isverb.dpr

语法分析 语法分析

    (cc: ['n']; s: 50),
    { 38: }
    (cc: ['A'..'Z', 'a'..'r', 't'..'z']; s: 16),
    (cc: ['s']; s: 51),
    { 39: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 40: }
    (cc: ['A'..'Z', 'a'..'t', 'v'..'z']; s: 16),
    (cc: ['u']; s: 52),
    { 41: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 42: }
    (cc: ['A'..'Z', 'a'..'k', 'm'..'z']; s: 16),
    (cc: ['l']; s: 53),
    { 43: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 44: }
    (cc: ['A'..'Z', 'a'..'d', 'f'..'z']; s: 16),
    (cc: ['e']; s: 54),
    { 45: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 46: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 47: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 48: }
    (cc: ['A'..'Z', 'a'..'c', 'e'..'z']; s: 16),
    (cc: ['d']; s: 55),
    { 49: }
    (cc: ['A'..'Z', 'a'..'f', 'h'..'z']; s: 16),
    (cc: ['g']; s: 56),
    { 50: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 51: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 52: }
    (cc: ['A'..'Z', 'a'..'k', 'm'..'z']; s: 16),
    (cc: ['l']; s: 57),
    { 53: }
    (cc: ['A'..'Z', 'a'..'c', 'e'..'z']; s: 16),
    (cc: ['d']; s: 58),
    { 54: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 55: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 56: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 57: }
    (cc: ['A'..'Z', 'a'..'c', 'e'..'z']; s: 16),
    (cc: ['d']; s: 59),
    { 58: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16),
    { 59: }
    (cc: ['A'..'Z', 'a'..'z']; s: 16)
    );

  yykl: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 1,
    { 2: } 1,
    { 3: } 3,
    { 4: } 5,
    { 5: } 7,
    { 6: } 9,
    { 7: } 11,
    { 8: } 13,
    { 9: } 15,
    { 10: } 17,
    { 11: } 19,
    { 12: } 21,
    { 13: } 23,
    { 14: } 24,
    { 15: } 25,
    { 16: } 27,
    { 17: } 28,
    { 18: } 30,
    { 19: } 31,
    { 20: } 32,
    { 21: } 33,
    { 22: } 34,
    { 23: } 35,
    { 24: } 37,
    { 25: } 39,
    { 26: } 40,
    { 27: } 41,
    { 28: } 42,
    { 29: } 43,
    { 30: } 44,
    { 31: } 46,
    { 32: } 48,
    { 33: } 49,
    { 34: } 51,
    { 35: } 52,
    { 36: } 53,
    { 37: } 54,
    { 38: } 55,
    { 39: } 56,
    { 40: } 58,
    { 41: } 59,
    { 42: } 61,
    { 43: } 62,
    { 44: } 64,
    { 45: } 65,
    { 46: } 67,
    { 47: } 69,
    { 48: } 71,
    { 49: } 72,
    { 50: } 73,
    { 51: } 75,
    { 52: } 77,
    { 53: } 78,
    { 54: } 79,
    { 55: } 81,
    { 56: } 83,
    { 57: } 85,
    { 58: } 86,
    { 59: } 88
    );

  yykh: array[0..yynstates - 1] of Integer = (
    { 0: } 0,
    { 1: } 0,
    { 2: } 2,
    { 3: } 4,
    { 4: } 6,
    { 5: } 8,
    { 6: } 10,
    { 7: } 12,
    { 8: } 14,
    { 9: } 16,
    { 10: } 18,
    { 11: } 20,
    { 12: } 22,
    { 13: } 23,
    { 14: } 24,
    { 15: } 26,
    { 16: } 27,
    { 17: } 29,
    { 18: } 30,
    { 19: } 31,
    { 20: } 32,
    { 21: } 33,
    { 22: } 34,
    { 23: } 36,
    { 24: } 38,
    { 25: } 39,
    { 26: } 40,
    { 27: } 41,
    { 28: } 42,
    { 29: } 43,
    { 30: } 45,
    { 31: } 47,
    { 32: } 48,
    { 33: } 50,
    { 34: } 51,
    { 35: } 52,
    { 36: } 53,
    { 37: } 54,
    { 38: } 55,
    { 39: } 57,
    { 40: } 58,
    { 41: } 60,
    { 42: } 61,
    { 43: } 63,
    { 44: } 64,
    { 45: } 66,
    { 46: } 68,
    { 47: } 70,
    { 48: } 71,
    { 49: } 72,
    { 50: } 74,
    { 51: } 76,
    { 52: } 77,
    { 53: } 78,
    { 54: } 80,
    { 55: } 82,
    { 56: } 84,
    { 57: } 85,
    { 58: } 87,
    { 59: } 89
    );

  yyml: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 1,
    { 2: } 1,
    { 3: } 3,
    { 4: } 5,
    { 5: } 7,
    { 6: } 9,
    { 7: } 11,
    { 8: } 13,
    { 9: } 15,
    { 10: } 17,
    { 11: } 19,
    { 12: } 21,
    { 13: } 23,
    { 14: } 24,
    { 15: } 25,
    { 16: } 27,
    { 17: } 28,
    { 18: } 30,
    { 19: } 31,
    { 20: } 32,
    { 21: } 33,
    { 22: } 34,
    { 23: } 35,
    { 24: } 37,
    { 25: } 39,
    { 26: } 40,
    { 27: } 41,
    { 28: } 42,
    { 29: } 43,
    { 30: } 44,
    { 31: } 46,
    { 32: } 48,
    { 33: } 49,
    { 34: } 51,
    { 35: } 52,
    { 36: } 53,
    { 37: } 54,
    { 38: } 55,
    { 39: } 56,
    { 40: } 58,
    { 41: } 59,
    { 42: } 61,
    { 43: } 62,
    { 44: } 64,
    { 45: } 65,
    { 46: } 67,
    { 47: } 69,
    { 48: } 71,
    { 49: } 72,
    { 50: } 73,
    { 51: } 75,
    { 52: } 77,
    { 53: } 78,
    { 54: } 79,
    { 55: } 81,
    { 56: } 83,
    { 57: } 85,
    { 58: } 86,
    { 59: } 88
    );

  yymh: array[0..yynstates - 1] of Integer = (
    { 0: } 0,
    { 1: } 0,
    { 2: } 2,
    { 3: } 4,
    { 4: } 6,
    { 5: } 8,
    { 6: } 10,
    { 7: } 12,
    { 8: } 14,
    { 9: } 16,
    { 10: } 18,
    { 11: } 20,
    { 12: } 22,
    { 13: } 23,
    { 14: } 24,
    { 15: } 26,
    { 16: } 27,
    { 17: } 29,
    { 18: } 30,
    { 19: } 31,
    { 20: } 32,
    { 21: } 33,
    { 22: } 34,
    { 23: } 36,
    { 24: } 38,
    { 25: } 39,
    { 26: } 40,
    { 27: } 41,
    { 28: } 42,
    { 29: } 43,
    { 30: } 45,
    { 31: } 47,
    { 32: } 48,
    { 33: } 50,
    { 34: } 51,
    { 35: } 52,
    { 36: } 53,
    { 37: } 54,
    { 38: } 55,
    { 39: } 57,
    { 40: } 58,
    { 41: } 60,
    { 42: } 61,
    { 43: } 63,
    { 44: } 64,
    { 45: } 66,
    { 46: } 68,
    { 47: } 70,
    { 48: } 71,
    { 49: } 72,
    { 50: } 74,
    { 51: } 76,
    { 52: } 77,
    { 53: } 78,
    { 54: } 80,
    { 55: } 82,
    { 56: } 84,
    { 57: } 85,
    { 58: } 87,
    { 59: } 89
    );

  yytl: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 13,
    { 2: } 25,
    { 3: } 26,
    { 4: } 28,
    { 5: } 31,
    { 6: } 36,
    { 7: } 38,
    { 8: } 41,
    { 9: } 43,
    { 10: } 46,
    { 11: } 48,
    { 12: } 50,
    { 13: } 51,
    { 14: } 51,
    { 15: } 52,
    { 16: } 53,
    { 17: } 54,
    { 18: } 55,
    { 19: } 57,
    { 20: } 59,
    { 21: } 61,
    { 22: } 63,
    { 23: } 65,
    { 24: } 68,
    { 25: } 70,
    { 26: } 72,
    { 27: } 74,
    { 28: } 76,
    { 29: } 78,
    { 30: } 82,
    { 31: } 83,
    { 32: } 84,
    { 33: } 86,
    { 34: } 87,
    { 35: } 89,
    { 36: } 91,
    { 37: } 93,
    { 38: } 95,
    { 39: } 97,
    { 40: } 98,
    { 41: } 100,
    { 42: } 101,
    { 43: } 103,
    { 44: } 104,
    { 45: } 106,
    { 46: } 107,
    { 47: } 108,
    { 48: } 109,
    { 49: } 111,
    { 50: } 113,
    { 51: } 114,
    { 52: } 115,
    { 53: } 117,
    { 54: } 119,
    { 55: } 120,
    { 56: } 121,
    { 57: } 122,
    { 58: } 124,
    { 59: } 125
    );

  yyth: array[0..yynstates - 1] of Integer = (
    { 0: } 12,
    { 1: } 24,
    { 2: } 25,
    { 3: } 27,
    { 4: } 30,
    { 5: } 35,
    { 6: } 37,
    { 7: } 40,
    { 8: } 42,
    { 9: } 45,
    { 10: } 47,
    { 11: } 49,
    { 12: } 50,
    { 13: } 50,
    { 14: } 51,
    { 15: } 52,
    { 16: } 53,
    { 17: } 54,
    { 18: } 56,
    { 19: } 58,
    { 20: } 60,
    { 21: } 62,
    { 22: } 64,
    { 23: } 67,
    { 24: } 69,
    { 25: } 71,
    { 26: } 73,
    { 27: } 75,
    { 28: } 77,
    { 29: } 81,
    { 30: } 82,
    { 31: } 83,
    { 32: } 85,
    { 33: } 86,
    { 34: } 88,
    { 35: } 90,
    { 36: } 92,
    { 37: } 94,
    { 38: } 96,
    { 39: } 97,
    { 40: } 99,
    { 41: } 100,
    { 42: } 102,
    { 43: } 103,
    { 44: } 105,
    { 45: } 106,
    { 46: } 107,
    { 47: } 108,
    { 48: } 110,
    { 49: } 112,
    { 50: } 113,
    { 51: } 114,
    { 52: } 116,
    { 53: } 118,
    { 54: } 119,
    { 55: } 120,
    { 56: } 121,
    { 57: } 123,
    { 58: } 124,
    { 59: } 125
    );

var
  yyn: Integer;

label
  start, scan, action;

begin

  start:

  (* initialize: *)

  yynew;

  scan:

  (* mark positions and matches: *)

  for yyn := yykl[yystate] to yykh[yystate] do
    yymark(yyk[yyn]);
  for yyn := yymh[yystate] downto yyml[yystate] do
    yymatch(yym[yyn]);

  if yytl[yystate] > yyth[yystate] then
    goto action; (* dead state *)

  (* get next character: *)

  yyscan;

  (* determine action: *)

  yyn := yytl[yystate];
  while (yyn <= yyth[yystate]) and not (yyactchar in yyt[yyn].cc) do
    inc(yyn);
  if yyn > yyth[yystate] then
    goto action;
  (* no transition on yyactchar in this state *)

(* switch to new state: *)

  yystate := yyt[yyn].s;

  goto scan;

  action:

  (* execute action: *)

  if yyfind(yyrule) then
  begin
    yyaction(yyrule);
    if yyreject then
      goto action;
  end
  else if not yydefault and yywrap then
  begin
    yyclear;
    return(0);
  end;

  if not yydone then
    goto start;

  yylex := yyretval;

end (*yylex*);

begin
  yylex;
end.