Question

我正在为我编写的编程语言编写语言解释器。这是一些示例代码，它应该可以工作，但在读取此测试用例时，目前会以Syntax error at offset 45.消失。

{
  foo = { "min" : 1 ,"max" : 5};
  foo["min"]
}

正确的解释是第一行用foo创建一个映射并将其存储在一个名为foo的变量中，第二行查找记录foo中字段min的值，并且起始/结束与分号将两个表达式包装成一个expr_seq（即一个块），其值与上一个expr的值相同。

我的parser.mly的简化版本如下：

%token <int> INT
%token <string> VAR
%token SEMI COMMA COLON ASSIGN QUOTE
%token LBRACK RBRACK LCURL RCURL
%token EOF

%start <int> main

%%

main:
| EOF
    { failwith "empty input" }
| e = exp EOF
    { e }

exp:
| INT
    { 0 }
| e = exp LBRACK v = q_var RBRACK
    { (* map lookup *) 0 }
| v = VAR ASSIGN e = exp
    { (* assign to var *) 0 }
| v = VAR LBRACK f = q_var RBRACK ASSIGN e = exp
    { (* assign to map field *) 0 }
| v = VAR
    { Printf.printf "lookup %s\n" v; 0 }
| LCURL e = expr_seq RCURL
    { (* Block expression *) 0 }
| LCURL f = fields RCURL
    { (* map literal *)0 }

fields:
| v = q_var COLON e = exp
    { [(v, e)] }
| v = q_var COLON e = exp COMMA vt = fields
    { (v, e) :: vt }

q_var:
| QUOTE v = VAR QUOTE
    { Printf.printf "qvar %s\n" v; v }

expr_seq:
| e = exp
    {[e]}
|e1 = exp SEMI e2 = expr_seq
    {e1 :: e2}

尝试自己调试它，我发现如果你删除了下面的| v = VAR LBRACK f = q_var RBRACK ASSIGN e = exp它将解析它并正确运行，但我真的希望能够在地图中设置东西。

我98％确信问题出在我的mly文件中，但我的lexer.mll的简化版本如下：

{
  open Parser
  open Printf
}

rule token = parse
| [' ' '\t' '\n']
    { token lexbuf }
| "="
    {ASSIGN}
| ['1'-'9']['0'-'9']* as i
    { INT (int_of_string i) }
| ['a'-'z']+ as v
    { printf "var %s\n" v;VAR v }
| '{'
    { LCURL }
| '}'
    { RCURL }
| '['
    { printf "["; LBRACK }
| ']'
    { printf "]"; RBRACK }
| ';'
    { SEMI }
| ':'
    { COLON }
| ','
    { COMMA }
| '"'
    { QUOTE }
| eof
    { EOF }
| _
    { raise (Failure (sprintf "At offset %d: unexpected character.\n" 
                       (Lexing.lexeme_start lexbuf))) }

一个简单的ml文件是：

open Core.Std
open Printf

let rec read_all ic =
  try
    let ln = input_line ic in
      ln ^ read_all ic
  with End_of_file -> "";;

let () =
  let linebuf = Lexing.from_string (read_all stdin) in
  try
    Parser.main Lexer.token linebuf;
    printf "Done"
  with
  | Failure msg ->
      fprintf stderr "%s%!" msg
  | Parser.Error ->
      fprintf stderr "Syntax error at offset %d.\n%!"   
        (Lexing.lexeme_start linebuf)

编辑：这是一个Makefile。 parser.mly，lexer.mll和interpreter.ml是上面的第二，第三和第四个文件。

all: HB lexer.cmx parser.cmx interpreter.cmx
    @true

HB: interpreter.cmx
    ocamlfind ocamlopt -o HB -linkpkg -package core -package core_kernel \
    -thread -w -10 parser.cmx lexer.cmx interpreter.cmx

interpreter.cmx: lexer.cmx
    ocamlfind ocamlopt -package core -package core_kernel -thread -w   -10 \
    -c interpreter.ml

lexer.cmx: lexer.ml parser.cmx
    ocamlfind ocamlopt    -c lexer.ml

parser.cmx: parser.mly
    menhir --ocamlc "ocamlfind ocamlc" --infer --base parser  parser.mly
    ocamlfind ocamlc -c parser.mli
    ocamlfind ocamlopt -c parser.ml

lexer.ml: lexer.mll
    ocamllex lexer.mll

clean:
    @rm HB *.o *.cmi *.cmx lexer.ml parser.ml parser.mli 2>/dev/null || true

这里正在制作/运行它，其中test.in是上面的第一个。

$ mk;HB < test.in
ocamllex lexer.mll
menhir --ocamlc "ocamlfind ocamlc" --infer --base parser  parser.mly
15 states, 286 transitions, table size 1234 bytes
Warning: 3 states have shift/reduce conflicts.
Warning: 3 shift/reduce conflicts were arbitrarily resolved.
ocamlfind ocamlc -c parser.mli
ocamlfind ocamlopt -c parser.ml
ocamlfind ocamlopt    -c lexer.ml
ocamlfind ocamlopt -package core -package core_kernel -thread -w -10 \
    -c interpreter.ml
ocamlfind ocamlopt -o HB -linkpkg -package core -package core_kernel \
    -thread -w -10 parser.cmx lexer.cmx interpreter.cmx
Syntax error at offset 45.
var foo
var min
qvar min
var max
qvar max
var foo
[var min
]qvar min

编辑2：我最后只是将| e = VAR LBRACK v = q_var RBRACK { GetMap(v,LookupVar(e)) }作为特殊情况添加到我的解析器中。那么，问题解决了吗？

Answer 1

我尝试使用您的语言，现在我同意解析器，您的输入很糟糕，请查看您的＆＃34;分配到地图字段＆＃34;规则：

v = VAR LBRACK f = q_var RBRACK ASSIGN e = exp

如果我们删除这个嘈杂的变量（你不需要使用，顺便说一句）：

VAR LBRACK q_var RBRACK ASSIGN exp

这意味着规则需要：

VAR, '[' '"' VAR '"' ']' '=' exp

例如

foo["min"] = 42

以下是完全接受的

{
  foo = { "min" : 1 ,"max" : 5};
  foo["min"] = 42
}

Answer 2

回顾这一点，我相信它不起作用的原因是语法不是LR（1），因此Menhir无法准确解析。确定foo["min"]是v = VAR LBRACK f = q_var RBRACK ASSIGN e = exp的开头还是e = exp LBRACK v = q_var RBRACK，要求我们查看四个左右的符号，而Menhir作为LR（1）解析器仅向前看一个。

尝试解析虚构的编程语言时出错

2 个答案: