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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// { dg-do compile { target c++11 } }
// Reduced from Mozilla SpiderMonkey, licensed under MPL-2.0.
template<typename T, unsigned N>
class Vector
{
public:
Vector() {}
unsigned length() const { return 0; }
};
class TokenStreamShared
{
};
template<typename CharT, class AnyCharsAccess>
class TokenStreamSpecific;
class TokenStreamAnyChars
: public TokenStreamShared
{
public:
TokenStreamAnyChars() {}
};
template<typename CharT>
class SourceUnits
{
public:
SourceUnits() {}
bool atEnd() const { return true; }
unsigned offset() const { return 0; }
bool matchCodeUnit(CharT c) { return true; }
};
class TokenStreamCharsShared
{
using CharBuffer = Vector<char16_t, 32>;
protected:
CharBuffer charBuffer;
protected:
explicit TokenStreamCharsShared() {}
};
template<typename CharT>
class TokenStreamCharsBase
: public TokenStreamCharsShared
{
public:
TokenStreamCharsBase()
: TokenStreamCharsShared(), sourceUnits()
{}
using SourceUnits = ::SourceUnits<CharT>;
bool matchCodeUnit(int expect) { return true; }
protected:
SourceUnits sourceUnits;
};
template<typename CharT, class AnyCharsAccess>
class GeneralTokenStreamChars
: public TokenStreamCharsBase<CharT>
{
using CharsBase = TokenStreamCharsBase<CharT>;
protected:
using CharsBase::CharsBase;
TokenStreamAnyChars& anyCharsAccess();
const TokenStreamAnyChars& anyCharsAccess() const;
};
template<typename CharT, class AnyCharsAccess> class TokenStreamChars;
template<class AnyCharsAccess>
class TokenStreamChars<char16_t, AnyCharsAccess>
: public GeneralTokenStreamChars<char16_t, AnyCharsAccess>
{
private:
using CharsBase = TokenStreamCharsBase<char16_t>;
using GeneralCharsBase = GeneralTokenStreamChars<char16_t, AnyCharsAccess>;
using Self = TokenStreamChars<char16_t, AnyCharsAccess>;
protected:
using GeneralCharsBase::anyCharsAccess;
using CharsBase::sourceUnits;
using typename GeneralCharsBase::SourceUnits;
protected:
using GeneralCharsBase::GeneralCharsBase;
bool getFullAsciiCodePoint(int lead, int* codePoint) {
if (lead == '\r') {
bool isAtEnd = sourceUnits.atEnd();
if (!isAtEnd)
sourceUnits.matchCodeUnit('\n');
} else if (lead != '\n') {
*codePoint = lead;
return true;
}
*codePoint = '\n';
return true;
}
};
template<typename CharT, class AnyCharsAccess>
class TokenStreamSpecific
: public TokenStreamChars<CharT, AnyCharsAccess>,
public TokenStreamShared
{
public:
using CharsBase = TokenStreamCharsBase<CharT>;
using GeneralCharsBase = GeneralTokenStreamChars<CharT, AnyCharsAccess>;
using SpecializedCharsBase = TokenStreamChars<CharT, AnyCharsAccess>;
public:
using GeneralCharsBase::anyCharsAccess;
private:
using typename CharsBase::SourceUnits;
private:
using TokenStreamCharsShared::charBuffer;
using CharsBase::sourceUnits;
public:
TokenStreamSpecific()
: SpecializedCharsBase()
{}
public:
bool advance(unsigned position) {
bool t = charBuffer.length() + 1 > 0;
auto offs = sourceUnits.offset();
return t && offs > 0;
}
};
class TokenStreamAnyCharsAccess
{
};
class TokenStream final
: public TokenStreamAnyChars,
public TokenStreamSpecific<char16_t, TokenStreamAnyCharsAccess>
{
using CharT = char16_t;
public:
TokenStream()
: TokenStreamAnyChars(),
TokenStreamSpecific<CharT, TokenStreamAnyCharsAccess>()
{}
};
class SyntaxParseHandler {};
class ParserBase
{
public:
TokenStreamAnyChars anyChars;
};
template<class ParseHandler, typename CharT> class GeneralParser;
template <class ParseHandler>
class PerHandlerParser : public ParserBase
{
};
template<class Parser>
class ParserAnyCharsAccess
{
};
template <class ParseHandler, typename CharT>
class Parser;
template <class ParseHandler, typename CharT>
class GeneralParser
: public PerHandlerParser<ParseHandler>
{
public:
TokenStreamSpecific<CharT, ParserAnyCharsAccess<GeneralParser>> tokenStream;
public:
GeneralParser();
};
template class TokenStreamCharsBase<char16_t>;
template class TokenStreamChars<char16_t, TokenStreamAnyCharsAccess>;
template class
TokenStreamChars<char16_t, ParserAnyCharsAccess<GeneralParser<SyntaxParseHandler, char16_t>>>;
template class
TokenStreamSpecific<char16_t, ParserAnyCharsAccess<GeneralParser<SyntaxParseHandler, char16_t>>>;
|
