Pegjs: 支持解析基于缩进的语言

创建于 2013-10-16 · 34评论 · 资料来源: pegjs/pegjs

我使用了一堆基于缩进的语言，比如 CoffeeScript、Jade，并且想自己创建 DSL。
我通过搜索发现了一些在 pegjs 中保持缩进的技巧，想知道是否有一致的解决方案：
http://stackoverflow.com/questions/11659095/parse-indentation-level-with-peg-js
http://stackoverflow.com/questions/4205442/peg-for-python-style-indentation
https://gist.github.com/jakubkulhan/3192844
https://groups.google.com/forum/#!searchin/pegjs/indent/pegjs/RkbAB4rPlfU/xxafrY5wGCEJ
但是 pegjs 会支持这个功能吗？

feature

资料来源

jiyinyiyong

👍4

最有用的评论

依靠在自定义处理程序中添加的副作用来解析基于缩进的语法是非常危险的。只是不要这样做。 Pegjs 必须添加一些推送和弹出条件状态的能力，以便使解析缩进（和其他上下文相关的语法）安全。

这就是我现在所做的，我建议您这样做：预处理输入文件并插入您自己的缩进/缩进标记。我分别使用 {{{{ 和 }}}}。那么你的语法是上下文无关的，可以正常解析。它可能会弄乱您的行/列值，但您可以在后处理器中更正这些值。

krisnye 于 2014-02-11

👍3

所有34条评论

krisnye 于 2014-02-11

👍3

如果您不需要以 javascript 为目标， Pegasus （我的 C# 的 pegjs 克隆）支持推送/弹出状态。这是一篇关于如何做你想做的事的维基文章： https :

我想建议 pegjs 使用我的语法作为基于状态解析的起点。

otac0n 于 2014-02-11

安全地推送和弹出状态的能力很好。如果它是基于 Javascript 的，我会使用它。只是为了解析而集成 CLR 是不值得的。

krisnye 于 2014-02-11

我就是这么想的。我认为，在那种情况下，我可能应该尝试将我的改进移植到 pegjs 中。

但是，如果不与 @dmajda 对话，我不一定想这样做。

otac0n 于 2014-02-12

👍2

@otac0n很好。我不写 C# 。 JavaScript 对我来说要好得多。

jiyinyiyong 于 2014-02-12

基于缩进的语言很重要。我想看看在 1.0.0 之后简化他们的解析。

dmajda 于 2014-04-21

我认为这个问题最好通过允许状态来解决，就像 Pegasus 和 #285 中建议的那样。这是一个想法（以下是 Pegasus 的重要空白语法翻译为 pegjs 并添加了我的语法想法）：

{var indentation = 0}

program
  = s:statements eof { return s }

statements
  = line+

line
  = INDENTATION s:statement { return s }

statement
  = s:simpleStatement eol { return s }
  / "if" _ n:name _? ":" eol INDENT !"bar " s:statements UNDENT {
      return { condition: n, statements: s }
    }
  / "def" _ n:name _? ":" eol INDENT s:statements UNDENT {
      return { name: n, statements: s }
    }

simpleStatement
  = a:name _? "=" _? b:name { return { lValue: a, expression: b } }

name
  = [a-zA-Z] [a-zA-Z0-9]* { return text() }

_ = [ \t]+

eol = _? comment? ("\r\n" / "\n\r" / "\r" / "\n" / eof)

comment = "//" [^\r\n]*

eof = !.

INDENTATION
  = spaces:" "* &{ return spaces.length == indentation }

INDENT
  = #STATE{indentation}{ indentation += 4 }

UNDENT
  = #STATE{indentation}{ indentation -= 4 }

注意底部附近的#STATE{indentation}块（显然受到 Pegasus 的启发）。我称这些状态块。这个想法是在动作之前允许一个状态块。这是一个更复杂的状态块：

#STATE{a, b, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c}

它是以下的简写：

#STATE{a: {a}, b: {b}, arr: {arr.slice()}, obj: {shallowCopy(obj)}, c: {c}}

换句话说，在应用速记扩展之后，状态块的内容是identifier ":" "{" code "}" 。在动作之前添加一个状态块告诉 pegjs 这个动作将修改列出的标识符，如果规则被回溯，这些标识符应该被重置为大括号之间的代码。

以下是上述语法中 INDENT 和 UNDENT 的编译函数，并添加了indentation变量的重置：

    function peg$parseINDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c41();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

    function peg$parseUNDENT() {
      var s0, s1, t0;

      s0 = peg$currPos;
      t0 = indentation;
      s1 = [];
      if (s1 !== peg$FAILED) {
        peg$reportedPos = s0;
        s1 = peg$c42();
      } else {
        indentation = t0;
      }
      s0 = s1;

      return s0;
    }

下面是如何编译上面的“复杂状态块”的一些内容：

s0 = peg$currPos;
t0 = a;
t1 = b;
t2 = arr.slice();
t3 = shallowCopy(obj);
t4 = c;
// ...
if (s1 !== peg$FAILED) {
  // ...
} else {
  peg$currPos = s0;
  a = t0;
  b = t1;
  arr = t2;
  obj = t3;
  c = t4;
}

您如何看待这种能够：

告诉 pegjs 哪些有状态变量将被操作修改。
如果需要重置这些变量，请提供存储这些变量所需的代码。（包括变量是原始值的简单情况的速记语法。）

你如何看待语法？

编辑：这是建议的语法语法（只是为了好玩）：

diff --git a/src/parser.pegjs b/src/parser.pegjs
index 08f6c4f..09e079f 100644
--- a/src/parser.pegjs
+++ b/src/parser.pegjs
@@ -116,12 +116,31 @@ ChoiceExpression
     }

 ActionExpression
-  = expression:SequenceExpression code:(__ CodeBlock)? {
+  = expression:SequenceExpression code:((__ StateBlock)? __ CodeBlock)? {
       return code !== null
-        ? { type: "action", expression: expression, code: code[1] }
+        ? {
+            type:       "action",
+            expression: expression,
+            code:       code[2],
+            stateVars:  (code[0] !== null ? code[0][1] : [])
+          }
         : expression;
     }

+StateBlock "state block"
+  = "#STATE{" __ first:StateBlockItem rest:(__ "," __ StateBlockItem)* __ "}" {
+      return buildList(first, rest, 3);
+    }
+
+StateBlockItem
+  = varName:Identifier expression:(__ ":" __ CodeBlock)? {
+      return {
+        type:       "stateVar",
+        name:       varName,
+        expression: expression !== null ? expression[3] : varName
+      };
+    }
+
 SequenceExpression
   = first:LabeledExpression rest:(__ LabeledExpression)* {
       return rest.length > 0

lydell 于 2015-02-15

嗨，大家好，
只是为了澄清一下，我是否正确，最好不要在基于缩进的语言中使用 PEG.js（从这个问题顶部开始的解决方法），直到这个问题关闭？
谢谢。

hoho 于 2015-11-08

@hoho我不明白你的意思..但我后来找到了另一种解决方案来使用解析器组合器来

jiyinyiyong 于 2015-11-09

我的意思是有解析缩进的变通方法，但评论说这些变通方法在某些情况下会失败。

hoho 于 2015-11-10

让我澄清一下情况：在 PEG.js 中解析基于缩进的语言是可能的。上面提到了各种解决方案，我刚刚创建了另一个解决方案，因为我试图对此有一种“感觉”（它是一种具有两个语句的简单语言的语法，其中一个可以包含缩进的子语句——类似于例如if在 Python 中）。

所有解决方案的共同点是它们需要手动跟踪缩进状态（因为 PEG.js 不能这样做）。这意味着有两个限制：

您不能安全地编译带有缓存的语法（因为解析器可以使用缓存的结果而不是执行状态操作代码）。
您不能跨缩进级别回溯（因为当前无法在回溯时展开状态）。换句话说，您无法解析一种语言，其中有两个有效构造，只有在换行和缩进级别更改后才能消除歧义。

在某些情况下，限制 1 可能会导致性能问题，但我认为没有多少语言会出现限制 2 的问题。

在 1.0.0 之前我对这种状态没问题，我计划在之后的某个时候回到这个话题。第一级改进可能是使用更明确的状态跟踪（如上所述）或通过提供回溯钩子（以便人们可以正确展开状态）来摆脱限制 2。第二级可以通过提供一些声明性的方式来摆脱手动跟踪缩进状态的需要。这可能有助于限制 1。

dmajda 于 2015-11-27

H，我为支持正确回溯的 PEG.js 编写了一个（微小的、hacky 的）补丁，正如我在此处解释的： https :

tebbi 于 2015-11-27

👍1

抱歉磕磕碰碰😜

我只是想为我正在设计的语言创建 CSON 和 YAML 解析器，在寻找使用 PEG.js 创建基于缩进的解析器的方法时，我想出了一个简单的方法：

1) 不依赖于 push/pop 状态
2）通过动作中的代码断言缩进级别

我突然想到，上述 2 个解决方案中的任何一个实际上都会给生成的解析器增加性能问题。另外在我看来：

1) 依赖状态不仅会增加丑陋的 PEG.js 语法，还会影响可以生成的解析器类型，因为它们需要支持基于动作的状态处理。
2) 有时在动作中添加一些代码会导致语言依赖规则，对于一些开发人员来说，这意味着他们不能使用插件来为其他语言（如 C 或 PHP）生成解析器，而无需借助更多插件来处理规则上的动作，这只是意味着更大的构建系统只是为了支持 1 或 2 个更改。

一段时间后，我开始创建自己的 PEG.js 解析器变体并思考：为什么不只使用增量（“++”）和减量（“--”）前缀运算符（__++ 表达式__ 和 __-- 表达式__ ) 来处理匹配表达式（__expression *__ 或 __expression +__）的结果。

以下是基于@dmajda的Simple Intation-based language的示例语法，重写后使用新的 __++ 表达式__ 和 __-- 表达式__ 而不是 __& { 谓词 }__：

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* statement:(S / I) { return statement; }

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent statements:Statements --Indent { return statements; }
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

更赏心悦目，不是吗？对于人类和软件来说也更容易理解。

它是如何工作的？简单的：

1) Indent*告诉解析器我们想要Indent返回的 0 或更多
2) ++Indent告诉解析器增加Indent所需的最小匹配数
3) 现在任何时候解析器将要返回Indent的匹配项，它首先期望它比之前多 __1 个 __ 匹配项，否则会抛出 _peg$SyntaxError_。
4) --Indent告诉解析器减少Indent所需的最小匹配数
5) 现在任何时候解析器查找Indent并返回它期望 __1 less__ 匹配之前的匹配项，否则抛出 _peg$SyntaxError_。

此解决方案是添加对“重要空白解析”支持的最佳方式，无需向 PEG.js 语法添加难看的语法或阻止 3rd 方生成器。

这是在 _src/parser.pegjs_ 中添加对解析它的支持的更改规则：

{
  const OPS_TO_PREFIXED_TYPES = {
    "$": "text",
    "&": "simple_and",
    "!": "simple_not",
    "++": "increment_match",
    "--": "decrement_match"
  };
}

PrefixedOperator
  = "$"
  / "&"
  / "!"
  / "++"
  / "--"

SuffixedOperator
  = "?"
  / "*"
  / "+" !"+"

我是否正确假设要支持它编译器/生成器方面，我们将必须：

1) 添加编译器传递以确保 __++ 表达式__ 或 __-- 表达式__ 仅用于 __expression *__ 或 __expression +__，其中 __expression__ 必须是以下类型：choice、sequence 或 rule_ref
2) 在生成的解析器中为 __expression *__ 或 __expression +__ 添加一个基于缓存的检查，在返回匹配之前断言满足最低要求的匹配
3) 可选地为生成的解析器添加一个辅助方法，以实现返回给定规则所需的匹配数，例如。 nMatches( name: String ): Number

futagoza 于 2017-03-15

@futagoza ，这很干净而且很聪明。我喜欢。我正在研究处理状态的解析器，但我们真正需要的唯一状态是缩进级别。我可能会使用这个想法，并为此称赞你。跟踪缩进级别仍然有效地需要推送/弹出状态，因此它仍然可能会阻止一些优化，但其语义非常好。

如果您要向语法中添加运算符，我建议也添加 @ 前缀运算符。它的目的是简单地从序列中提取单个规则结果。使用它，示例语法变得更加清晰。没有更多琐碎的 { return x } 操作。

Start
  = Statements

Statements
  = Statement*

Statement
  = Indent* @(S / I)

S
  = "S" EOS {
      return "S";
    }

I
  = "I" EOL ++Indent <strong i="8">@Statements</strong> --Indent
  / "I" EOS { return []; }

Indent "indent"
  = "\t"
 / !__ "  "

__ "white space"
 = " \t"
 / " "

EOS
  = EOL
  / EOF

EOL
  = "\n"

EOF
  = !.

@kodyjking你怎么看？

krisnye 于 2017-03-16

@futagoza你有启用缩进补丁和小样本语法的 fork/branch 吗？