gcc/m2/gm2-compiler/M2Reserved.mod

   1 (* M2Reserved.mod determines is a token is a reserved word.
   2
   3 Copyright (C) 2001-2023 Free Software Foundation, Inc.
   4 Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>.
   5
   6 This file is part of GNU Modula-2.
   7
   8 GNU Modula-2 is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GNU Modula-2 is distributed in the hope that it will be useful, but
  14 WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Modula-2; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  *)
  21
  22 IMPLEMENTATION MODULE M2Reserved ;
  23
  24
  25 FROM SymbolKey IMPORT SymbolTree, InitTree, PutSymKey, GetSymKey ;
  26 FROM NameKey IMPORT MakeKey, NulName ;
  27 FROM ASCII IMPORT nul ;
  28
  29 CONST
  30    eof = 032C ;
  31
  32 VAR
  33    NameTotok,
  34    tokToName: SymbolTree ;
  35
  36
  37 (*
  38    AddKeyword - adds the Name and enumerated value of a keyword
  39                 into the binary tree.
  40 *)
  41
  42 PROCEDURE AddKeyword (n: Name; tok: toktype) ;
  43 BEGIN
  44    PutSymKey(NameTotok, n, tok) ;
  45    PutSymKey(tokToName, VAL(Name, tok), n)
  46 END AddKeyword ;
  47
  48
  49 PROCEDURE Init ;
  50 VAR
  51    a: ARRAY [0..1] OF CHAR ;
  52 BEGIN
  53    InitTree(NameTotok) ;
  54    InitTree(tokToName) ;
  55
  56    NulTok := NulName ;
  57
  58    PlusTok := MakeKey('+') ;
  59    AddKeyword(PlusTok, plustok) ;
  60
  61    MinusTok := MakeKey('-') ;
  62    AddKeyword(MinusTok, minustok) ;
  63
  64    TimesTok := MakeKey('*') ;
  65    AddKeyword(TimesTok, timestok) ;
  66
  67    DivideTok := MakeKey('/') ;
  68    AddKeyword(DivideTok, dividetok) ;
  69
  70    BecomesTok := MakeKey(':=') ;
  71    AddKeyword(BecomesTok, becomestok) ;
  72
  73    AmbersandTok := MakeKey('&') ;
  74    AddKeyword(AmbersandTok, ambersandtok) ;
  75
  76    PeriodTok := MakeKey('.') ;
  77    AddKeyword(PeriodTok, periodtok) ;
  78
  79    CommaTok := MakeKey(',') ;
  80    AddKeyword(CommaTok, commatok) ;
  81
  82    SemiColonTok := MakeKey(';') ;
  83    AddKeyword(SemiColonTok, semicolontok) ;
  84
  85    LParaTok := MakeKey('(') ;
  86    AddKeyword(LParaTok, lparatok) ;
  87
  88    LSBraTok := MakeKey('[') ;
  89    AddKeyword(LSBraTok, lsbratok) ;
  90
  91    LCBraTok := MakeKey('{') ;
  92    AddKeyword(LCBraTok, lcbratok) ;
  93
  94    UpArrowTok := MakeKey('^') ;
  95    AddKeyword(UpArrowTok, uparrowtok) ;
  96
  97    SingleQuoteTok := MakeKey("'") ;
  98    AddKeyword(SingleQuoteTok, singlequotetok) ;
  99
 100    EqualTok := MakeKey('=') ;
 101    AddKeyword(EqualTok, equaltok) ;
 102
 103    HashTok := MakeKey('#') ;
 104    AddKeyword(HashTok, hashtok) ;
 105
 106    LessTok := MakeKey('<') ;
 107    AddKeyword(LessTok, lesstok) ;
 108
 109    GreaterTok := MakeKey('>') ;
 110    AddKeyword(GreaterTok, greatertok) ;
 111
 112    LessGreaterTok := MakeKey('<>') ;
 113    AddKeyword(LessGreaterTok, lessgreatertok) ;
 114
 115    LessEqualTok := MakeKey('<=') ;
 116    AddKeyword(LessEqualTok, lessequaltok) ;
 117
 118    GreaterEqualTok := MakeKey('>=') ;
 119    AddKeyword(GreaterEqualTok, greaterequaltok) ;
 120
 121    LDirectiveTok := MakeKey('<*') ;
 122    AddKeyword(LDirectiveTok, ldirectivetok) ;
 123
 124    RDirectiveTok := MakeKey('*>') ;
 125    AddKeyword(RDirectiveTok, rdirectivetok) ;
 126
 127    PeriodPeriodTok := MakeKey('..') ;
 128    AddKeyword(PeriodPeriodTok, periodperiodtok) ;
 129
 130    ColonTok := MakeKey(':') ;
 131    AddKeyword(ColonTok, colontok) ;
 132
 133    RParaTok := MakeKey(')') ;
 134    AddKeyword(RParaTok, rparatok) ;
 135
 136    RSBraTok := MakeKey(']') ;
 137    AddKeyword(RSBraTok, rsbratok) ;
 138
 139    RCBraTok := MakeKey('}') ;
 140    AddKeyword(RCBraTok, rcbratok) ;
 141
 142    BarTok := MakeKey('|') ;
 143    AddKeyword(BarTok, bartok) ;
 144
 145    DoubleQuotesTok := MakeKey('"') ;
 146    AddKeyword(DoubleQuotesTok, doublequotestok) ;
 147
 148
 149    AndTok := MakeKey('AND') ;
 150    AddKeyword(AndTok, andtok) ;
 151
 152    ArrayTok := MakeKey('ARRAY') ;
 153    AddKeyword(ArrayTok, arraytok) ;
 154
 155    BeginTok := MakeKey('BEGIN') ;
 156    AddKeyword(BeginTok, begintok) ;
 157
 158    ByTok := MakeKey('BY') ;
 159    AddKeyword(ByTok, bytok) ;
 160
 161    CaseTok := MakeKey('CASE') ;
 162    AddKeyword(CaseTok, casetok) ;
 163
 164    ConstTok := MakeKey('CONST') ;
 165    AddKeyword(ConstTok, consttok) ;
 166
 167    DefinitionTok := MakeKey('DEFINITION') ;
 168    AddKeyword(DefinitionTok, definitiontok) ;
 169
 170    DivTok := MakeKey('DIV') ;
 171    AddKeyword(DivTok, divtok) ;
 172
 173    DoTok := MakeKey('DO') ;
 174    AddKeyword(DoTok, dotok) ;
 175
 176    ElseTok := MakeKey('ELSE') ;
 177    AddKeyword(ElseTok, elsetok) ;
 178
 179    ElsifTok := MakeKey('ELSIF') ;
 180    AddKeyword(ElsifTok, elsiftok) ;
 181
 182    EndTok := MakeKey('END') ;
 183    AddKeyword(EndTok, endtok) ;
 184
 185    ExitTok := MakeKey('EXIT') ;
 186    AddKeyword(ExitTok, exittok) ;
 187
 188    ExceptTok := MakeKey('EXCEPT') ;
 189    AddKeyword(ExceptTok, excepttok) ;
 190
 191    ExportTok := MakeKey('EXPORT') ;
 192    AddKeyword(ExportTok, exporttok) ;
 193
 194    FinallyTok := MakeKey('FINALLY') ;
 195    AddKeyword(FinallyTok, finallytok) ;
 196
 197    ForTok := MakeKey('FOR') ;
 198    AddKeyword(ForTok, fortok) ;
 199
 200    FromTok := MakeKey('FROM') ;
 201    AddKeyword(FromTok, fromtok) ;
 202
 203    IfTok := MakeKey('IF') ;
 204    AddKeyword(IfTok, iftok) ;
 205
 206    ImplementationTok := MakeKey('IMPLEMENTATION') ;
 207    AddKeyword(ImplementationTok, implementationtok) ;
 208
 209    ImportTok := MakeKey('IMPORT') ;
 210    AddKeyword(ImportTok, importtok) ;
 211
 212    InTok := MakeKey('IN') ;
 213    AddKeyword(InTok, intok) ;
 214
 215    LoopTok := MakeKey('LOOP') ;
 216    AddKeyword(LoopTok, looptok) ;
 217
 218    ModTok := MakeKey('MOD') ;
 219    AddKeyword(ModTok, modtok) ;
 220
 221    ModuleTok := MakeKey('MODULE') ;
 222    AddKeyword(ModuleTok, moduletok) ;
 223
 224    NotTok := MakeKey('NOT') ;
 225    AddKeyword(NotTok, nottok) ;
 226
 227    OfTok := MakeKey('OF') ;
 228    AddKeyword(OfTok, oftok) ;
 229
 230    OrTok := MakeKey('OR') ;
 231    AddKeyword(OrTok, ortok) ;
 232 (*
 233    PackedTok := MakeKey('PACKED') ;
 234    AddKeyword(PackedTok, packedtok) ;
 235 *)
 236    PackedSetTok := MakeKey('PACKEDSET') ;
 237    AddKeyword(PackedSetTok, packedsettok) ;
 238
 239    PointerTok := MakeKey('POINTER') ;
 240    AddKeyword(PointerTok, pointertok) ;
 241
 242    ProcedureTok := MakeKey('PROCEDURE') ;
 243    AddKeyword(ProcedureTok, proceduretok) ;
 244
 245    QualifiedTok := MakeKey('QUALIFIED') ;
 246    AddKeyword(QualifiedTok, qualifiedtok) ;
 247
 248    UnQualifiedTok := MakeKey('UNQUALIFIED') ;
 249    AddKeyword(UnQualifiedTok, unqualifiedtok) ;
 250
 251    RecordTok := MakeKey('RECORD') ;
 252    AddKeyword(RecordTok, recordtok) ;
 253
 254    RemTok := MakeKey('REM') ;
 255    AddKeyword(RemTok, remtok) ;
 256
 257    RepeatTok := MakeKey('REPEAT') ;
 258    AddKeyword(RepeatTok, repeattok) ;
 259
 260    RetryTok := MakeKey('RETRY') ;
 261    AddKeyword(RetryTok, retrytok) ;
 262
 263    ReturnTok := MakeKey('RETURN') ;
 264    AddKeyword(ReturnTok, returntok) ;
 265
 266    SetTok := MakeKey('SET') ;
 267    AddKeyword(SetTok, settok) ;
 268
 269    ThenTok := MakeKey('THEN') ;
 270    AddKeyword(ThenTok, thentok) ;
 271
 272    ToTok := MakeKey('TO') ;
 273    AddKeyword(ToTok, totok) ;
 274
 275    TypeTok := MakeKey('TYPE') ;
 276    AddKeyword(TypeTok, typetok) ;
 277
 278    UntilTok := MakeKey('UNTIL') ;
 279    AddKeyword(UntilTok, untiltok) ;
 280
 281    VarTok := MakeKey('VAR') ;
 282    AddKeyword(VarTok, vartok) ;
 283
 284    WhileTok := MakeKey('WHILE') ;
 285    AddKeyword(WhileTok, whiletok) ;
 286
 287    WithTok := MakeKey('WITH') ;
 288    AddKeyword(WithTok, withtok) ;
 289
 290    AsmTok := MakeKey('ASM') ;
 291    AddKeyword(AsmTok, asmtok) ;
 292
 293    VolatileTok := MakeKey('VOLATILE') ;
 294    AddKeyword(VolatileTok, volatiletok) ;
 295
 296    DateTok := MakeKey('__DATE__') ;     (* C compatible preprocessor primatives *)
 297    AddKeyword(DateTok, datetok) ;
 298
 299    LineTok := MakeKey('__LINE__') ;
 300    AddKeyword(LineTok, linetok) ;
 301
 302    FileTok := MakeKey('__FILE__') ;
 303    AddKeyword(FileTok, filetok) ;
 304
 305    AttributeTok := MakeKey('__ATTRIBUTE__') ; (* GCC extension incorporated into gm2 *)
 306    AddKeyword(AttributeTok, attributetok) ;
 307
 308    BuiltinTok := MakeKey('__BUILTIN__') ; (* GCC extension incorporated into gm2 *)
 309    AddKeyword(BuiltinTok, builtintok) ;
 310
 311    InlineTok := MakeKey('__INLINE__') ; (* GCC extension incorporated into gm2 *)
 312    AddKeyword(InlineTok, inlinetok) ;
 313
 314    a[0] := eof ;
 315    a[1] := nul ;
 316    EofTok := MakeKey(a)              (* Not a reserved token *)
 317 END Init ;
 318
 319
 320 (*
 321    IsReserved - returns TRUE if the symbol, Name, is a reserved word.
 322                 If TRUE it also sets tok to the appropriate enumerated
 323                 value. It will set tok to eoftok if appropriate.
 324 *)
 325
 326 PROCEDURE IsReserved (n: Name; VAR tok: toktype) : BOOLEAN ;
 327 VAR
 328    t: CARDINAL ;
 329 BEGIN
 330    t := GetSymKey(NameTotok, n) ;
 331    IF t=0
 332    THEN
 333       (* eoftok is not a reserved word *)
 334       IF n=EofTok
 335       THEN
 336          tok := eoftok
 337       END ;
 338       RETURN( FALSE )
 339    ELSE
 340       tok := VAL(toktype, t) ;
 341       RETURN( TRUE )
 342    END
 343 END IsReserved ;
 344
 345
 346 (*
 347    tokToTok - returns a Tok given the enumerated variable, t.
 348 *)
 349
 350 PROCEDURE tokToTok (t: toktype) : Name ;
 351 BEGIN
 352    RETURN( GetSymKey(tokToName, VAL(Name, t)) )
 353 END tokToTok ;
 354
 355
 356 BEGIN
 357    Init
 358 END M2Reserved.