В общем у меня готова реализация, которую можно назвать демонстрационной
Идея родилась как раз, когда Няшик мучил нас своими простынями нагенерированного кода для парсера
Причём огромная часть токенов имело вид <= >= == $ " >>> + - >>= и прочая штукенция
Сначала я сделал табличное преобразование первого символа. От case уйти не удалось, но зато появилась возможность сделать его последовательным, т.е. на x86 бинарное дерево поменять на jmp [eax * 4 + offset], т.е. сделал некое подобие хеша.
Соответственно и для задачи ТС предлагалось сделать array[Char] для первого символа, чтобы оперативно определять, символ S[i] является первым символом одной из искомых строк или нет. Вообще array[Char] - это частный быстрый вид хеша, его минус расход памяти, поэтому применим не всегда, но для первого символа - самое то.
Так вот, возвращаясь к задаче Няшика, я постоянно настаивал на том, что для скорости компиляции лучше использовать байтовую кодировку (UTF-8, например). Потом возникла мысль, что можно "хешировать" сразу 2 символа, но тогда понадобится 64Кб таблица. А потом возникла мысль, что можно "хешировать" сразу 3 символа, причём это может занять значительно меньше памяти, а все операторные лексемы (типа <= >= ===) будут охвачены, уйдут простыни кода и многочисленные ошибки предсказаний ветвлений. Вот пример.
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.
type
TLexeme = (T_UNKNOWN, T_ASSIGN, T_GREATER, T_IS_EQUAL, T_DOUBLE_ARROW, T_SR,
T_IS_GREATER_OR_EQUAL, T_IF, T_IS_IDENTICAL, T_SR_EQUAL, T_USE, T_VAR, T_LIST,
T_GOTO, T_ISSET, T_RETURN, T_DIR, T_ENDWHILE, T_PROTECTED, T_ENDSWITCH, T_CLASS_C,
T_REQUIRE_ONCE);
const
LEXEME_LENGTH: array[Ord(Low(TLexeme))..Ord(High(TLexeme))] of Byte = (
1, // :[?]: T_UNKNOWN
1, // [=]: T_ASSIGN
1, // [>]: T_GREATER
2, // [==]: T_IS_EQUAL
2, // [=>]: T_DOUBLE_ARROW
2, // [>>]: T_SR
2, // [>=]: T_IS_GREATER_OR_EQUAL
2, // [if]: T_IF
3, // [===]: T_IS_IDENTICAL
3, // [>>=]: T_SR_EQUAL
3, // [use]: T_USE
3, // [var]: T_VAR
4, //
: T_LIST
4, // [goto]: T_GOTO
5, // [isset]: T_ISSET
6, // [return]: T_RETURN
7, // [__DIR__]: T_DIR
8, // [endwhile]: T_ENDWHILE
9, // [protected]: T_PROTECTED
9, // [endswitch]: T_ENDSWITCH
9, // [__CLASS__]: T_CLASS_C
12 // [require_once]: T_REQUIRE_ONCE
);
const
TEST_CODE = '= > == => >> >= iF === >>= UsE vAr list goto' +
'isset return __DIR__ endwhile protected endswitch __CLASS__ require_once';
procedure LexemeFound(const Lexeme: TLexeme);
begin
Writeln(GetEnumName(TypeInfo(TLexeme), Ord(Lexeme)));
end;
procedure ParseLexemes(const Text: AnsiString);
label
unknown;
type
HugeByteArray = array[0..High(Integer) - 1] of Byte;
var
S: ^HugeByteArray;
Value: NativeUInt;
begin
S := Pointer(Text);
if (S = nil) then Exit;
repeat
// spaces, #0
Value := FIRST_CHARS[S[0]];
if (Value <= 1) then
repeat
Inc(PByte(S));
if (Value = 0{#0}) then Exit;
Value := FIRST_CHARS[S[0]];
until (Value > 1);
// offset (3 tables)
Inc(Value, SECOND_CHARS[S[1]]);
Inc(Value, THIRD_CHARS[S[2]]);
// Lexeme
Value := LEXEME_TABLE[Value];
if (Value >= NativeUInt(T_LIST){4 symbols}) then
case Value of
// 4, //
: T_LIST
Ord(T_LIST):
begin
if (S[3] or $20 <> Ord('t')) then goto unknown;
end;
// 4, // [goto]: T_GOTO
Ord(T_GOTO):
begin
if (S[3] or $20 <> Ord('o')) then goto unknown;
end;
// 5, // [isset]: T_ISSET
Ord(T_ISSET):
begin
if (S[3] or $20 <> Ord('e')) or (S[4] or $20 <> Ord('t')) then goto unknown;
end;
// 6, // [return]: T_RETURN
Ord(T_RETURN):
begin
if (S[3] or $20 <> Ord('u')) or (S[4] or $20 <> Ord('r')) or
(S[5] or $20 <> Ord('n')) then goto unknown;
end;
// 7, // [__DIR__]: T_DIR
Ord(T_DIR):
begin
if (S[3] or $20 <> Ord('i')) or (S[4] or $20 <> Ord('r')) or
(S[5] <> Ord('_')) or (S[6] <> Ord('_')) then goto unknown;
end;
// 8, // [endwhile]: T_ENDWHILE | 9, // [endswitch]: T_ENDSWITCH
Ord(T_ENDWHILE):
begin
case (S[3] or $20) of
Ord('w'):
begin
if (S[4] or $20 <> Ord('h')) or (S[5] or $20 <> Ord('i')) or
(S[6] or $20 <> Ord('l')) or (S[7] or $20 <> Ord('e')) then goto unknown;
end;
Ord('s'):
begin
Value := Ord(T_ENDSWITCH);
if (S[4] or $20 <> Ord('w')) or (S[5] or $20 <> Ord('i')) or
(S[6] or $20 <> Ord('t')) or (S[7] or $20 <> Ord('c')) or
(S[8] or $20 <> Ord('h')) then goto unknown;
end;
else
goto unknown;
end;
end;
// 9, // [protected]: T_PROTECTED
Ord(T_PROTECTED):
begin
if (S[3] or $20 <> Ord('t')) or (S[4] or $20 <> Ord('e')) or
(S[5] or $20 <> Ord('c')) or (S[6] or $20 <> Ord('t')) or
(S[7] or $20 <> Ord('e')) or (S[8] or $20 <> Ord('d')) then goto unknown;
end;
// 9, // [__CLASS__]: T_CLASS_C
Ord(T_CLASS_C):
begin
if (S[3] or $20 <> Ord('l')) or (S[4] or $20 <> Ord('a')) or
(S[5] or $20 <> Ord('s')) or (S[6] or $20 <> Ord('s')) or
(S[7] <> Ord('_')) or (S[8] <> Ord('_')) then goto unknown;
end;
// 12 // [require_once]: T_REQUIRE_ONCE
Ord(T_REQUIRE_ONCE):
begin
if (S[3] or $20 <> Ord('u')) or (S[4] or $20 <> Ord('i')) or
(S[5] or $20 <> Ord('r')) or (S[6] or $20 <> Ord('e')) or
(S[7] <> Ord('_')) or (S[8] or $20 <> Ord('o')) or (S[9] or $20 <> Ord('n')) or
(S[10] or $20 <> Ord('c')) or (S[11] or $20 <> Ord('e')) then goto unknown;
end;
else
{ вообще в данной ситуации никакого else не будет, но для иллюстрации выглядит неплохо }
unknown:
Value := Ord(T_UNKNOWN);
end;
// found lexeme
LexemeFound(TLexeme(Value));
Inc(PByte(S), LEXEME_LENGTH[Value]);
until (False);
end;
Вот что на выходе:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
T_ASSIGN
T_GREATER
T_IS_EQUAL
T_DOUBLE_ARROW
T_SR
T_IS_GREATER_OR_EQUAL
T_IF
T_IS_IDENTICAL
T_SR_EQUAL
T_USE
T_VAR
T_LIST
T_GOTO
T_ISSET
T_RETURN
T_DIR
T_ENDWHILE
T_PROTECTED
T_ENDSWITCH
T_CLASS_C
T_REQUIRE_ONCE
Но многобуквенные лексемы я бы как-нибудь приспособил под универсальный компаратор, честно говоря. Это вообще не та ситуация, где нужно использовать кодогенерацию, ИМХО.
