sentenceyacc.dpr

语法分析 语法分析

(* Yacc parser template (TP Yacc V3.0), V1.2 6-17-91 AG *)

(* global definitions: *)

{*
 * 识别简单英语句子的yacc程序
   编译：yacc sentence sentenceyacc.dpr
 *}
program SentenceYacc;

{$APPTYPE CONSOLE}

uses
  SysUtils, LexLib, YaccLib, Sentence;

const
  Noun = 257;
const
  Pron = 258;
const
  Verb = 259;
const
  Adv = 260;
const
  Adj = 261;
const
  Prep = 262;
const
  Conj = 263;

var
  yylval: YYSType;

function yyparse: Integer;

var
  yystate, yysp, yyn: Integer;
  yys: array[1..yymaxdepth] of Integer;
  yyv: array[1..yymaxdepth] of YYSType;
  yyval: YYSType;

  procedure yyaction(yyruleno: Integer);
    (* local definitions: *)
  begin
    (* actions: *)
    case yyruleno of
      1:
        begin
          writeln('句子有效');
            //注意在yacc中的附加的代码必须加花括号, lex中可以不加
        end;
      2:
        begin
          yyval := yyv[yysp - 0];
        end;
      3:
        begin
          yyval := yyv[yysp - 0];
        end;
      4:
        begin
          yyval := yyv[yysp - 0];
        end;
    end;
  end (*yyaction*);

  (* parse table: *)

type
  YYARec = record
    sym, act: Integer;
  end;
  YYRRec = record
    len, sym: Integer;
  end;

const

  yynacts = 5;
  yyngotos = 3;
  yynstates = 8;
  yynrules = 4;

  yya: array[1..yynacts] of YYARec = (
    { 0: }
    (sym: 257; act: 3),
    (sym: 258; act: 4),
    { 1: }
    (sym: 259; act: 5),
    { 2: }
    (sym: 0; act: 0),
    { 3: }
    { 4: }
    { 5: }
    (sym: 257; act: 7)
    { 6: }
    { 7: }
    );

  yyg: array[1..yyngotos] of YYARec = (
    { 0: }
    (sym: - 3; act: 1),
    (sym: - 2; act: 2),
    { 1: }
    { 2: }
    { 3: }
    { 4: }
    { 5: }
    (sym: - 4; act: 6)
    { 6: }
    { 7: }
    );

  yyd: array[0..yynstates - 1] of Integer = (
    { 0: } 0,
    { 1: } 0,
    { 2: } 0,
    { 3: }-2,
    { 4: }-3,
    { 5: } 0,
    { 6: }-1,
    { 7: }-4
    );

  yyal: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 3,
    { 2: } 4,
    { 3: } 5,
    { 4: } 5,
    { 5: } 5,
    { 6: } 6,
    { 7: } 6
    );

  yyah: array[0..yynstates - 1] of Integer = (
    { 0: } 2,
    { 1: } 3,
    { 2: } 4,
    { 3: } 4,
    { 4: } 4,
    { 5: } 5,
    { 6: } 5,
    { 7: } 5
    );

  yygl: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 3,
    { 2: } 3,
    { 3: } 3,
    { 4: } 3,
    { 5: } 3,
    { 6: } 4,
    { 7: } 4
    );

  yygh: array[0..yynstates - 1] of Integer = (
    { 0: } 2,
    { 1: } 2,
    { 2: } 2,
    { 3: } 2,
    { 4: } 2,
    { 5: } 3,
    { 6: } 3,
    { 7: } 3
    );

  yyr: array[1..yynrules] of YYRRec = (
    { 1: }(len: 3; sym: - 2),
    { 2: }(len: 1; sym: - 3),
    { 3: }(len: 1; sym: - 3),
    { 4: }(len: 1; sym: - 4)
    );

const
  _error = 256; (* error token *)

  function yyact(state, sym: Integer; var act: Integer): Boolean;
    (* search action table *)
  var
    k: Integer;
  begin
    k := yyal[state];
    while (k <= yyah[state]) and (yya[k].sym <> sym) do
      inc(k);
    if k > yyah[state] then
      yyact := false
    else
    begin
      act := yya[k].act;
      yyact := true;
    end;
  end (*yyact*);

  function yygoto(state, sym: Integer; var nstate: Integer): Boolean;
    (* search goto table *)
  var
    k: Integer;
  begin
    k := yygl[state];
    while (k <= yygh[state]) and (yyg[k].sym <> sym) do
      inc(k);
    if k > yygh[state] then
      yygoto := false
    else
    begin
      nstate := yyg[k].act;
      yygoto := true;
    end;
  end (*yygoto*);

label
  parse, next, error, errlab, shift, reduce, accept, abort;

begin (*yyparse*)

  (* initialize: *)

  yystate := 0;
  yychar := -1;
  yynerrs := 0;
  yyerrflag := 0;
  yysp := 0;

{$IFDEF yydebug}
  yydebug := true;
{$ELSE}
  yydebug := false;
{$ENDIF}

  parse:

  (* push state and value: *)

  inc(yysp);
  if yysp > yymaxdepth then
  begin
    yyerror('yyparse stack overflow');
    goto abort;
  end;
  yys[yysp] := yystate;
  yyv[yysp] := yyval;

  next:

  if (yyd[yystate] = 0) and (yychar = -1) then
    (* get next symbol *)
  begin
    yychar := yylex;
    if yychar < 0 then
      yychar := 0;
  end;

  if yydebug then
    writeln('state ', yystate, ', char ', yychar);

  (* determine parse action: *)

  yyn := yyd[yystate];
  if yyn <> 0 then
    goto reduce; (* simple state *)

  (* no default action; search parse table *)

  if not yyact(yystate, yychar, yyn) then
    goto error
  else if yyn > 0 then
    goto shift
  else if yyn < 0 then
    goto reduce
  else
    goto accept;

  error:

  (* error; start error recovery: *)

  if yyerrflag = 0 then
    yyerror('syntax error');

  errlab:

  if yyerrflag = 0 then
    inc(yynerrs); (* new error *)

  if yyerrflag <= 2 then (* incomplete recovery; try again *)
  begin
    yyerrflag := 3;
    (* uncover a state with shift action on error token *)
    while (yysp > 0) and not (yyact(yys[yysp], _error, yyn) and
      (yyn > 0)) do
    begin
      if yydebug then
        if yysp > 1 then
          writeln('error recovery pops state ', yys[yysp], ', uncovers ',
            yys[yysp - 1])
        else
          writeln('error recovery fails ... abort');
      dec(yysp);
    end;
    if yysp = 0 then
      goto abort; (* parser has fallen from stack; abort *)
    yystate := yyn; (* simulate shift on error *)
    goto parse;
  end
  else (* no shift yet; discard symbol *)
  begin
    if yydebug then
      writeln('error recovery discards char ', yychar);
    if yychar = 0 then
      goto abort; (* end of input; abort *)
    yychar := -1;
    goto next; (* clear lookahead char and try again *)
  end;

  shift:

  (* go to new state, clear lookahead character: *)

  yystate := yyn;
  yychar := -1;
  yyval := yylval;
  if yyerrflag > 0 then
    dec(yyerrflag);

  goto parse;

  reduce:

  (* execute action, pop rule from stack, and go to next state: *)

  if yydebug then
    writeln('reduce ', -yyn);

  yyflag := yyfnone;
  yyaction(-yyn);
  dec(yysp, yyr[-yyn].len);
  if yygoto(yys[yysp], yyr[-yyn].sym, yyn) then
    yystate := yyn;

  (* handle action calls to yyaccept, yyabort and yyerror: *)

  case yyflag of
    yyfaccept: goto accept;
    yyfabort: goto abort;
    yyferror: goto errlab;
  end;

  goto parse;

  accept:

  yyparse := 0;
  exit;

  abort:

  yyparse := 1;
  exit;

end (*yyparse*);

begin
  if yyparse = 0 then { 结束 }
    ;
end.