commentc.dpr

语法分析 语法分析

    (cc: [#10]; s: 66),
    (cc: ['*']; s: 73),
    (cc: ['/']; s: 84),
    { 74: }
    (cc: [#1..#9, #11..')', '+'..'.', '0'..#255]; s: 74),
    (cc: [#10]; s: 67),
    (cc: ['*']; s: 75),
    (cc: ['/']; s: 80),
    { 75: }
    (cc: [#1..#9, #11..')', '+'..'.', '0'..#255]; s: 74),
    (cc: [#10]; s: 67),
    (cc: ['*']; s: 75),
    (cc: ['/']; s: 82),
    { 76: }
    (cc: [#1..#8, #11..#31, '!'..')', '+'..'.', '0'..#255]; s: 74),
    (cc: [#9, ' ']; s: 78),
    (cc: [#10]; s: 85),
    (cc: ['*']; s: 75),
    (cc: ['/']; s: 80),
    { 77: }
    { 78: }
    (cc: [#1..#8, #11..#31, '!'..')', '+'..'.', '0'..#255]; s: 74),
    (cc: [#9, ' ']; s: 78),
    (cc: [#10]; s: 85),
    (cc: ['*']; s: 75),
    (cc: ['/']; s: 80),
    { 79: }
    { 80: }
    (cc: [#1..#9, #11..')', '+'..'.', '0'..#255]; s: 74),
    (cc: [#10]; s: 67),
    (cc: ['*']; s: 75),
    (cc: ['/']; s: 80),
    { 81: }
    { 82: }
    (cc: [#1..#8, #11..#31, '!'..')', '+'..'.', '0'..#255]; s: 68),
    (cc: [#9, ' ']; s: 70),
    (cc: [#10]; s: 83),
    (cc: ['*']; s: 69),
    (cc: ['/']; s: 72),
    { 83: }
    { 84: }
    (cc: [#1..#8, #11..#31, '!'..')', '+'..'.', '0'..#255]; s: 52),
    (cc: [#9, ' ']; s: 54),
    (cc: [#10]; s: 77),
    (cc: ['*']; s: 53),
    (cc: ['/']; s: 56)
    { 85: }
    );

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

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

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

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

  yytl: array[0..yynstates - 1] of Integer = (
    { 0: } 1,
    { 1: } 3,
    { 2: } 7,
    { 3: } 11,
    { 4: } 16,
    { 5: } 19,
    { 6: } 23,
    { 7: } 27,
    { 8: } 31,
    { 9: } 31,
    { 10: } 34,
    { 11: } 34,
    { 12: } 37,
    { 13: } 41,
    { 14: } 45,
    { 15: } 49,
    { 16: } 49,
    { 17: } 51,
    { 18: } 54,
    { 19: } 54,
    { 20: } 57,
    { 21: } 61,
    { 22: } 64,
    { 23: } 64,
    { 24: } 67,
    { 25: } 72,
    { 26: } 72,
    { 27: } 72,
    { 28: } 76,
    { 29: } 79,
    { 30: } 82,
    { 31: } 86,
    { 32: } 89,
    { 33: } 92,
    { 34: } 95,
    { 35: } 99,
    { 36: } 99,
    { 37: } 103,
    { 38: } 107,
    { 39: } 107,
    { 40: } 111,
    { 41: } 114,
    { 42: } 118,
    { 43: } 122,
    { 44: } 126,
    { 45: } 131,
    { 46: } 135,
    { 47: } 139,
    { 48: } 143,
    { 49: } 147,
    { 50: } 151,
    { 51: } 155,
    { 52: } 160,
    { 53: } 164,
    { 54: } 168,
    { 55: } 173,
    { 56: } 173,
    { 57: } 177,
    { 58: } 182,
    { 59: } 186,
    { 60: } 190,
    { 61: } 194,
    { 62: } 194,
    { 63: } 198,
    { 64: } 202,
    { 65: } 206,
    { 66: } 210,
    { 67: } 210,
    { 68: } 210,
    { 69: } 214,
    { 70: } 218,
    { 71: } 223,
    { 72: } 223,
    { 73: } 227,
    { 74: } 231,
    { 75: } 235,
    { 76: } 239,
    { 77: } 244,
    { 78: } 244,
    { 79: } 249,
    { 80: } 249,
    { 81: } 253,
    { 82: } 253,
    { 83: } 258,
    { 84: } 258,
    { 85: } 263
    );

  yyth: array[0..yynstates - 1] of Integer = (
    { 0: } 2,
    { 1: } 6,
    { 2: } 10,
    { 3: } 15,
    { 4: } 18,
    { 5: } 22,
    { 6: } 26,
    { 7: } 30,
    { 8: } 30,
    { 9: } 33,
    { 10: } 33,
    { 11: } 36,
    { 12: } 40,
    { 13: } 44,
    { 14: } 48,
    { 15: } 48,
    { 16: } 50,
    { 17: } 53,
    { 18: } 53,
    { 19: } 56,
    { 20: } 60,
    { 21: } 63,
    { 22: } 63,
    { 23: } 66,
    { 24: } 71,
    { 25: } 71,
    { 26: } 71,
    { 27: } 75,
    { 28: } 78,
    { 29: } 81,
    { 30: } 85,
    { 31: } 88,
    { 32: } 91,
    { 33: } 94,
    { 34: } 98,
    { 35: } 98,
    { 36: } 102,
    { 37: } 106,
    { 38: } 106,
    { 39: } 110,
    { 40: } 113,
    { 41: } 117,
    { 42: } 121,
    { 43: } 125,
    { 44: } 130,
    { 45: } 134,
    { 46: } 138,
    { 47: } 142,
    { 48: } 146,
    { 49: } 150,
    { 50: } 154,
    { 51: } 159,
    { 52: } 163,
    { 53: } 167,
    { 54: } 172,
    { 55: } 172,
    { 56: } 176,
    { 57: } 181,
    { 58: } 185,
    { 59: } 189,
    { 60: } 193,
    { 61: } 193,
    { 62: } 197,
    { 63: } 201,
    { 64: } 205,
    { 65: } 209,
    { 66: } 209,
    { 67: } 209,
    { 68: } 213,
    { 69: } 217,
    { 70: } 222,
    { 71: } 222,
    { 72: } 226,
    { 73: } 230,
    { 74: } 234,
    { 75: } 238,
    { 76: } 243,
    { 77: } 243,
    { 78: } 248,
    { 79: } 248,
    { 80: } 252,
    { 81: } 252,
    { 82: } 257,
    { 83: } 257,
    { 84: } 262,
    { 85: } 262
    );

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();
  writeln(format('代码行数: %d, 注释行数：%d, 空白行数：%d', [code, comments,
    whiteSpace]));
  readln;
end.