豫言源码浏览器 / Source Browser

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312

寻观「标准库」之书。

寻观「编译器核心」之「编译步骤」之「语法分析」之「具体语法树」之书。

寻观「编译器核心」之「编译数据」之「抽象绑定树结构」之「抽象语法树」之「总集」之书。

寻观「编译器核心」之「编译数据」之「操作符」之「操作符操作」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「操作符数据结构」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「内建操作符」之「总集」之书。

寻观「编译器核心」之「编译数据」之「编译配置」之「编译期输出」之书。
寻观「编译器核心」之「编译步骤」之「语法分析」之「注释操作」之书。

「抽栈素」立「元类型」也。

「：把相同关键词的归为一组：」
「合并操作符栈素」乃化（「列」于「栈素」） 「：已有：」而
  化（「列」于（「字符串」 「：当前操作符的字符串：」
      合（「操作符」合「整数」） 「：当前操作符：」
      合（「列」于「表达式」） 「：剩余栈素：」
    ））而
  「：返回已有，单个栈素，剩余输入：」
  「列」于（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」））也。
「合并操作符栈素」者会「已有」而会「待处理」而
  鉴「待处理」而
    有「罄」则「罄」
    或有（「缀」于（「关键词」与（「操符」与「序号」）与「后输入」）于「待处理尾」）则
      「：我们挑出处理尾中相同长度的关键词组件放在一起，剩余的再继续处理：」
      （「缀」授以（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」）））
        于（「已有」与（（（「列」于「栈素」）也（（「列」【（「栈操作符」
            于（（「缀」授以（「操作符」合「整数」））于（「操符」与「序号」）
            于（（「滤态射」
              授以（「字符串」合（「操作符」合「整数」）合（「列」于「表达式」））授以（「操作符」合「整数」））
              于（会
              「项」而
                若（「等」于（「串长度」于「关键词」）于（「串长度」于（「三对子取零」于「项」）））
                则
                  （「可有」于（「三对子取一」于「项」））
                否则
                  「可无」）于「待处理尾」））于「关键词」）】）））
          ）与「后输入」
        ）于（「合并操作符栈素」于「已有」于（（（「滤」授以（「字符串」合（「操作符」合「整数」）合（「列」于「表达式」
                ）））
                于（会「项」而（「不等于」于（「串长度」于「关键词」）于（「串长度」于（「三对子取零」于「项」））））于
                  「待处理尾」
          ）））也。

「匹配操作符字符」乃化（「列」于「表达式」） 「：输入：」而
  化（「列」于（「操作符」 「：关键词所在操作符：」
            合「整数」 「：字符串组件序号：」
    ））而
    「列」于（「字符串」 「：当前操作符的字符串：」
      合（「操作符」合「整数」） 「：当前操作符：」
      合（「列」于「表达式」） 「：剩余栈素：」
    ）也。
「匹配操作符字符」者（会「输入」而会「符序们」而
  虑「匹配符序们」者（（「滤态射」授以（「操作符」合「整数」）授以（「字符串」合（「操作符」合「整数」）合（「列」于
            「表达式」
        ）））于（会「符序」而
          虑「操符」者（「二对子取零」授以「操作符」授以「整数」）于「符序」而
          虑「序号」者（「二对子取一」授以「操作符」授以「整数」）于「符序」而
          虑「关键词」者「获取操作符组件字符串」于「操符」于「序号」而
          鉴「顶层匹配」于「输入」于（「获取字符」于「关键词」）
而
            有（「可有」于「后输入」）则「可有」于（「关键词」与（「操符」与「序号」）与「后输入」）
            或有「可无」则「可无」
    ）于「符序们」
  ）而

  「匹配符序们」
）也。

「匹配操作符字符随后合并栈素」乃化（「列」于「栈素」） 「：已有栈素，应当不会改变：」而
  化（「列」于「表达式」） 「：输入：」而
  化（「列」于（「操作符」 「：关键词所在操作符：」
            合「整数」 「：字符串组件序号：」
    ））而
    「列」于（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」）） 「：如果顶层匹配成功，返回作为关键字的栈素以及之后的输入：」
也。
「匹配操作符字符随后合并栈素」者（会「已有」而会「输入」而会「符序们」而
  虑「匹配符序们」者「匹配操作符字符」于「输入」于「符序们」而
  「合并操作符栈素」于「已有」于「匹配符序们」
）也。

「：扫描绑定返回绑定式和下一个字符串组件：」
「扫描绑定」乃化（「列」于「表达式」）而化「组件」而化「栈素」而（「或可有」
    于（（「列」于「栈素」）合（「列」于「表达式」）））也。
「扫描绑定」者会「输入」而会「截止」而会「截止栈素」而
  虑「处理名称」者（化「字符串」而化（「列」于「字符串」）而化（「列」于「字符串」）而化（「列」于「表达式」） 「：名称后内容：」而
      （「或可有」于（（「列」于「栈素」）合（「列」于「表达式」）））也会「名称」而会「前注释」而会「后注释」
    而会
    「名称后」而
    鉴「顶层匹配」于「名称后」于（「获取字符」于（「读取组件字符串」于「截止」））而
      有（「可有」于「余下输入」）则（「可有」于（（（「列」【（「栈绑定」于「名称」于「前注释」于「后注释」），「截止栈素」】））
          与「余下输入」
        ））
      或有「可无」则（「可无」））而

  鉴「输入」而
    有（「缀」于「名称式」于「名称后」）则（鉴（「去除表达式表层注释」于「名称式」）而
      有（「自由变量」于「名称」）则「处理名称」于「名称」于（「表达式表层前置注释」于「名称式」）
        于（「表达式表层后置注释」于「名称式」）于「名称后」
      或有「其他」则「可无」授以（（「列」于「栈素」）合（「列」于「表达式」）））
    或有「其他」则「可无」授以（（「列」于「栈素」）合（「列」于「表达式」））
也。

「：匹配可以作为开始的操作符：」
「处理下个字符开始」乃化（「列」于「栈素」）而化（「列」于「表达式」）而「列」
  于（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」））也。
「处理下个字符开始」者会「已有」而会「输入」而
  （鉴「输入」而
    有「罄」则「罄」
    或有（「缀」于（「式节点」于（「带注释节点」于「忽略前注释」于「忽略后注释」）于（（「列」【「原式」】）））
      于「尾」）则（鉴「原式」而
      有（「式节点」于（「字符串节点」于「串」）于「罄」）则
        （「列」【（「已有」与（（「列」【（「栈式」于（「式节点」
            于（「带注释节点」于「忽略前注释」于「忽略后注释」）
            于（（「列」【「原式」】）））于（（「列」【（「构造语义标记草稿」于「字符串标记」于「串」）】）））】）
          ）与「尾」
        ）】）
      或有（「自由变量」于「名」）则
        （「列」【（「已有」与（（「列」【（「栈式」于（「式节点」
            于（「带注释节点」于「忽略前注释」于「忽略后注释」）
            于（（「列」【「原式」】）））于（（「列」【（「构造语义标记草稿」于「引用标识符标记」于「名」）】）））】）
          ）与「尾」
        ）】）
      或有「其他」则「发生事故」于『带注释词法元素不是字符串或标识符』
    ）
    或有（「缀」于（「式节点」于（「具体字符节点」于「始」）于「罄」）于「尾」）
    则（虑「关键词们」者
          「获取所有开始关键词」于
          「默认操作符」而
        虑「可能解析」者
          「匹配操作符字符随后合并栈素」于
          「已有」于「输入」于「关键词们」
        而
        （若（「大于」于（「长度」于「可能解析」）于「零」）则「可能解析」否则「罄」））
    或有（「缀」于（「式节点」于（「字符串节点」于「串」）于「罄」）于「尾」）则（（「列」【（「已有」与（（「列」【（「栈式」于（「式节点」于（「字符串节点」于「串」）于「罄」）
          于（（「列」【（「构造语义标记草稿」于「字符串标记」于「串」）】）））】）
        ）与「尾」
      ）】）
    ）
    或有（「缀」于（「自由变量」于「名」）于「尾」）则（（「列」【（「已有」与（（「列」【（「栈式」于（「自由变量」于「名」）
          于（（「列」【（「构造语义标记草稿」于「引用标识符标记」于「名」）】）））】）
        ）与「尾」
      ）】）
    ）
    或有「其他2」则（「发生事故」于（『解表73：输入是』附（「表达式列表示」于「输入」））））也。

「：匹配可以作为一个操作符后续的操作符，
也就是获取的新操作符组件必须可以消除前面的输入
，不可以添加新的组件：」
「：我们目前假设不存在连续的参数组件，TODO：探究可否放松该要求：」
「处理下个字符后续」乃化（「列」于「栈素」）而化（「列」于「表达式」）而「列」
  于（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」））也。
「处理下个字符后续」者会「已有」而会「输入」而
  （鉴「输入」而
    有「罄」则「罄」
    或有（「缀」于（「式节点」于（「带注释节点」于「忽略前注释」于「忽略后注释」）于（（「列」【「原式」】）））于
      「尾」）则（鉴「原式」而
      有（「式节点」于（「字符串节点」于「忽略串」）于「罄」）则「罄」
      或有（「自由变量」于「忽略名」）则「罄」
      或有「其他」则「发生事故」于『带注释词法元素不是字符串或标识符』
    ）
    或有（「缀」于（「式节点」于（「具体字符节点」于「始」）于「罄」）于「尾」）
    则（虑「关键词们」者
          「获取所有继续关键词」于「一」于
          「默认操作符」而
        虑「可能解析」者
          「匹配操作符字符随后合并栈素」于
          「已有」于「输入」于「关键词们」
        而
        （若（「大于」于（「长度」于「可能解析」）于「零」）则「可能解析」否则（「罄」）））
    或有（「缀」于（「式节点」于（「字符串节点」于「串」）于「罄」）于「尾」）
    则（「罄」）
    或有（「缀」于（「自由变量」于「名」）于「尾」）
    则（「罄」）
    或有「其他2」则（「发生事故」于（『解表73：输入是』附（「表达式列表示」于「输入」））））也。

「：输入头部
    如果是字符则查询对应的关键字，可能有多个匹配项，
        若无匹配，则查询最长的不认识的名字：」
「分析输入」乃化（「列」于「栈素」）而化（「列」于「表达式」）而化（化「字符串」而化（「列」于「栈素」）而「有」）而
  「列」于（（「列」于「栈素」） 「：新的已有，倒序：」
    合（「列」于「栈素」） 「：正顺序：」
    合（「列」于「表达式」））也。
「：分析输入会返回新的已有栈，因为对于输入的分析可能会使得栈上的元素发生改变，
        我们要保证所有的返回的输入解析一定可以被规约，所以要在解析时排除不可规约的可能性：」
「分析输入」者会「已有」而会「输入」而会「调试」而

  「：查找下一个操作符在已有栈中的序数：」
  鉴（（「查找元素序数条件」授以「栈素」）于（会「素」而鉴「素」而
        有（「栈操作符」于「整符及序号们」于「忽略关键词」）
        则
          「阳」
        或有「其他素」则「阴」
    ）于「已有」
  ）而
    有（「可有」于「序数」）则（ 「：序数表示栈顶到第一个操作符所要跳过的表达式的个数：」
      若（「大于」于「序数」于「零」）则（
        「：序数必须是一，因为我们假设不存在两个连续的参数。两个连续的参数将会使得很多的优化都不可以执行。：」
        若（「大于」于「序数」于「一」）
        则
          「发生事故」于『栈上不应当存在连续表达式！』
        否则
          （递归虑「获得可能操作符匹配结果」其化「整数」 「：当前检查的字符串组件在已有栈中序数，
                                    根据单参数假设，序数必须指向一个字符串组件，
                                    组件的序数加二即是下个要匹配输入 （此处序数含义发生改变！有栈序数和组件序数）
                                    ：」而
              「列」于（「字符串」 「：当前操作符的字符串：」
              合（「操作符」合「整数」） 「：当前操作符：」
              合（「列」于「表达式」） 「：剩余栈素：」）者
                会「序数」而
                  鉴（（「第N个」授以「栈素」）于「序数」于「已有」）而
                    有（「栈操作符」于「当前符序们」于「当前关键词」）则（ 「：TODO 这边应当更新第N个，而不是复制：」
                      虑「无」者「非常详细调试打印行」于（会「无」而
                        『[D][D]正在匹配操作符，序数：』附（「整数表示」于「序数」）附
                        『，操作符：』附（「栈素表示」于（「栈操作符」于「当前符序们」于「当前关键词」）））而
                      虑「操作符后续解析」者（（「串联」授以（「字符串」
                              合（「操作符」合「整数」）合（「列」于「表达式」）））
                              于（（「态射」）于「当前符序们」
                              于（会
                            「当前符序」而虑「整符」者（「二对子取零」授以「操作符」授以「整数」）于「当前符序」而
                                          虑「序号」者（「二对子取一」授以「操作符」授以「整数」）于「当前符序」而
                                          虑「组件们」者「获取所有组件」于「整符」而
                                          「：取得输入组件的位置：」
                                          若（「小于」于（「加」于「序号」于「二」）于（「长度」于「组件们」））
                                          「：下一个输入仍然是组件内部：」
                                          则
                                            （虑「下个组件」者（「第N个」授以「组件」）
                                                于（「加」于「序号」于「二」）于「组件们」而若「组件是字符串组件」
                                                于（（「第N个」授以「组件」）
                                                于（「加」于「序号」于「二」）于「组件们」）则（（「匹配操作符字符」于
                                                    「输入」于（（（「列」于（「操作符」合「整数」））也（（「列」【（「整符」与（「加」于「序号」于「二」））】））））））
                                                否则
                                                  （ 「：下个字符是表达式，如果我们强制不可以出现连续的表达式参数，这个case是不可能的：」
                                                    「： 处理下个字符开始于输入 ：」
                                                    「发生事故」于『组件中纯真连续的参数』
                                                  ））
                                          否则
                                            （若（「等」于（「加」于「序号」于「二」）于（「长度」于「组件们」）） 「：正好是这个组件的完结，我们去寻找上一个组件：」
                                            则
                                              （虑「下个序数」者（「加」于「序数」于（「加」于「序号」于「一」））
                                                而
                                                若（「小于」于「下个序数」于（「长度」于「已有」）） 「：栈中仍然存在上个组件：」
                                                则
                                                  （「获得可能操作符匹配结果」于「下个序数」）
                                                否则
                                                  （「罄」） 「：栈中不存在上个组件：」
                                              ）
                                            否则
                                              （「发生事故」于『组件的长度不正确』）））））而
                      「操作符后续解析」
                    ）
                    或有「其他栈操作符」则「发生事故」于『不可能285，期待栈操作符』
                而
                （「附加」授以（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」）））
                      于（「合并操作符栈素」于「已有」于（「获得可能操作符匹配结果」于「序数」））
                      于（「处理下个字符后续」于「已有」于「输入」）））
      否则
        （
          「：序数等于零， 后面可以是任意表达式：」
          鉴「已有」而
            「：我们需要特殊处理绑定式：」
            有（「缀」于（「栈操作符」于「整符及序号们」于「当前关键词」）于「尾」）则 「：我们默认栈操作符不是结尾，结尾操作符必须归一，所以本操作符后必须跟一个表达式：」
            （
              「：处理绑定后续，我们会每个绑定单独分出一个分支，此处没有优化：」
              （「附加」授以（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」）））
                于（（「串联」授以（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于「表达式」）））
                于（（「态射」）于
                「整符及序号们」于（会「整符及序号」而
                  虑「整符」者（「二对子取零」授以「操作符」授以「整数」）于「整符及序号」而
                  虑「序号」者（「二对子取一」授以「操作符」授以「整数」）于「整符及序号」而鉴（「获取随后的绑定信息」于
                    「整符」于「序号」
                  ）而
                    有（「可有」于「次字」）则（鉴（「扫描绑定」于「输入」于「次字」
                          于（「栈操作符」于（（（「列」于（「操作符」合「整数」））也（（「列」【（「整符」与（「加」于「序号」于「二」））】））））
                          于（「读取组件字符串」于「次字」）））而
                      有（「可有」于「绑素后」）则（（（「列」于（（「列」于「栈素」）合（「列」于「栈素」）合（「列」于
                                「表达式」
                            ）））也（（「列」【（（（「缀」授以「栈素」）
                              于（「栈操作符」于（（（「列」于（「操作符」合「整数」））也（（「列」【（「整符」与（「序号」））】））））于
                                「当前关键词」）于「尾」
                            ）与（「绑素后」中「零」）与（「绑素后」中「一」））】）））
                      ）
                      或有「可无」则「罄」
                    ） 「：绑定必须解析成功，否则报错：」
                    或有「可无」则（「罄」））））
                    于（
                    「：处理非绑定后续：」
                    虑「非绑定符序们」者（「滤」授以（「操作符」合「整数」））
                      于（会
                      「整符及序号」而虑「整符」者（「二对子取零」授以「操作符」授以「整数」）于
                      「整符及序号」而虑「序号」者（「二对子取一」授以「操作符」授以「整数」）于
                      「整符及序号」而鉴（「获取随后的绑定信息」于「整符」于「序号」）而
                        有（「可有」于「次字」）则（「阴」）
                        或有「可无」则（「阳」））于「整符及序号们」而若（「大于」
                        于（「长度」于「非绑定符序们」）于
                        「零」
                      ）则（「处理下个字符开始」于（（「缀」授以「栈素」）
                          于（「栈操作符」于「非绑定符序们」于「当前关键词」）于「尾」）于「输入」
                      ）
                        否则
                          「罄」））
            或有「其他已有」则（「处理下个字符开始」于「已有」于「输入」）））
    或有「可无」则（若（「大于」于（「长度」于「已有」）于「零」）则（「处理下个字符后续」于「已有」于「输入」 「：栈上有表达式，可以处理后续的字符：」
      ）
    否则
      （「处理下个字符开始」于「已有」于「输入」 「：我们刚开始，可以处理开始的字符：」
      ））

也。