我为解析正则表达式做了一个简单的语法。不幸的是,当我尝试在大型表达式上测试我的正则表达式编译器时,我遇到了StackOverflowException。该问题与this one相似,除了它们的解决方案在我的方案中不再起作用。这是我的语法:
union: concat | concat '|' union ;
concat: kleene_closure concat | kleene_closure;
kleene_closure: atomic '*' | atomic ;
atomic : '(' union ')' | LETTER ;
现在的问题是我有一个看起来很大的文件
something1 | something2 | something3 | .... | something1000
我使用ANTLR的Visitor
类进行解析。我知道我可以像这样使用+
/ *
进行一些优化
union: (concat '|')* concat ;
concat: kleene_closure+;
kleene_closure: atomic '*' | atomic ;
atomic : '(' union ')' | LETTER ;
但是,由于这种语法的递归性质,它并不能真正解决问题。例如,现在在显然需要递归的以下示例上将失败:
(...(((something1) | something2) | something3) | .... ) | something1000
如何避免StackOverflowExcpetion?其他编译器(例如C编译器)如何处理具有数千行代码的超大型文本?
答案 0 :(得分:2)
如果要使用递归下降解析器,那么不可避免地会遇到超出调用堆栈深度的输入。诸如Java之类的语言能够控制其自身的堆栈深度,从而改善了此问题,从而产生了诸如StackOverflowException之类的可控结果。但这仍然是一个真正的问题。
Yacc / Bison和Java Cup之类的解析器生成器使用自下而上的LALR(1)算法,该算法使用显式堆栈进行临时存储,而不是为此目的使用调用堆栈。这意味着解析器必须管理解析器堆栈的存储(或使用主机语言的标准库中的容器ADT(如果有的话)使用容器),这稍微复杂一些。但是您不必处理这种复杂性。它内置在解析器生成器中。
解析器生成器的显式堆栈有几个优点:
不过,这不是万能药。足够复杂的表达式将超出任何固定的堆栈大小,并且可能导致某些程序无法解析。此外,如果您利用了以上第二点提到的灵活性(“仅受可用内存限制”),您很可能会发现编译器被OOM进程(或段错误)毫不客气地终止了,而不是能够响应一个更礼貌的内存不足异常(当然取决于操作系统和配置)。
关于:
其他编译器(例如C编译器)如何处理具有数千行代码的超大型文本?
如果在语法中使用重复运算符(或者在使用LALR(1)解析器的情况下,语法是左递归的),那么拥有数千行代码就不是问题。正如您在问题中指出的那样,当您的文本具有成千上万的嵌套块时,就会出现问题。答案是,许多C编译器无法很好地处理此类文本。这是一个使用gcc的简单实验:
$ # A function which generates deeply-nested C programs
$ type deep
deep is a function
deep () {
n=$1;
printf "%s\n%s\n %s\n" '#include <stdio.h>' 'int main(void) {' 'int a0 = 0;';
for ((i=0; i<n; ++i))
do
printf '%*s{ int a%d = a%d + 1;\n' $((i+1)) '' $((i+1)) $i;
done;
printf '%*sprintf("%%d\\n", a%d);\n' $n '' $n;
for ((i=0; i<n; ++i))
do
printf "%s" '}';
done;
printf "%s\n" '}'
}
$ deep 3
#include <stdio.h>
int main(void) {
int a0 = 0;
{ int a1 = a0 + 1;
{ int a2 = a1 + 1;
{ int a3 = a2 + 1;
printf("%d\n", a3);
}}}}
$ # For small depths, GCC is OK with that.
$ deep 3 | gcc -x c - && ./a.out
3
$ # Let's go deeper:
$ deep 10 | gcc -x c - && ./a.out
10
$ deep 100 | gcc -x c - && ./a.out
100
$ deep 1000 | gcc -x c - && ./a.out
1000
$ deep 10000 | gcc -x c - && ./a.out
10000
$ # Ka-bang. (Took quite a long time, too.)
$ deep 100000 | gcc -x c - && ./a.out
gcc: internal compiler error: Segmentation fault (program cc1)
Please submit a full bug report,
with preprocessed source if appropriate.
See <file:///usr/share/doc/gcc-7/README.Bugs> for instructions.
没有嵌套块,gcc仍然很慢,但可以处理程序:
$ type big
big is a function
big ()
{
n=$1;
printf "%s\n%s\n %s\n" '#include <stdio.h>' 'int main(void) {' 'int a0 = 0;';
for ((i=0; i<n; ++i))
do
printf ' int a%d = a%d + 1;\n' $((i+1)) $i;
done;
printf ' printf("%%d\\n", a%d);\n' $n;
printf "%s\n" '}'
}
$ big 3
#include <stdio.h>
int main(void) {
int a0 = 0;
int a1 = a0 + 1;
int a2 = a1 + 1;
int a3 = a2 + 1;
printf("%d\n", a3);
}
$ $ big 3|gcc -x c - && ./a.out
3
$ big 10000|gcc -x c - && ./a.out
10000
$ big 100000|gcc -x c - && ./a.out
100000
答案 1 :(得分:1)
您可以使用ABNF语法定义语法,然后将其交给TGS *进行迭代解析-无需使用线程专用堆栈进行递归。解析器生成器生成解析器,该解析器针对其所有所有操作进行迭代运行:词法分析,解析,树构造,树到字符串转换,树迭代和树破坏。
运行时的解析器还可以仅向您提供具有事件的树构建信息,然后您可以根据需要构建树(或在没有任何树的情况下进行任何计算)。在这种情况下,当您使用事件进行解析(确定性的解析器语法而不使用显式的树结构)时,如果您有足够的操作内存来容纳解析规则的深度,则实际上可以“流式传输”任何输入不管 >。
ABNF(RFC 5234)这样的语法中的确定性语法是这样的:
alternative = concatenation *('|' concatenation)
concatenation = 1* kleene-closure
kleene-closure = atomic 0*1 '*'
atomic = '(' alternative ')' / letter
letter = 'a'-'z' / 'A'-'Z'
然而,该语法每个项目只有一个字母,对于输入为“ ab”的您将获得两个原子节点,每个节点一个字母。如果您想要更多的字母,那么这种语法可能会起作用:
alternative = concatenation *('|' *ws concatenation)
concatenation = element *(ws 0*1 element)
element = primary 0*1 '*'
primary = '(' *ws alternative ')' / identifier
identifier = 1*('a'-'z' / 'A'-'Z')
ws = %x20 / %x9 / %xA / %xD
您可以将其理解为:一种替代方案是由一个或多个concatenations
隔开,|
。 concatenation
是一个或多个elements
,由至少一个white space
字符分隔。 element
可以以*
结尾,并且可以是范围内的alternative
或identifier
,后者又是一个或多个字母。空格为space
,tab
,new line
或carriage return
。如果要使用更复杂的标识符,可以使用以下方法:
identifier = (letter / '_') *(letter / '_' / digit)
letter = 'a'-'z' / 'A'-'Z'
digit = '0'-'9'
*我正在那个项目上。