path: root/gcc/m2/gm2-compiler/CLexBuf.mod

(* CLexBuf.mod provides a lexical buffer for clex.

Copyright (C) 2003-2025 Free Software Foundation, Inc.
Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.

This file is part of GNU Modula-2.

GNU Modula-2 is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GNU Modula-2 is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Modula-2; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  *)

IMPLEMENTATION MODULE CLexBuf ;

IMPORT cflex ;

FROM SYSTEM IMPORT ADDRESS ;
FROM Storage IMPORT ALLOCATE, DEALLOCATE ;
FROM DynamicStrings IMPORT string, InitString, InitStringCharStar, Equal, Mark, KillString ;
FROM FormatStrings IMPORT Sprintf1 ;
FROM NameKey IMPORT Name, NulName, makekey, KeyToCharStar ;
FROM M2Printf IMPORT printf0, printf1, printf2, printf3 ;
FROM Assertion IMPORT Assert ;
FROM SymbolKey IMPORT NulKey, SymbolTree, InitTree, DelSymKey, PutSymKey, GetSymKey ;
FROM Indexing IMPORT Index, InitIndex, IsIndiceInIndex, GetIndice, PutIndice ;

CONST
   MaxBucketSize = 100 ;
   Debugging     = FALSE ;

TYPE
   SourceList = POINTER TO sourcelist ;
   sourcelist =            RECORD
                              left,
                              right: SourceList ;
                              name : String ;
                              line : CARDINAL ;
                           END ;

   TokenDesc = RECORD
                  token: toktype ;
                  str  : Name ;
                  int  : INTEGER ;
                  line : CARDINAL ;
                  file : SourceList ;
               END ;

   TokenBucket = POINTER TO tokenbucket ;
   tokenbucket =            RECORD
                               buf : ARRAY [0..MaxBucketSize] OF TokenDesc ;
                               len : CARDINAL ;
                               next: TokenBucket ;
                            END ;

   ListDesc = RECORD
                 head,
                 tail            : TokenBucket ;
                 LastBucketOffset: CARDINAL ;
              END ;

   MacroArgs = POINTER TO macroargs ;
   macroargs =            RECORD
                             next: MacroArgs ;
                             str : Name ;
                          END ;

   Macro = POINTER TO macro ;
   macro =            RECORD
                         str   : Name ;
                         tokno : CARDINAL ;
                         noArgs: CARDINAL ;
                         args  : MacroArgs ;
                      END ;

VAR
   CurrentSource    : SourceList ;
   UseBufferedTokens,
   CurrentUsed      : BOOLEAN ;
   ListOfTokens     : ListDesc ;
   CurrentTokNo     : CARDINAL ;
   MacroDefinitions : SymbolTree ;
   MacroIndex       : Index ;
   DefineNo         : CARDINAL ;
   EnabledMacros    : BOOLEAN ;


(* M A C R O *)

(*
   EnableMacroSubstitutions -
*)

PROCEDURE EnableMacroSubstitutions (b: BOOLEAN) ;
BEGIN
   EnabledMacros := b
END EnableMacroSubstitutions ;


(*
   IsMacroDefined - returns TRUE if macro, n, was defined.
*)

PROCEDURE IsMacroDefined (n: Name) : BOOLEAN ;
VAR
   i: CARDINAL ;
   m: Macro ;
BEGIN
   i := GetSymKey(MacroDefinitions, n) ;
   IF i=0
   THEN
      RETURN( FALSE )
   ELSE
      m := GetIndice(MacroIndex, i) ;
      IF m=NIL
      THEN
         RETURN( FALSE )
      ELSE
         RETURN( TRUE )
      END
   END
END IsMacroDefined ;


(*
   NoArgs - returns the number of arguments for macro, n.
            -1 if the macro does not exist
*)

PROCEDURE NoArgs (n: Name) : INTEGER ;
VAR
   m: Macro ;
   i: CARDINAL ;
BEGIN
   IF IsMacroDefined(n)
   THEN
      i := GetSymKey(MacroDefinitions, n) ;
      m := GetIndice(MacroIndex, i) ;
      RETURN( m^.noArgs )
   ELSE
      RETURN( -1 )
   END
END NoArgs ;


(*
   DefineMacro - defines macro, n, as defined to start at token, t.
*)

PROCEDURE DefineMacro (n: Name; t: CARDINAL) ;
VAR
   m: Macro ;
   i: CARDINAL ;
BEGIN
   NEW(m) ;
   WITH m^ DO
      str := n ;
      tokno := t ;
      noArgs := 0 ;
      args := NIL
   END ;
   UnDefineMacro(n) ;
   i := GetSymKey(MacroDefinitions, n) ;
   IF i=NulKey
   THEN
      PutSymKey(MacroDefinitions, n, DefineNo) ;
      i := DefineNo ;
      INC(DefineNo)
   END ;
   PutIndice(MacroIndex, i, m)
END DefineMacro ;


(*
   UnDefineMacro -
*)

PROCEDURE UnDefineMacro (n: Name) ;
VAR
   m: Macro ;
   i: CARDINAL ;
BEGIN
   IF IsMacroDefined(n)
   THEN
      i := GetSymKey(MacroDefinitions, n) ;
      m := GetIndice(MacroIndex, i) ;
      PutIndice(MacroIndex, i, NIL) ;
      DISPOSE(m)
   END
END UnDefineMacro ;


(*
   PushMacroDefinition - pushes the macro definition, n, onto the token stream.
                         It returns TRUE if the macro was found and pushed.
*)

PROCEDURE PushMacroDefinition (n: Name) : BOOLEAN ;
VAR
   m: Macro ;
   t: CARDINAL ;
   b: TokenBucket ;
   i: CARDINAL ;
BEGIN
   IF EnabledMacros AND IsMacroDefined(n)
   THEN
      i := GetSymKey(MacroDefinitions, n) ;
      m := GetIndice(MacroIndex, i) ;
      WITH m^ DO
         IF tokno>0
         THEN
            t := tokno ;
            LOOP
               b := FindTokenBucket(t) ;
               WITH b^.buf[t] DO
                  IF token=endhashtok
                  THEN
                     RETURN( TRUE )
                  ELSE
                     IF IsMacroDefined(str) AND (str#n)
                     THEN
                        IF PushMacroDefinition(str)
                        THEN
                        END
                     ELSE
                        AddTokToList(token, str, int, line, file)
                     END
                  END
               END ;
               INC(t)
            END
         END
      END ;
      RETURN( TRUE )
   ELSE
      RETURN( FALSE )
   END
END PushMacroDefinition ;


(*   e n d    o f    M A C R O    r o u t i n e s   *)

PROCEDURE stop ; BEGIN END stop ;

(*
   Init - initializes the token list and source list.
*)

PROCEDURE Init ;
BEGIN
   currenttoken := eoftok ;
   CurrentTokNo := 0 ;
   CurrentSource := NIL ;
   ListOfTokens.head := NIL ;
   ListOfTokens.tail := NIL ;
   UseBufferedTokens := FALSE ;
   InitTree(MacroDefinitions) ;
   EnabledMacros := TRUE ;
   DefineNo := 1 ;
   MacroIndex := InitIndex(1)
END Init ;


(*
   AddTo - adds a new element to the end of SourceList, CurrentSource.
*)

PROCEDURE AddTo (l: SourceList) ;
BEGIN
   l^.right := CurrentSource ;
   l^.left  := CurrentSource^.left ;
   CurrentSource^.left^.right := l ;
   CurrentSource^.left := l ;
   l^.left^.line := cflex.GetLineNo()
END AddTo ;


(*
   SubFrom - subtracts, l, from the source list.
*)

PROCEDURE SubFrom (l: SourceList) ;
BEGIN
   l^.left^.right := l^.right ;
   l^.right^.left := l^.left
END SubFrom ;


(*
   NewElement - returns a new SourceList
*)

PROCEDURE NewElement (s: ADDRESS) : SourceList ;
VAR
   l: SourceList ;
BEGIN
   NEW(l) ;
   IF l=NIL
   THEN
      HALT
   ELSE
      WITH l^ DO
         name  := InitStringCharStar(s) ;
         left  := NIL ;
         right := NIL
      END
   END ;
   RETURN( l )
END NewElement ;


(*
   NewList - initializes an empty list with the classic dummy header element.
*)

PROCEDURE NewList () : SourceList ;
VAR
   l: SourceList ;
BEGIN
   NEW(l) ;
   WITH l^ DO
      left  := l ;
      right := l ;
      name  := NIL
   END ;
   RETURN( l )
END NewList ;


(*
   CheckIfNeedToDuplicate - checks to see whether the CurrentSource has
                            been used, if it has then duplicate the list.
*)

PROCEDURE CheckIfNeedToDuplicate ;
VAR
   l, h: SourceList ;
BEGIN
   IF CurrentUsed
   THEN
      l := CurrentSource^.right ;
      h := CurrentSource ;
      CurrentSource := NewList() ;
      WHILE l#h DO
         AddTo(NewElement(l^.name)) ;
         l := l^.right
      END
   END
END CheckIfNeedToDuplicate ;


(*
   PushFile - indicates that, filename, has just been included.
*)

PROCEDURE PushFile (filename: ADDRESS) ;
VAR
   l: SourceList ;
BEGIN
   CheckIfNeedToDuplicate ;
   AddTo(NewElement(filename)) ;
   IF Debugging
   THEN
      IF CurrentSource^.right#CurrentSource
      THEN
         l := CurrentSource ;
         REPEAT
            printf2('name = %s, line = %d\n', l^.name, l^.line) ;
            l := l^.right
         UNTIL l=CurrentSource
      END
   END
END PushFile ;


(*
   PopFile - indicates that we are returning to, filename, having finished
             an include.
*)

PROCEDURE PopFile (filename: ADDRESS) ;
VAR
   l: SourceList ;
BEGIN
   CheckIfNeedToDuplicate ;
   IF (CurrentSource#NIL) AND (CurrentSource^.left#CurrentSource)
   THEN
      l := CurrentSource^.left ;  (* last element *)
      SubFrom(l) ;
      DISPOSE(l) ;
      IF (CurrentSource^.left#CurrentSource) AND
         (NOT Equal(CurrentSource^.name, Mark(InitStringCharStar(filename))))
      THEN
         (* mismatch in source file names after preprocessing files *)
      END
   ELSE
      (* source file list is empty, cannot pop an include.. *)
   END
END PopFile ;


(*
   KillList - kills the SourceList providing that it has not been used.
*)

PROCEDURE KillList ;
VAR
   l, k: SourceList ;
BEGIN
   IF (NOT CurrentUsed) AND (CurrentSource#NIL)
   THEN
      l := CurrentSource ;
      REPEAT
         k := l ;
         l := l^.right ;
         DISPOSE(k)
      UNTIL l=CurrentSource
   END
END KillList ;


(*
   ReInitialize - re-initialize the all the data structures.
*)

PROCEDURE ReInitialize ;
VAR
   s, t: TokenBucket ;
BEGIN
   IF ListOfTokens.head#NIL
   THEN
      t := ListOfTokens.head ;
      REPEAT
         s := t ;
         t := t^.next ;
         DISPOSE(s) ;
      UNTIL t=NIL ;
      CurrentUsed := FALSE ;
      KillList
   END ;
   Init
END ReInitialize ;


(*
   SetFile - sets the current filename to, filename.
*)

PROCEDURE SetFile (filename: ADDRESS) ;
BEGIN
   KillList ;
   CurrentUsed   := FALSE ;
   CurrentSource := NewList() ;
   AddTo(NewElement(filename))
END SetFile ;


(*
   OpenSource - Attempts to open the source file, s.
                The success of the operation is returned.
*)

PROCEDURE OpenSource (s: String) : BOOLEAN ;
BEGIN
   IF UseBufferedTokens
   THEN
      GetToken ;
      RETURN( TRUE )
   ELSE
      IF cflex.OpenSource(string(s))
      THEN
         SetFile(string(s)) ;
         SyncOpenWithBuffer ;
         GetToken ;
         RETURN( TRUE )
      ELSE
         RETURN( FALSE )
      END
   END
END OpenSource ;


(*
   CloseSource - closes the current open file.
*)

PROCEDURE CloseSource ;
BEGIN
   IF UseBufferedTokens
   THEN
      WHILE currenttoken#eoftok DO
         GetToken
      END
   ELSE
      (* a subsequent call to cflex.OpenSource will really close the file *)
   END
END CloseSource ;


(*
   ResetForNewPass - reset the buffer pointers to the beginning ready for
                     a new pass
*)

PROCEDURE ResetForNewPass ;
BEGIN
   CurrentTokNo := 0 ;
   UseBufferedTokens := TRUE
END ResetForNewPass ;


(*
   DisplayToken -
*)

PROCEDURE DisplayToken ;
VAR
   n: Name ;
BEGIN
   cflex.CError(string(InitString('current token'))) ;
   IF currenttoken=identtok
   THEN
      n := makekey(currentstring) ;
      printf1('currenttoken = %a\n', n)
   ELSE
      CASE currenttoken OF

      eoftok               : printf0('eoftok\n') |
      startok              : printf0('*\n') |
      arrowtok             : printf0('->\n') |
      structtok            : printf0('struct\n') |
      lsbratok             : printf0('[\n') |
      rsbratok             : printf0(']\n') |
      lcbratok             : printf0('{\n') |
      rcbratok             : printf0('}\n') |
      lparatok             : printf0('(\n') |
      rparatok             : printf0(')\n') |
      semicolontok         : printf0(';\n') |
      longtok              : printf0('long\n') |
      inttok               : printf0('int\n') |
      chartok              : printf0('char\n') |
      enumtok              : printf0('enum\n') |
      typedeftok           : printf0('typedef\n') |
      floattok             : printf0('float\n') |
      doubletok            : printf0('double\n') |
      unsignedtok          : printf0('unsigned\n') |
      consttok             : printf0('const\n') |
      periodperiodperiodtok: printf0('...\n') |
      integertok           : printf0('integer number\n') |
      hexintegertok        : printf0('hexadecimal number\n') |
      octintegertok        : printf0('octal number\n') |
      identtok             : printf0('identifier\n') |
      realtok              : printf0('real number\n') |
      conststringtok       : printf0('constant string\n') |
      constchartok         : printf0('constant char\n') |
      codetok              : printf0('some C code\n') |
      starthashtok         : printf0('start#\n') |
      endhashtok           : printf0('end#\n') |
      definetok            : printf0('define\n') |
      definedtok           : stop ; printf0('defined\n') |
      undeftok             : printf0('undef\n') |
      iftok                : printf0('if\n') |
      elsetok              : printf0('else\n') |
      endiftok             : printf0('endif\n') |
      ifdeftok             : printf0('ifdef\n') |
      ifndeftok            : printf0('ifndef\n') |
      nottok               : printf0('not\n') |
      includetok           : printf0('include\n') |
      commatok             : printf0('comma\n') |
      periodtok            : printf0('period\n') |
      gretok               : printf0('gre\n') |
      lesstok              : printf0('less\n') |
      ortok                : printf0('or\n') |
      andtok               : printf0('and\n') |
      bartok               : printf0('bar\n') |
      ambersandtok         : printf0('ambersand\n') |
      shiftlefttok         : printf0('shiftleft\n') |
      shiftrighttok        : printf0('shiftright\n') |
      divtok               : printf0('div\n') |
      modtok               : printf0('mod\n') |
      sizeoftok            : printf0('sizeof\n') |
      hattok               : printf0('hat\n') |
      equaltok             : printf0('equal\n') |
      notequaltok          : printf0('notequal\n') |
      greequaltok          : printf0('greequal\n') |
      lessequaltok         : printf0('lessequal\n') |
      plustok              : printf0('plus\n') |
      minustok             : printf0('minus\n') |
      tildetok             : printf0('tilde\n') |
      externtok            : printf0('extern\n') |
      statictok            : printf0('static\n') |
      autotok              : printf0('auto\n') |
      registertok          : printf0('register\n') |
      voidtok              : printf0('void\n') |
      shorttok             : printf0('short\n') |
      signedtok            : printf0('signed\n') |
      uniontok             : printf0('union\n') |
      colontok             : printf0('colon\n') |
      becomestok           : printf0('becomes\n') |
      volatiletok          : printf0('volatile\n') |
      typetok              : printf0('type\n')

      ELSE
         cflex.CError(string(InitString('unrecognised token')))
      END
   END
END DisplayToken ;


(*
   GetToken - gets the next token into currenttoken.
*)

PROCEDURE GetToken ;
VAR
   t: CARDINAL ;
   b: TokenBucket ;
   l: CARDINAL ;
BEGIN
   IF UseBufferedTokens
   THEN
      t := CurrentTokNo ;
      b := FindTokenBucket(t) ;
      WITH b^.buf[t] DO
         currenttoken   := token ;
         currentstring  := KeyToCharStar(str) ;
         currentinteger := int ;
         IF Debugging
         THEN
            l := line
         END
      END ;
      IF Debugging
      THEN
         printf3('line %d (# %d  %d) ', l, t, CurrentTokNo) ;
         DisplayToken
      END ;
      INC(CurrentTokNo)
   ELSE
      IF ListOfTokens.tail=NIL
      THEN
         cflex.AdvanceToken ;
         IF ListOfTokens.tail=NIL
         THEN
            HALT
         END
      END ;

      IF ListOfTokens.LastBucketOffset>CurrentTokNo
      THEN
         t := CurrentTokNo ;
         b := FindTokenBucket(t) ;
         WITH b^.buf[t] DO
            currenttoken   := token ;
            currentstring  := KeyToCharStar(str) ;
            currentinteger := int ;
            IF Debugging
            THEN
               l := line
            END
         END ;
         INC(CurrentTokNo)
      ELSE
         WITH ListOfTokens.tail^ DO
            IF CurrentTokNo-ListOfTokens.LastBucketOffset<len
            THEN
               WITH buf[CurrentTokNo-ListOfTokens.LastBucketOffset] DO
                  currenttoken   := token ;
                  currentstring  := KeyToCharStar(str) ;
                  currentinteger := int
               END ;
               IF Debugging
               THEN
                  (* printf1('# %d ', CurrentTokNo) ; *)
                  DisplayToken
               END ;
               INC(CurrentTokNo)
            ELSE
               cflex.AdvanceToken ;
               GetToken ;
               (* printf0('\n'); cflex.CError(string(InitString('current token'))) ; *)
            END
         END
      END
   END
END GetToken ;


(*
   FlushTokens - removes the last token.
*)

PROCEDURE FlushTokens ;
BEGIN
   INC(CurrentTokNo)
END FlushTokens ;


(*
   SyncOpenWithBuffer - synchronise the buffer with the start of a file.
                        Skips all the tokens to do with the previous file.
*)

PROCEDURE SyncOpenWithBuffer ;
BEGIN
   IF ListOfTokens.tail#NIL
   THEN
      WITH ListOfTokens.tail^ DO
         CurrentTokNo := ListOfTokens.LastBucketOffset+len
      END
   END
END SyncOpenWithBuffer ;


(*
   InsertToken - inserts a symbol, token, infront of the current token
                 ready for the next pass.
*)

PROCEDURE InsertToken (token: toktype) ;
BEGIN
   IF ListOfTokens.tail#NIL
   THEN
      WITH ListOfTokens.tail^ DO
         IF len>0
         THEN
            buf[len-1].token := token
         END
      END ;
      AddTokToList(currenttoken, NulName, 0, GetLineNo(), CurrentSource) ;
      GetToken
   END
END InsertToken ;


(*
   InsertTokenAndRewind - inserts a symbol, token, infront of the current token
                          and then moves the token stream back onto the inserted token.
*)

PROCEDURE InsertTokenAndRewind (token: toktype) ;
BEGIN
   IF ListOfTokens.tail#NIL
   THEN
      WITH ListOfTokens.tail^ DO
         IF len>0
         THEN
            buf[len-1].token := token
         END
      END ;
      AddTokToList(currenttoken, NulName, 0, GetLineNo(), CurrentSource) ;
      currenttoken := token
   END
END InsertTokenAndRewind ;


(*
   GetLineNo - returns the current line number where the symbol occurs in
               the source file.
*)

PROCEDURE GetLineNo () : CARDINAL ;
BEGIN
   IF CurrentTokNo=0
   THEN
      RETURN( 0 )
   ELSE
      RETURN( TokenToLineNo(GetTokenNo(), 0) )
   END
END GetLineNo ;


(*
   GetTokenNo - returns the current token number.
*)

PROCEDURE GetTokenNo () : CARDINAL ;
BEGIN
   IF CurrentTokNo=0
   THEN
      RETURN( 0 )
   ELSE
      RETURN( CurrentTokNo-1 )
   END
END GetTokenNo ;


(*
   FindTokenBucket - returns the TokenBucket corresponding to the TokenNo.
*)

PROCEDURE FindTokenBucket (VAR TokenNo: CARDINAL) : TokenBucket ;
VAR
   b: TokenBucket ;
BEGIN
   b := ListOfTokens.head ;
   WHILE b#NIL DO
      WITH b^ DO
         IF TokenNo<len
         THEN
            RETURN( b )
         ELSE
            DEC(TokenNo, len)
         END
      END ;
      b := b^.next
   END ;
   RETURN( NIL )
END FindTokenBucket ;


(*
   TokenToLineNo - returns the line number of the current file for the
                   TokenNo. The depth refers to the include depth.
                   A depth of 0 is the current file, depth of 1 is the file
                   which included the current file. Zero is returned if the
                   depth exceeds the file nesting level.
*)

PROCEDURE TokenToLineNo (TokenNo: CARDINAL; depth: CARDINAL) : CARDINAL ;
VAR
   b: TokenBucket ;
   l: SourceList ;
BEGIN
   b := FindTokenBucket(TokenNo) ;
   IF b=NIL
   THEN
      RETURN( 0 )
   ELSE
      IF depth=0
      THEN
         RETURN( b^.buf[TokenNo].line )
      ELSE
         l := b^.buf[TokenNo].file^.left ;
         WHILE depth>0 DO
            l := l^.left ;
            IF l=b^.buf[TokenNo].file^.left
            THEN
               RETURN( 0 )
            END ;
            DEC(depth)
         END ;
         RETURN( l^.line )
      END
   END
END TokenToLineNo ;


(*
   FindFileNameFromToken - returns the complete FileName for the appropriate
                           source file yields the token number, TokenNo.
                           The, Depth, indicates the include level: 0..n
                           Level 0 is the current. NIL is returned if n+1
                           is requested.
*)

PROCEDURE FindFileNameFromToken (TokenNo: CARDINAL; depth: CARDINAL) : String ;
VAR
   b: TokenBucket ;
   l: SourceList ;
BEGIN
   b := FindTokenBucket(TokenNo) ;
   IF b=NIL
   THEN
      RETURN( NIL )
   ELSE
      l := b^.buf[TokenNo].file^.left ;
      WHILE depth>0 DO
         l := l^.left ;
         IF l=b^.buf[TokenNo].file^.left
         THEN
            RETURN( NIL )
         END ;
         DEC(depth)
      END ;
      RETURN( l^.name )
   END
END FindFileNameFromToken ;


(*
   GetFileName - returns a String defining the current file.
*)

PROCEDURE GetFileName () : String ;
BEGIN
   RETURN( FindFileNameFromToken(GetTokenNo(), 0) )
END GetFileName ;


(*
   AddTokToList - adds a token to a dynamic list.
*)

PROCEDURE AddTokToList (t: toktype; n: Name;
                        i: INTEGER; l: CARDINAL; f: SourceList) ;
BEGIN
   IF ListOfTokens.head=NIL
   THEN
      NEW(ListOfTokens.head) ;
      IF ListOfTokens.head=NIL
      THEN
         (* list error *)
      END ;
      ListOfTokens.tail := ListOfTokens.head ;
      ListOfTokens.tail^.len := 0
   ELSIF ListOfTokens.tail^.len=MaxBucketSize
   THEN
      Assert(ListOfTokens.tail^.next=NIL) ;
      NEW(ListOfTokens.tail^.next) ;
      IF ListOfTokens.tail^.next=NIL
      THEN
         (* list error *)
      ELSE
         ListOfTokens.tail := ListOfTokens.tail^.next ;
         ListOfTokens.tail^.len := 0
      END ;
      INC(ListOfTokens.LastBucketOffset, MaxBucketSize)
   END ;
   WITH ListOfTokens.tail^ DO
      next := NIL ;
      WITH buf[len] DO
         token := t ;
         str   := n ;
         int   := i ;
         line  := l ;
         file  := f
      END ;
      INC(len)
   END
END AddTokToList ;


(*
   IsLastTokenEof - returns TRUE if the last token was an eoftok
*)

PROCEDURE IsLastTokenEof () : BOOLEAN ;
VAR
   b: TokenBucket ;
BEGIN
   IF ListOfTokens.tail#NIL
   THEN
      IF ListOfTokens.tail^.len=0
      THEN
         b := ListOfTokens.head ;
         IF b=ListOfTokens.tail
         THEN
            RETURN( FALSE )
         END ;
         WHILE b^.next#ListOfTokens.tail DO
            b := b^.next
         END ;
      ELSE
         b := ListOfTokens.tail
      END ;
      WITH b^ DO
         RETURN( buf[len-1].token=eoftok )
      END
   END ;
   RETURN( FALSE )
END IsLastTokenEof ;


(* ***********************************************************************
 *
 * These functions allow c.flex to deliver tokens into the buffer
 *
 ************************************************************************* *)

(*
   AddTok - adds a token to the buffer.
*)

PROCEDURE AddTok (t: toktype) ;
BEGIN
   IF NOT ((t=eoftok) AND IsLastTokenEof())
   THEN
      AddTokToList(t, NulName, 0, cflex.GetLineNo(), CurrentSource) ;
      CurrentUsed := TRUE
   END
END AddTok ;


(*
   AddTokCharStar - adds a token to the buffer and an additional string, s.
                    A copy of string, s, is made.
*)

PROCEDURE AddTokCharStar (t: toktype; s: ADDRESS) ;
BEGIN
   IF (t=identtok) AND PushMacroDefinition(makekey(s))
   THEN
      (* do nothing *)
   ELSE
      AddTokToList(t, makekey(s), 0, cflex.GetLineNo(), CurrentSource) ;
      CurrentUsed := TRUE
   END
END AddTokCharStar ;


(*
   AddTokInteger - adds a token and an integer to the buffer.
*)

PROCEDURE AddTokInteger (t: toktype; i: INTEGER) ;
VAR
   s: String ;
   lineno: CARDINAL ;
BEGIN
   lineno := cflex.GetLineNo() ;
   s := Sprintf1(Mark(InitString('%d')), lineno) ;
   AddTokToList(t, makekey(string(s)), i, lineno, CurrentSource) ;
   s := KillString(s) ;
   CurrentUsed := TRUE
END AddTokInteger ;


BEGIN
   Init
END CLexBuf.