1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
using System.Collections.Generic;
using System.Text;
namespace QtVsTools.SyntaxAnalysis
{
using static RegExprAssert;
////////////////////////////////////////////////////////////////////////////////////////////////
///
/// RegExprAssert ( -> RegExpr)
///
////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Asserts a pattern on the input string without consuming chars.
/// </summary>
///
public partial class RegExprAssert : RegExpr
{
public enum AssertLook { Ahead, Behind }
public AssertLook Context { get; set; }
public bool Negative { get; set; }
public RegExpr Expr { get; set; }
protected override IEnumerable<RegExpr> OnRender(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack<Token> tokenStack)
{
base.OnRender(defaultTokenWs, parent, pattern, ref mode, tokenStack);
if (mode.HasFlag(RenderMode.Assert))
throw new NestedAssertException();
switch (Context) {
case AssertLook.Ahead:
pattern.Append(Negative ? "(?!" : "(?=");
break;
case AssertLook.Behind:
pattern.Append(Negative ? "(?<!" : "(?<=");
break;
}
mode |= RenderMode.Assert;
return Items(Expr);
}
protected override void OnRenderEnd(RegExpr defaultTokenWs, RegExpr parent,
StringBuilder pattern, ref RenderMode mode, Stack<Token> tokenStack)
{
base.OnRenderEnd(defaultTokenWs, parent, pattern, ref mode, tokenStack);
pattern.Append(")");
mode &= ~RenderMode.Assert;
}
}
public abstract partial class RegExpr
{
RegExprAssert AsAssert()
{
if (this is RegExprAssert)
return this as RegExprAssert;
return new RegExprAssert
{
Context = AssertLook.Ahead,
Negative = false,
Expr = this
};
}
public static RegExprAssert AssertLookAhead(RegExpr expr)
{
var assert = expr.AsAssert();
return new RegExprAssert
{
Context = AssertLook.Ahead,
Negative = assert.Negative,
Expr = assert.Expr
};
}
public static RegExprAssert AssertLookBehind(RegExpr expr)
{
var assert = expr.AsAssert();
return new RegExprAssert
{
Context = AssertLook.Behind,
Negative = assert.Negative,
Expr = assert.Expr
};
}
public static RegExprAssert AssertNegated(RegExpr expr)
{
var assert = expr.AsAssert();
return new RegExprAssert
{
Context = assert.Context,
Negative = !assert.Negative,
Expr = assert.Expr
};
}
public delegate RegExprAssert AssertTemplate(RegExpr expr);
public class AssertExprBuilder
{
AssertTemplate Template { get; }
public AssertExprBuilder(AssertTemplate template)
{
Template = template;
}
public class Expr
{
public RegExprAssert Assert { get; set; }
public Expr(RegExprAssert assert) { Assert = assert; }
public static implicit operator RegExpr(Expr e)
{
return e.Assert;
}
public static RegExpr operator &(RegExpr rx1, Expr rx2)
{
return Concat(rx1, rx2);
}
public static RegExpr operator |(RegExpr rx1, Expr rx2)
{
return Choice(rx1, rx2);
}
}
public class NegateableExpr : Expr
{
public NegateableExpr(RegExprAssert assert) : base(assert) { }
public static Expr operator !(NegateableExpr x)
{
return new Expr(AssertNegated(x.Assert));
}
}
public NegateableExpr this[RegExpr expr] => new(Template(expr));
}
public class NestedAssertException : RegExprException
{
public NestedAssertException(string message = null) : base(message) { }
}
}
}
|
