豫言源码浏览器

yuyan · 573 行 · 30670 字节 · UTF-8
寻观「标准库」之书。

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

寻观「编译器核心」之「顺序标识符」之「顺序标识符」之书。

寻观「编译器核心」之「编译数据」之「操作符」之「操作符数据结构」之书。
寻观「编译器核心」之「编译数据」之「操作符」之「操作符操作」之书。
寻观「编译器核心」之「编译步骤」之「语法分析」之「整数小数解析」之书。
寻观「编译器核心」之「编译步骤」之「语法分析」之「注释操作」之书。

「操作符近似类型占位式」乃「表达式」也。
「操作符近似类型占位式」者「式节点」于「近似类型占位节点」于「罄」也。

「解析元组解构序数」乃化「表达式」而「整数」也。
「解析元组解构序数」者会「式」而
  鉴「式」而
    有（「式节点」于（「带注释节点」于「忽略前注释」于「忽略后注释」）于（（「列」【「原式」】）））则
      「解析元组解构序数」于「原式」
    或有（「式节点」于（「整数节点」于「序数」）于「罄」）则「序数」
    或有（「自由变量」于「名」）则（
      鉴（「尝试解析字符串为数字」于「名」）而
        有（「可有」于（「整数解析」于「序数」））则「序数」
        或有（「可有」于（「小数解析」于「数」于「整小部」））则
          「发生事故」于『中后必须是整数：』附「名」
        或有「可无」则
          「发生事故」于『中后必须是整数：』附「名」
    ）
    或有「其他」则
      「发生事故」于『中后必须是整数：』附（「表达式表示」于「其他」）
也。

「顺序执行操作符」乃「操作符」也。
「顺序执行操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『；』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「前式」，「后式」】）则（「可有」
          于（「式节点」
            于（「顺序执行节点」）
            于（（「列」【「前式」，「后式」】）） 「：最后的组件是在结构中绑定的，所以，TODO：修复调用函数的bug：」））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇；〇』
也。

「内联虑操作符」乃「操作符」也。
「内联虑操作符」者
  「构造操作符」
    于（「列」【
      「字符串组件」于『虑』，
      「绑定组件」，
      「字符串组件」于『者』，
      「元素组件」，
      「字符串组件」于『而』，
      「元素组件」
    】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有「列」【「绑定名」，「定义式」，「后式」】则（「可有」
          于（「转移表达式表层注释」
            于「绑定名」
            于（「式节点」
              于「内联虑」
              于（（「列」【「定义式」，（「进行抽象」于（「获取绑定字符串」于「绑定名」）于「后式」）】）） 「：最后的组件是在结构中绑定的，所以：」）））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『虑□者〇而〇』
也。

「递归内联虑操作符」乃「操作符」也。
「递归内联虑操作符」者
  「构造操作符」
    于（「列」【
      「字符串组件」于『递归虑』，
      「绑定组件」，
      「字符串组件」于『其』，
      「元素组件」，
      「字符串组件」于『者』，
      「元素组件」，
      「字符串组件」于『而』，
      「元素组件」
    】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有「列」【「绑定名」，「定义域」，「定义式」，「后式」】则（「可有」
          于（「转移表达式表层注释」
            于「绑定名」
            于（「式节点」
              于「内联虑」
              于（（「列」【
                （「式节点」
                  于（「递归节点」）
                  于（（「列」【「定义域」，（「进行抽象」于（「获取绑定字符串」于「绑定名」）于「定义式」）】））），
                  （「进行抽象」于（「获取绑定字符串」于「绑定名」）于「后式」）
              】）））））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『递归虑□其〇者〇而〇』
也。

「类型判断操作符」乃「操作符」也。
「类型判断操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『也』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「类」，「式」】）则（「可有」
          于（「式节点」
            于（「类型判断节点」）
            于（（「列」【「类」，「式」】）） 「：最后的组件是在结构中绑定的，所以：」））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇也〇』
也。

「顶层文件操作符」乃化「字符串」而化「结构名称操作」而「操作符」也。
「顶层文件操作符」者会「符名」而会「作」而
  「构造操作符」
    于（「列」【「字符串组件」于「符名」，「元素组件」，「字符串组件」于『之书』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「结构名」】）则
          （「可有」于（「式节点」于（「文件操作近似类型节点」于「作」）于（（「列」【「结构名」】））））
        或有「其他」则
          「发生事故」于『顶层文件操作参数个数不匹配』
    ）
    于（「符名」附『〇之书』）
也。

「顶层寻操作符」乃「操作符」也。
「顶层寻操作符」者「顶层文件操作符」于『寻』于「结构寻」也。

「顶层寻观操作符」乃「操作符」也。
「顶层寻观操作符」者「顶层文件操作符」于『寻观』于「结构寻观」也。

「顶层寻诵操作符」乃「操作符」也。
「顶层寻诵操作符」者「顶层文件操作符」于『寻诵』于「结构寻诵」也。

「顶层寻观诵操作符」乃「操作符」也。
「顶层寻观诵操作符」者「顶层文件操作符」于『寻观诵』于「结构寻观诵」也。

「顶层观操作符」乃「操作符」也。
「顶层观操作符」者「顶层文件操作符」于『观』于「结构观」也。

「顶层观诵操作符」乃「操作符」也。
「顶层观诵操作符」者「顶层文件操作符」于『观诵』于「结构观诵」也。

「顶层诵操作符」乃「操作符」也。
「顶层诵操作符」者「顶层文件操作符」于『诵』于「结构诵」也。

「顶层构造声明操作符」乃「操作符」也。
「顶层构造声明操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『立』，「元素组件」，「字符串组件」于『也』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「名」，「类」】）
        则（
          虑「构造器名」者「获取绑定字符串」于「名」而
          虑「构造器实现」者
            「式节点」
              于（「唯一构造器节点」于（「行」于「下个序数」）于「当前文件名」于「构造器名」）
              于（（「列」【「类」】））
          而
          「可有」
            于（「转移表达式表层注释」
              于「名」
              于（「式节点」于「构造声明近似类型节点」于（（「列」【「构造器实现」】））））
        ）
        或有「其他」则
          「发生事故」于『顶层构造声明参数个数不匹配』
    ）于『〇立〇也』
也。

「顶层类型声明操作符」乃「操作符」也。
「顶层类型声明操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『乃』，「元素组件」，「字符串组件」于『也』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「名」，「类」】）则
          （「可有」于（「式节点」于「类型声明近似类型节点」于（（「列」【「名」，「类」】））））
        或有「其他」则
          「发生事故」于『顶层类型声明参数个数不匹配』
    ）于『〇乃〇也』
也。

「顶层定义声明操作符」乃化「字符串」而化「定义透明性」而「操作符」也。
「顶层定义声明操作符」者会「符名」而会「透明性」而
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于「符名」，「元素组件」，「字符串组件」于『也』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「名」，「定义」】）则（「可有」
          于（「式节点」
            于（「定义声明近似类型节点」于「透明性」）
            于（「列」【「名」，「操作符近似类型占位式」，「定义」】）））
        或有「其他」则
          「发生事故」于『顶层定义声明参数个数不匹配』
    ）
    于（『〇』附「符名」附『〇也』）
也。

「顶层不透明定义声明操作符」乃「操作符」也。
「顶层不透明定义声明操作符」者「顶层定义声明操作符」于『者』于「定义不透明」也。

「顶层透明定义声明操作符」乃「操作符」也。
「顶层透明定义声明操作符」者「顶层定义声明操作符」于『即』于「定义透明」也。

「获取结构投影名称」乃化「表达式」而化「表达式」而「或可有」于「表达式」也。
「获取结构投影名称」者会「体」而会「式」而
  鉴「式」而
    有（「式节点」于（「带注释节点」于「忽略前注释」于「忽略后注释」）于（（「列」【「原式」】）））则（
      鉴（「获取结构投影名称」于「体」于「原式」）而
        有（「可有」于「投影式」）则
          「可有」于（「转移表达式表层注释」于「式」于「投影式」）
        或有「可无」则「可无」
    ）
    或有「自由变量」于「名」则（「可有」于（「式节点」于（「结构投影」于（「名」））于（（「列」【「体」】））））
    或有「它」则
      「发生事故」于『内65：之的参数必须是自由变量，却得到了』附（「表达式表示」于「它」）
也。

「结构投影符」乃「操作符」也。
「结构投影符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『之』，「元素组件」】）
    于（「结构投影符标号」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「体」，「之参数」】）则
          （「获取结构投影名称」于「体」于「之参数」）
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇之〇』
也。

「括号表达式操作符」乃「操作符」也。
「括号表达式操作符」者
  「构造操作符」
    于（「列」【「字符串组件」于『（』，「元素组件」，「字符串组件」于『）』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「内式」】）则
          （「可有」于「内式」）
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『（〇）』
也。

「字符串拼接操作符」乃「操作符」也。
「字符串拼接操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『附』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「左」，「右」】）则（「可有」
          于（「式节点」
            于「内联虑」
            于（（「列」【
              （「式节点」于「类型判断节点」于（（「列」【「字符串类型」，「左」】））），
              （「构造抽象」
                于『附左』
                于（会「左名」而
                  「式节点」
                    于「内联虑」
                    于（（「列」【
                      （「式节点」于「类型判断节点」于（（「列」【「字符串类型」，「右」】））），
                      （「构造抽象」
                        于『附右』
                        于（会「右名」而
                          「式节点」
                            于「类型判断节点」
                            于（（「列」【
                              「字符串类型」，
                              （「式节点」
                                于
                                「外部调用节点」
                                  于（（「列」【
                                    （「式节点」于（「字符串节点」于『豫言_字符串拼接』）于「罄」），
                                    （「式节点」
                                      于（「元组构造节点」）
                                      于（（「列」【（「自由变量」于「左名」），（「自由变量」于「右名」）】）））
                                  】）））
                            】））））
                    】））））
            】））））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇附〇』
也。

「函数调用操作符」乃「操作符」也。
「函数调用操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『于』，「元素组件」】）
    于（「函数调用操作符标号」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「函」，「参」】）则
          （「可有」于（「添加函数调用参数」于「函」于「显式」于「参」））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇于〇』
也。

「隐函数调用操作符」乃「操作符」也。
「隐函数调用操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『授以』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「函」，「参」】）则
          （「可有」于（「添加函数调用参数」于「函」于「隐式」于「参」））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇授以〇』
也。

「对子构造操作符」乃「操作符」也。
「对子构造操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『与』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「左」，「右」】）则（
          鉴「右」而
            有
          「式节点」于（「元组构造节点」）于「右元素们」则
            （「可有」于（「式节点」于（「元组构造节点」）于（「缀」于「左」于「右元素们」）））
            或有「其他右式」则
              （「可有」于（「式节点」于（「元组构造节点」）于（（「列」【「左」，「右」】））））
        ）
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇与〇』
也。

「对子类型操作符」乃「操作符」也。
「对子类型操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『合』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「左」，「右」】）则（
          鉴「右」而
            有
          「式节点」于（「元组类型节点」）于「右元素们」则
            （「可有」于（「式节点」于（「元组类型节点」）于（「缀」于「左」于「右元素们」）））
            或有「其他右式」则
              （「可有」于（「式节点」于（「元组类型节点」）于（（「列」【「左」，「右」】））））
        ）
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇合〇』
也。

「读取逗号序列项」乃化「表达式」而（「列」于「表达式」）也。
「读取逗号序列项」者会「式」而
  鉴「式」而
    有（「式节点」于「逗号序列节点」于「项们」）则「项们」
    或有「其他」则（「列」【「其他」】）
也。

「构造多态列表达式」乃化（「列」于「表达式」）而「表达式」也。
「构造多态列表达式」者会「项们」而
  （「从右折叠」授以「表达式」授以「表达式」）
  于（会「项」而会「尾」而
  「添加函数调用参数」于（「添加函数调用参数」于（「自由变量」于『缀』）于「显式」于「项」）
  于「显式」
  于「尾」
  ）
  于（「自由变量」于『罄』）
  于「项们」
也。

「构造外部调用参数容器」乃化（「列」于「表达式」）而「表达式」也。
「构造外部调用参数容器」者会「参数们」而
  鉴「参数们」而
    有「罄」则「自由变量」于『元』
    或有（（「列」【「参数」】））则「参数」
    或有「多个参数」则
      「式节点」于「元组构造节点」于「多个参数」
也。

「阐述通用序列」乃化「表达式」而「或可有」于「表达式」也。
「阐述通用序列」者会「序列」而
  鉴「序列」而
    有（「式节点」于「通用序列节点」于（「缀」于「头」于「项们」））则
      鉴「头」而
        有（「自由变量」于「头名」）则
          若（「串相等」于「头名」于『列』）
          则
            「可有」于（「构造多态列表达式」于「项们」）
          否则若（「串相等」于「头名」于『典』）
          则
            「：典乃静态键值之集；仅由豫构解码。现代汉语：保留典语法树供构建配置解析器使用，不调用运行时字典构造。：」
            「可有」于「序列」
          否则若（「串开头是它吗」于『《《』于「头名」）
          则
            「：文言：扩展之头仍自由名，以列载义。汉语：保留「《《扩展名》》」为头的通用序列，按阶段解释其语义。：」
            「可有」于「序列」
          否则
            「可无」
        或有（「式节点」于「外部调用头节点」于（（「列」【「名称」】）））则
          「可有」于（「式节点」于「外部调用节点」于（（「列」【「名称」，（「构造外部调用参数容器」于「项们」）】）））
        或有「其他头」则「可无」
        或有「其他」则
          「发生事故」
            于『通用序列节点必须至少包含序列头：』附（「表达式表示」于「其他」）
也。

「通用序列逗号操作符」乃「操作符」也。
「通用序列逗号操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『，』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（（「列」【「左」，「右」】））则（「可有」
          于（「式节点」
            于「逗号序列节点」
            于（「附加」于（「读取逗号序列项」于「左」）于（「读取逗号序列项」于「右」））））
        或有「其他」则
          「发生事故」于『通用序列逗号的参数个数必须是二』
    ）于『〇，〇』
也。

「通用序列非空操作符」乃「操作符」也。
「通用序列非空操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『【』，「元素组件」，「字符串组件」于『】』】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（（「列」【「头」，「体」】））则
          「阐述通用序列」于（「式节点」于「通用序列节点」于（「缀」于「头」于（「读取逗号序列项」于「体」）））
        或有「其他」则
          「发生事故」于『非空通用序列必须有头和体』
    ）于『〇【〇】』
也。

「通用序列尾逗号操作符」乃「操作符」也。
「通用序列尾逗号操作符」者
  「：句末容逗，以利增删。现代汉语：允许“头【项，】”形式的末尾逗号。：」
  「构造操作符」
    于（（「列」【（「元素组件」），（「字符串组件」于『【』），（「元素组件」），（「字符串组件」于『，】』）】））
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（（「列」【「头」，「体」】））则
          「阐述通用序列」于（「式节点」于「通用序列节点」于（「缀」于「头」于（「读取逗号序列项」于「体」）））
        或有「其他」则
          「发生事故」于『尾逗号通用序列必须有头和体』
    ）于『〇【〇，】』
也。

「通用序列空操作符」乃「操作符」也。
「通用序列空操作符」者
  「构造操作符」
    于（（「列」【（「元素组件」），（「字符串组件」于『【】』）】））
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（（「列」【「头」】））则
          「阐述通用序列」于（「式节点」于「通用序列节点」于（（「列」【「头」】）））
        或有「其他」则
          「发生事故」于『空通用序列必须有一个头』
    ）于『〇【】』
也。

「对子解构操作符」乃「操作符」也。
「对子解构操作符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『中』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「左」，「右」】）则（「可有」
          于（「转移表达式表层注释」
            于「右」
            于（「式节点」于（「元组解构节点」于（「解析元组解构序数」于「右」））于（（「列」【「左」】）））））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『〇中〇』
也。

「模式匹配分支符」乃「操作符」也。
「模式匹配分支符」者
  「构造操作符」
    于（「列」【「字符串组件」于『有』，「元素组件」，「字符串组件」于『则』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「模式」，「体」】）则
          （「可有」于（「式节点」于（「模式匹配分支」）于（（「列」【「模式」，「体」】））））
        或有「其他」则
          「发生事故」于『内65：操作符参数个数不匹配』
    ）于『有〇则〇』
也。

「模式匹配分支汇总符」乃「操作符」也。
「模式匹配分支汇总符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『或』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【（「式节点」于（「模式匹配分支」）于「分」），（「式节点」于（「模式匹配」）于「已有分支」）】）则（「可有」
          于（「式节点」于（「模式匹配」）于（「缀」于（「式节点」于（「模式匹配分支」）于「分」）于「已有分支」）））
        或有（「列」【（「式节点」于（「模式匹配分支」）于「分」），（「式节点」于（「模式匹配分支」）于「分二」）】）则
        （「可有」
          于（「式节点」
            于（「模式匹配」）
            于（（「列」【（「式节点」于（「模式匹配分支」）于「分」），（「式节点」于（「模式匹配分支」）于「分二」）】））））
        或有「其他」则
          「可无」
      「： 发生事故于（『内148：期待模式匹配分支，却得到了：』附（间合于『，』于（态射于（表达式表示）于「其他」））） ：」
  ）于『〇或〇』
也。

「模式匹配符」乃「操作符」也。
「模式匹配符」者
  「构造操作符」
    于（「列」【「字符串组件」于『鉴』，「元素组件」，「字符串组件」于『而』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【「对象」，（「式节点」于（「模式匹配」）于「已有分支」）】）则
          （「可有」于（「式节点」于（「模式匹配」）于（「缀」于「对象」于「已有分支」）））
        或有（「列」【「对象」，（「式节点」于（「模式匹配分支」）于「分二」）】）则（「可有」
          于（「式节点」于（「模式匹配」）于（（「列」【「对象」，（「式节点」于（「模式匹配分支」）于「分二」）】））））
        或有「其他」则
          「发生事故」于『内161：期待模式匹配分支』
    ）于『鉴〇而〇』
也。

「爻分支符」乃「操作符」也。
「爻分支符」者
  「构造操作符」
    于（「列」【
      「字符串组件」于『若』，
      「元素组件」，
      「字符串组件」于『则』，
      「元素组件」，
      「字符串组件」于『否则』，
      「元素组件」
    】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有「列」【「爻式」，「阳分支」，「阴分支」】则
          （「可有」于（「式节点」于（「爻分支节点」）于（「列」【「爻式」，「阳分支」，「阴分支」】）））
        或有「其他」则
          「发生事故」于『内187：应该是3个』
    ）于『若〇则〇否则〇』
也。

「外部调用符」乃「操作符」也。
「外部调用符」者
  「构造操作符」
    于（「列」【「元素组件」，「字符串组件」于『传』，「元素组件」】）
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（「列」【（「式节点」于「外部调用头节点」于（（「列」【「名称」】））），「参数」】）则
          （「可有」于（「式节点」于（「外部调用节点」）于（（「列」【「名称」，「参数」】））））
        或有「其他」则「可无」
    ）于『〇传〇』
也。

「外调头符」乃「操作符」也。
「外调头符」者
  「构造操作符」
    于（（「列」【（「字符串组件」于『《《外调》》名』），（「元素组件」）】））
    于（「行」于「下个序数」）
    于（会「当前文件名」而会「式列」而鉴「式列」而
        有（（「列」【「名称」】））则
          （「可有」于（「式节点」于「外部调用头节点」于（（「列」【「名称」】））））
        或有「其他」则
          「发生事故」于『外部调用头必须有一个名称』
    ）于『《《外调》》名〇』
也。