寻观「标准库」之书。

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

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

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

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

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

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

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

  「匹配符序们」
）也。

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

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

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

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

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

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

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

也。
