我正在尝试在prolog中解决DCG语法并成功达到一定程度，我一直在评估涉及这些括号的表达式。
expr( T, [’(’, 5, +, 4, ’)’, *, 7], []),
expr(Z) --> num(Z).
expr(Z) --> num(X), [+], expr(Y), {Z is X+Y}.
expr(Z) --> num(X), [-], expr(Y), {Z is X-Y}.
expr(Z) --> num(X), [*], expr(Y), {Z is X*Y}.
num(D) --> [D], {number(D)}.
eval(L, V, []) :- expr(V, L, []).
答案 0 :(得分：4)
这是我在Prolog历史中观察到的最奇怪的事情之一。 也就是说，已经存在多年的错误表达语法。 DEC10 Prolog文档中已经找到了错误的语法 当我们看一条规则时会看到错误：
expr(Z) --> num(X), "/", expr(Y), {Z is X/Y}.
etc..
这使除法运算符xfy，但它应该是yfx。因此 上述规则将表达式10/2/5读作10 /（2/5）并导致 结果是25。但实际上这个例子应该是（10/2）/ 5 产生1作为结果。
问题是正确的语法将是递归的。 并且DCG确实存在左递归规则的问题。 Prolog 解释器只会遇到左边的无限循环 重复调用expr / 3的递归规则：
expr(Z) --> expr(X), "/", num(Y), {Z is X/Y}
etc..
因此解决方案是通过引入来消除左递归 累加器和附加规则。我不知道是否这样 方法一般工作，但它在当前情况下肯定有效。 因此，正确且深入的第一个可执行规则将为：
expr(Y) --> num(X), expr_rest(X,Y).
expr_rest(X,T) --> "/", !, num(Y), {Z is X/Y}, expr_rest(Z,T).
etc..
expr_rest(X,X).
上述语法有点具有挑战性的DCG。它不是 再纯粹的Prolog，因为它使用剪切（！）。但我们可以 消除切口，例如通过推回，切断 以下几行。推回再次变得复杂 在DCG介绍中解释的问题，我们需要 在表达式的末尾引入一个停止字符 它的工作原理：
etc..
expr_rest(X,X), [C] --> [C], {not_operator(C)}.
或者我们既不能完成切割或推回的长度 和它一起生活，在回溯时解析器会做额外的， 在目前的情况下，不必要的工作。所以底线可能是， 虽然这个例子不正确，但解释DCG很简单 无需DCG的高级功能。
有趣的是，缺少的括号语法几乎不受影响 消除左递归。只需添加：
num(X) --> "(", !, expr(X), ")".
哎呀，再次削减！
最好的问候
完整代码可以在这里看到： http://www.jekejeke.ch/idatab/doclet/prod/en/docs/05_run/06_bench/09_programs/10_calculator/01_calculator.p.html
P.S。：我们也可以使用，而不是消除左递归 使用某种形式的表格。
答案 1 :(得分：3)
Prolog的DCG语法实现的解析器是递归下降LL（某种）（预测）语法。它从左到右引导输入，并在它进行时产生最左边的推导。它们很容易制作，但语法必须符合一些限制：
它们不能是左递归的。可以/将导致无限递归。这意味着在跟随递归路径之前必须从输入流中删除至少一个符号（标记）。重构语法以消除左递归是一种相当机械的练习，尽管很乏味。看看有关如何做到这一点的任何体面的编译器书。
运算符优先级通常内置于语法本身的结构中。这里的BNF表示法显示了一种定义递归下降语法的方法，用于解析/评估简单的算术表达式：
ArithmeticExpression : AdditiveExpression
;
AdditiveExpression : MultiplicativeExpression
| MultiplicativeExpression '+' AdditiveExpression
| MultiplicativeExpression '-' AdditiveExpression
;
MultiplicativeExpression : ExponentialExpression
| ExponentialExpression '*' MultiplicativeExpression
| ExponentialExpression '/' MultiplicativeExpression
| ExponentialExpression '%' MultiplicativeExpression
;
ExponentialExpression : UnaryExpression
| UnaryExpression '^' ExponentialExpression
;
UnaryExpression : '-' UnaryExpression
| AtomicExpression
;
AtomicExpression : '(' ArithmeticExpression ')'
| ['0'..'9']+
;
每个运算符优先级的术语是根据下一个更高优先级的表达式构建的。因此，任意算术表达式只是一个加法表达式。
每个加法表达式是1个或更多乘法表达式，由加法和减法运算符连接。
每个乘法表达式是1个或多个指数表达式，由乘法，除法和余数运算符连接。
每个指数表达式都是一元表达式，带有选项指数运算符，后跟另一个一元表达式。
每个一元表达式都是原子表达式，或者是一元减号，后跟另一个一元表达式。
每个原子表达式是括在括号中的任意算术表达式，或无符号整数标记。
将上述内容翻译成Prolog的DCG语法应该是微不足道的。如何评估语法中每个子句所代表的术语应该是不言而喻的。
答案 2 :(得分：2)
添加此子句似乎有效：num(D) --> ['('], expr(D), [')'].
答案 3 :(得分：2)
它只是有效。然而，它并不比yacc / bison容易。
%?-eval('11*(7+5-2)^2*(11+8)').
eval(A) :- lex(A,L), evallist(L).
%?-evallist([11,*,'(',7,+,5,-,2,')',^,2,*,'(',11,+,8,')']).
evallist(L) :- e(R,L,[]),write(R),!.
e(N) --> t(N1), erest(N1,N).
erest(N1,N) --> [+], !, t(N2), {N3 is N1+N2}, erest(N3,N);
[-], !, t(N2), {N3 is N1-N2}, erest(N3,N).
erest(N,N) --> [].
t(N) --> f(N1), trest(N1,N).
trest(N1,N) --> [*], !, f(N2), {N3 is N1*N2}, trest(N3,N);
[/], !, f(N2), {N3 is N1/N2}, trest(N3,N).
trest(N,N) --> [].
f(N) --> n(N);
n(N1), [^], f(N2), {N is N1**N2}.
n(N) --> ['('], !, e(N), [')'];
[-], !, e(N1), {N is -N1};
num(N).
num(N) --> [N], {number(N)}.
lex(A,NL) :-
atom_chars(A,L), lex0(_,L,NL).
lex0(S,L,NL) :-
L=[], (number(S), NL=[S], !; NL=[]), !;
L=[E|R], (d(E,N), (number(S), !; S=0), S1 is S*10+N, lex0(S1, R, NL), !;
lex0(_,R,NR), (number(S), NL=[S|[E|NR]], !;
NL=[E|NR])).
d(I,N) :-
char_code(I,C), C > 47, C < 58, N is C - 48.
答案 4 :(得分：1)
感谢@vladimir Lidovski 并基于 BNF 表示法（以及我的需要），我将其扩展为还包括逻辑表达式。这是我的代码（要查看完整的解释器，请查看我的 git repo）：
cond_expre(T) --> and_expre(E1), or_rest(E1,T).
or_rest(E1,T) --> [punct('|'),punct('|')],!, and_expre(E2), {V = (\/,E1,E2)}, or_rest(V,T).
or_rest(T,T) --> [].
and_expre(T) --> equality_expre(E1), and_rest(E1,T).
and_rest(E1,T) --> [punct(&),punct(&)], !, equality_expre(E2), {V = (/\,E1,E2)}, and_rest(V,T).
and_rest(T,T) --> [].
equality_expre(T) --> relat_expre(E1), equality_rest(E1,T).
equality_rest(E1,T) --> equality_op(Op) ,!, relat_expre(E2), { V=(Op,E1,E2)}, equality_rest(V,T).
equality_rest(T,T) --> [].
relat_expre(T) --> atomic_texpre(E1), relat_rest(E1,T).
relat_rest(E1,T) --> relat_op(Op) ,!, atomic_texpre(E2) , { V=(Op,E1,E2) },relat_rest(V,T).
relat_rest(T,T) --> [].
atomic_texpre(T) --> arith_expre(T); [punct('(')], !, cond_expre(T), [punct(')')] .
arith_expre(V) --> expre(V).
equality_op(==) --> [punct(=),punct(=)].
equality_op(\=) --> [punct(!),punct(=)].
relat_op(>=) --> [punct(>),punct(=)].
relat_op(>) --> [punct(>)].
relat_op('=<') --> [punct(<),punct(=)].
relat_op(<) --> [punct(<)].
expre(N) --> multiplicative(N1), additive_rest(N1,N).
additive_rest(N1,N) --> [punct('+')], !, multiplicative(N2), {N3 = (+,N1,N2)}, additive_rest(N3,N);
[punct('-')], !, multiplicative(N2), {N3 = (-,N1,N2)}, additive_rest(N3,N).
additive_rest(N,N) --> [].
multiplicative(N) --> atomic(N1), multiplicative_rest(N1,N).
multiplicative_rest(N1,N) --> [punct('*')], !, atomic(N2), {N3 = (*,N1,N2)}, multiplicative_rest(N3,N);
[punct('/')], !, atomic(N2), {N3 = (/,N1,N2)}, multiplicative_rest(N3,N);
[punct('%')], !, atomic(N2), {N3 = (mod,N1,N2)}, multiplicative_rest(N3,N).
multiplicative_rest(N,N) --> [].
atomic(N) --> [punct('(')], !, expre(N), [punct(')')]; num(N).
num(N) --> pl_constant(N).
pl_constant(num(N)) --> pl_integer(N), !.
pl_constant(id(X)) --> identifier(X), {call(id(X,_)) }. %Not sure if I remember what it does but I think, the right most call I wrote to assure that the variable is already registered in the cache so that a value can later be retrieved from it
pl_integer(X) --> [number(X)]. %the value on the right works together with a tokenizer library -> :- use_module(library(tokenize)). It's basically a token labled as a number. Same with the next line.
identifier(X) --> [word(X)].