(* lexical analyzer template (TP Lex V3.0), V1.0 3-2-91 AG *)
(* 24.3.98: repacked into an class to make code thread-safe *)

(* global definitions: *)

function is_Keyword(id : string; var token : integer) : boolean;
  const
    id_len = 20;
  type
    Ident = string[id_len];
  const
    (* 條件保留字: *)
    no_of_keywords = 18;
    keyword : array [1..no_of_keywords] of Ident = (
	'ABS', 'AND', 'ARCCOS', 'ARCCOTAN', 'ARCSIN', 'ARCTAN', 'COS', 'COTAN', 
	'IIF', 'NOT', 'OR', 'PI', 'ROUND', 'SIN', 'SQR', 'SQRT', 'TAN', 'TRUNC');
    keyword_token : array [1..no_of_keywords] of integer = (
	_ABS, _AND, _ARCCOS, _ARCCOTAN, _ARCSIN, _ARCTAN, _COS, _COTAN, 
	_IIF, _NOT, _OR, _PI, _ROUND, _SIN, _SQR, _SQRT, _TAN, _TRUNC);
  var 
    m, n, k : integer;
  begin
    id := UpperCase(id);
    (* binary search: *)
    m := 1; 
    n := no_of_keywords;
    while m<=n do
      begin
        k := m+(n-m) div 2;
        if id = keyword[k] then
          begin
            is_keyword := true;
            token := keyword_token[k];
            exit
          end
        else if id>keyword[k] then
          m := k+1
        else
          n := k-1
      end;
    is_keyword := false
  end(*is_keyword*);




constructor TLex.Create;
begin
  inherited Create;
  llib := TLexLib.Create;
end; { TLex.Create }

destructor TLex.Destroy;
begin
  llib.Destroy;
  inherited Destroy;
end; { TLex.Destroy }

function TLex.yylex(var yylval: YYSType): Integer;

procedure yyaction ( yyruleno : Integer );
  (* local definitions: *)


var c  : char;
    kw : integer;


begin
  (* actions: *)
  case yyruleno of
  1:
                       	if is_keyword(llib.yytext, kw) then
			  llib.return(kw)                        
                        else
                        begin
                          yylval.yystring := llib.yytext;
                          llib.return(_NAME);
                        end;
                        
	//* punctuation */

  2:
     llib.return(_EQ);
  3:
     llib.return(_NOTEQ);
  4:
     llib.return(_LESS);
  5:
     llib.return(_GREAT);
  6:
     llib.return(_LESSEQ);
  7:
     llib.return(_GREATEQ);

  8:
             	llib.returnc(llib.yytext[1]);
		
		
	//* numbers */

  9:
        		   
  begin
    yylval.yyDouble := StrToInt(llib.yytext);
    llib.return(_INTNUM);
  end;
  10:
                           
  begin
    yylval.yyDouble := StrToFloat(llib.yytext);    
    llib.return(_APPROXNUM);
  end;

  11:
         		;

  12:
 			llib.return(_ILLEGAL);
  end;
end(*yyaction*);

(* DFA table: *)

type YYTRec = record
                cc : set of Char;
                s  : Integer;
              end;

const

yynmarks   = 32;
yynmatches = 32;
yyntrans   = 46;
yynstates  = 23;

yyk : array [1..yynmarks] of Integer = (
  { 0: }
  9,
  { 1: }
  9,
  { 2: }
  1,
  12,
  { 3: }
  2,
  12,
  { 4: }
  4,
  12,
  { 5: }
  5,
  12,
  { 6: }
  8,
  12,
  { 7: }
  9,
  12,
  { 8: }
  8,
  9,
  12,
  { 9: }
  1,
  12,
  { 10: }
  11,
  { 11: }
  11,
  12,
  { 12: }
  12,
  { 13: }
  1,
  { 14: }
  3,
  { 15: }
  6,
  { 16: }
  7,
  { 17: }
  9,
  { 18: }
  9,
  { 19: }
  { 20: }
  { 21: }
  1,
  10,
  { 22: }
  10
);

yym : array [1..yynmatches] of Integer = (
{ 0: }
  9,
{ 1: }
  9,
{ 2: }
  1,
  12,
{ 3: }
  2,
  12,
{ 4: }
  4,
  12,
{ 5: }
  5,
  12,
{ 6: }
  8,
  12,
{ 7: }
  9,
  12,
{ 8: }
  8,
  9,
  12,
{ 9: }
  1,
  12,
{ 10: }
  11,
{ 11: }
  11,
  12,
{ 12: }
  12,
{ 13: }
  1,
{ 14: }
  3,
{ 15: }
  6,
{ 16: }
  7,
{ 17: }
  9,
{ 18: }
  9,
{ 19: }
{ 20: }
{ 21: }
  1,
  10,
{ 22: }
  10
);

yyt : array [1..yyntrans] of YYTrec = (
{ 0: }
  ( cc: [ #1..#8,#11,#13..#31,'!'..'''','@','['..'`',
            '{'..#255 ]; s: 12),
  ( cc: [ #9,#12,' ' ]; s: 11),
  ( cc: [ #10 ]; s: 10),
  ( cc: [ '('..'-','/',':',';','?' ]; s: 6),
  ( cc: [ '.' ]; s: 8),
  ( cc: [ '0'..'9' ]; s: 7),
  ( cc: [ '<' ]; s: 4),
  ( cc: [ '=' ]; s: 3),
  ( cc: [ '>' ]; s: 5),
  ( cc: [ 'A'..'D','F'..'Z','a'..'d','f'..'z' ]; s: 2),
  ( cc: [ 'E','e' ]; s: 9),
{ 1: }
  ( cc: [ #1..#8,#11,#13..#31,'!'..'''','@','['..'`',
            '{'..#255 ]; s: 12),
  ( cc: [ #9,#12,' ' ]; s: 11),
  ( cc: [ #10 ]; s: 10),
  ( cc: [ '('..'-','/',':',';','?' ]; s: 6),
  ( cc: [ '.' ]; s: 8),
  ( cc: [ '0'..'9' ]; s: 7),
  ( cc: [ '<' ]; s: 4),
  ( cc: [ '=' ]; s: 3),
  ( cc: [ '>' ]; s: 5),
  ( cc: [ 'A'..'D','F'..'Z','a'..'d','f'..'z' ]; s: 2),
  ( cc: [ 'E','e' ]; s: 9),
{ 2: }
  ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 13),
{ 3: }
{ 4: }
  ( cc: [ '=' ]; s: 15),
  ( cc: [ '>' ]; s: 14),
{ 5: }
  ( cc: [ '=' ]; s: 16),
{ 6: }
{ 7: }
  ( cc: [ '.' ]; s: 18),
  ( cc: [ '0'..'9' ]; s: 17),
  ( cc: [ 'E','e' ]; s: 19),
{ 8: }
  ( cc: [ '0'..'9' ]; s: 18),
  ( cc: [ 'E','e' ]; s: 19),
{ 9: }
  ( cc: [ '+','-' ]; s: 20),
  ( cc: [ '0'..'9' ]; s: 21),
  ( cc: [ 'A'..'Z','_','a'..'z' ]; s: 13),
{ 10: }
{ 11: }
{ 12: }
{ 13: }
  ( cc: [ '0'..'9','A'..'Z','_','a'..'z' ]; s: 13),
{ 14: }
{ 15: }
{ 16: }
{ 17: }
  ( cc: [ '.' ]; s: 18),
  ( cc: [ '0'..'9' ]; s: 17),
  ( cc: [ 'E','e' ]; s: 19),
{ 18: }
  ( cc: [ '0'..'9' ]; s: 18),
  ( cc: [ 'E','e' ]; s: 19),
{ 19: }
  ( cc: [ '+','-' ]; s: 20),
  ( cc: [ '0'..'9' ]; s: 22),
{ 20: }
  ( cc: [ '0'..'9' ]; s: 22),
{ 21: }
  ( cc: [ '0'..'9' ]; s: 21),
  ( cc: [ 'A'..'Z','_','a'..'z' ]; s: 13),
{ 22: }
  ( cc: [ '0'..'9' ]; s: 22)
);

yykl : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 2,
{ 2: } 3,
{ 3: } 5,
{ 4: } 7,
{ 5: } 9,
{ 6: } 11,
{ 7: } 13,
{ 8: } 15,
{ 9: } 18,
{ 10: } 20,
{ 11: } 21,
{ 12: } 23,
{ 13: } 24,
{ 14: } 25,
{ 15: } 26,
{ 16: } 27,
{ 17: } 28,
{ 18: } 29,
{ 19: } 30,
{ 20: } 30,
{ 21: } 30,
{ 22: } 32
);

yykh : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 2,
{ 2: } 4,
{ 3: } 6,
{ 4: } 8,
{ 5: } 10,
{ 6: } 12,
{ 7: } 14,
{ 8: } 17,
{ 9: } 19,
{ 10: } 20,
{ 11: } 22,
{ 12: } 23,
{ 13: } 24,
{ 14: } 25,
{ 15: } 26,
{ 16: } 27,
{ 17: } 28,
{ 18: } 29,
{ 19: } 29,
{ 20: } 29,
{ 21: } 31,
{ 22: } 32
);

yyml : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 2,
{ 2: } 3,
{ 3: } 5,
{ 4: } 7,
{ 5: } 9,
{ 6: } 11,
{ 7: } 13,
{ 8: } 15,
{ 9: } 18,
{ 10: } 20,
{ 11: } 21,
{ 12: } 23,
{ 13: } 24,
{ 14: } 25,
{ 15: } 26,
{ 16: } 27,
{ 17: } 28,
{ 18: } 29,
{ 19: } 30,
{ 20: } 30,
{ 21: } 30,
{ 22: } 32
);

yymh : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 2,
{ 2: } 4,
{ 3: } 6,
{ 4: } 8,
{ 5: } 10,
{ 6: } 12,
{ 7: } 14,
{ 8: } 17,
{ 9: } 19,
{ 10: } 20,
{ 11: } 22,
{ 12: } 23,
{ 13: } 24,
{ 14: } 25,
{ 15: } 26,
{ 16: } 27,
{ 17: } 28,
{ 18: } 29,
{ 19: } 29,
{ 20: } 29,
{ 21: } 31,
{ 22: } 32
);

yytl : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 12,
{ 2: } 23,
{ 3: } 24,
{ 4: } 24,
{ 5: } 26,
{ 6: } 27,
{ 7: } 27,
{ 8: } 30,
{ 9: } 32,
{ 10: } 35,
{ 11: } 35,
{ 12: } 35,
{ 13: } 35,
{ 14: } 36,
{ 15: } 36,
{ 16: } 36,
{ 17: } 36,
{ 18: } 39,
{ 19: } 41,
{ 20: } 43,
{ 21: } 44,
{ 22: } 46
);

yyth : array [0..yynstates-1] of Integer = (
{ 0: } 11,
{ 1: } 22,
{ 2: } 23,
{ 3: } 23,
{ 4: } 25,
{ 5: } 26,
{ 6: } 26,
{ 7: } 29,
{ 8: } 31,
{ 9: } 34,
{ 10: } 34,
{ 11: } 34,
{ 12: } 34,
{ 13: } 35,
{ 14: } 35,
{ 15: } 35,
{ 16: } 35,
{ 17: } 38,
{ 18: } 40,
{ 19: } 42,
{ 20: } 43,
{ 21: } 45,
{ 22: } 46
);


var yyn : Integer;

label start, scan, action;

begin
start:
with llib do begin

  (* 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; (* with *)
end(*yylex*);

end. (* unit *)