git.sur5r.net Git - cc65/blob - src/cc65/scanner.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 scanner.c                                 */
   4 /*                                                                           */
   5 /*                      Source file line info structure                      */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2003 Ullrich von Bassewitz                                       */
  10 /*               Römerstrasse 52                                             */
  11 /*               D-70794 Filderstadt                                         */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <errno.h>
  40 #include <ctype.h>
  41
  42 /* common */
  43 #include "chartype.h"
  44 #include "tgttrans.h"
  45
  46 /* cc65 */
  47 #include "datatype.h"
  48 #include "error.h"
  49 #include "function.h"
  50 #include "global.h"
  51 #include "hexval.h"
  52 #include "ident.h"
  53 #include "input.h"
  54 #include "litpool.h"
  55 #include "preproc.h"
  56 #include "symtab.h"
  57 #include "util.h"
  58 #include "scanner.h"
  59
  60
  61
  62 /*****************************************************************************/
  63 /*                                   data                                    */
  64 /*****************************************************************************/
  65
  66
  67
  68 Token CurTok;           /* The current token */
  69 Token NextTok;          /* The next token */
  70
  71
  72
  73 /* Token types */
  74 #define TT_C    0               /* ANSI C token */
  75 #define TT_EXT  1               /* cc65 extension */
  76
  77 /* Token table */
  78 static const struct Keyword {
  79     char*           Key;        /* Keyword name */
  80     unsigned char   Tok;        /* The token */
  81     unsigned char   Type;       /* Token type */
  82 } Keywords [] = {
  83     { "_Pragma",        TOK_PRAGMA,     TT_C    },
  84     { "__A__",          TOK_A,          TT_C    },
  85     { "__AX__",         TOK_AX,         TT_C    },
  86     { "__EAX__",        TOK_EAX,        TT_C    },
  87     { "__X__",          TOK_X,          TT_C    },
  88     { "__Y__",          TOK_Y,          TT_C    },
  89     { "__asm__",        TOK_ASM,        TT_C    },
  90     { "__attribute__",  TOK_ATTRIBUTE,  TT_C    },
  91     { "__far__",        TOK_FAR,        TT_C    },
  92     { "__fastcall__",   TOK_FASTCALL,   TT_C    },
  93     { "asm",            TOK_ASM,        TT_EXT  },
  94     { "auto",           TOK_AUTO,       TT_C    },
  95     { "break",          TOK_BREAK,      TT_C    },
  96     { "case",           TOK_CASE,       TT_C    },
  97     { "char",           TOK_CHAR,       TT_C    },
  98     { "const",          TOK_CONST,      TT_C    },
  99     { "continue",       TOK_CONTINUE,   TT_C    },
 100     { "default",        TOK_DEFAULT,    TT_C    },
 101     { "do",             TOK_DO,         TT_C    },
 102     { "double",         TOK_DOUBLE,     TT_C    },
 103     { "else",           TOK_ELSE,       TT_C    },
 104     { "enum",           TOK_ENUM,       TT_C    },
 105     { "extern",         TOK_EXTERN,     TT_C    },
 106     { "far",            TOK_FAR,        TT_EXT  },
 107     { "fastcall",       TOK_FASTCALL,   TT_EXT  },
 108     { "float",          TOK_FLOAT,      TT_C    },
 109     { "for",            TOK_FOR,        TT_C    },
 110     { "goto",           TOK_GOTO,       TT_C    },
 111     { "if",             TOK_IF,         TT_C    },
 112     { "int",            TOK_INT,        TT_C    },
 113     { "long",           TOK_LONG,       TT_C    },
 114     { "register",       TOK_REGISTER,   TT_C    },
 115     { "restrict",       TOK_RESTRICT,   TT_C    },
 116     { "return",         TOK_RETURN,     TT_C    },
 117     { "short",          TOK_SHORT,      TT_C    },
 118     { "signed",         TOK_SIGNED,     TT_C    },
 119     { "sizeof",         TOK_SIZEOF,     TT_C    },
 120     { "static",         TOK_STATIC,     TT_C    },
 121     { "struct",         TOK_STRUCT,     TT_C    },
 122     { "switch",         TOK_SWITCH,     TT_C    },
 123     { "typedef",        TOK_TYPEDEF,    TT_C    },
 124     { "union",          TOK_UNION,      TT_C    },
 125     { "unsigned",       TOK_UNSIGNED,   TT_C    },
 126     { "void",           TOK_VOID,       TT_C    },
 127     { "volatile",       TOK_VOLATILE,   TT_C    },
 128     { "while",          TOK_WHILE,      TT_C    },
 129 };
 130 #define KEY_COUNT       (sizeof (Keywords) / sizeof (Keywords [0]))
 131
 132
 133
 134 /* Stuff for determining the type of an integer constant */
 135 #define IT_INT          0x01
 136 #define IT_UINT         0x02
 137 #define IT_LONG         0x04
 138 #define IT_ULONG        0x08
 139
 140
 141
 142 /*****************************************************************************/
 143 /*                                   code                                    */
 144 /*****************************************************************************/
 145
 146
 147
 148 static int CmpKey (const void* Key, const void* Elem)
 149 /* Compare function for bsearch */
 150 {
 151     return strcmp ((const char*) Key, ((const struct Keyword*) Elem)->Key);
 152 }
 153
 154
 155
 156 static int FindKey (const char* Key)
 157 /* Find a keyword and return the token. Return IDENT if the token is not a
 158  * keyword.
 159  */
 160 {
 161     struct Keyword* K;
 162     K = bsearch (Key, Keywords, KEY_COUNT, sizeof (Keywords [0]), CmpKey);
 163     if (K && (K->Type != TT_EXT || ANSI == 0)) {
 164         return K->Tok;
 165     } else {
 166         return TOK_IDENT;
 167     }
 168 }
 169
 170
 171
 172 static int SkipWhite (void)
 173 /* Skip white space in the input stream, reading and preprocessing new lines
 174  * if necessary. Return 0 if end of file is reached, return 1 otherwise.
 175  */
 176 {
 177     while (1) {
 178         while (CurC == 0) {
 179             if (NextLine () == 0) {
 180                 return 0;
 181             }
 182             Preprocess ();
 183         }
 184         if (IsSpace (CurC)) {
 185             NextChar ();
 186         } else {
 187             return 1;
 188         }
 189     }
 190 }
 191
 192
 193
 194 void SymName (char* s)
 195 /* Get symbol from input stream */
 196 {
 197     unsigned k = 0;
 198     do {
 199         if (k != MAX_IDENTLEN) {
 200             ++k;
 201             *s++ = CurC;
 202         }
 203         NextChar ();
 204     } while (IsIdent (CurC) || IsDigit (CurC));
 205     *s = '\0';
 206 }
 207
 208
 209
 210 int IsSym (char *s)
 211 /* Get symbol from input stream or return 0 if not a symbol. */
 212 {
 213     if (IsIdent (CurC)) {
 214         SymName (s);
 215         return 1;
 216     } else {
 217         return 0;
 218     }
 219 }
 220
 221
 222
 223 static void UnknownChar (char C)
 224 /* Error message for unknown character */
 225 {
 226     Error ("Invalid input character with code %02X", C & 0xFF);
 227     NextChar ();                        /* Skip */
 228 }
 229
 230
 231
 232 static void SetTok (int tok)
 233 /* Set NextTok.Tok and bump line ptr */
 234 {
 235     NextTok.Tok = tok;
 236     NextChar ();
 237 }
 238
 239
 240
 241 static int ParseChar (void)
 242 /* Parse a character. Converts \n into EOL, etc. */
 243 {
 244     int i;
 245     unsigned val;
 246     int C;
 247
 248     /* Check for escape chars */
 249     if (CurC == '\\') {
 250         NextChar ();
 251         switch (CurC) {
 252             case 'b':
 253                 C = '\b';
 254                 break;
 255             case 'f':
 256                 C = '\f';
 257                 break;
 258             case 'r':
 259                 C = '\r';
 260                 break;
 261             case 'n':
 262                 C = '\n';
 263                 break;
 264             case 't':
 265                 C = '\t';
 266                 break;
 267             case '\"':
 268                 C = '\"';
 269                 break;
 270             case '\'':
 271                 C = '\'';
 272                 break;
 273             case '\\':
 274                 C = '\\';
 275                 break;
 276             case 'x':
 277             case 'X':
 278                 /* Hex character constant */
 279                 NextChar ();
 280                 val = HexVal (CurC) << 4;
 281                 NextChar ();
 282                 C = val | HexVal (CurC);        /* Do not translate */
 283                 break;
 284             case '0':
 285             case '1':
 286                 /* Octal constant */
 287                 i = 0;
 288                 C = CurC - '0';
 289                 while (NextC >= '0' && NextC <= '7' && i++ < 4) {
 290                     NextChar ();
 291                     C = (C << 3) | (CurC - '0');
 292                 }
 293                 break;
 294             default:
 295                 Error ("Illegal character constant");
 296                 C = ' ';
 297                 break;
 298         }
 299     } else {
 300         C = CurC;
 301     }
 302
 303     /* Skip the character read */
 304     NextChar ();
 305
 306     /* Do correct sign extension */
 307     return SignExtendChar (C);
 308 }
 309
 310
 311
 312 static void CharConst (void)
 313 /* Parse a character constant. */
 314 {
 315     int C;
 316
 317     /* Skip the quote */
 318     NextChar ();
 319
 320     /* Get character */
 321     C = ParseChar ();
 322
 323     /* Check for closing quote */
 324     if (CurC != '\'') {
 325         Error ("`\'' expected");
 326     } else {
 327         /* Skip the quote */
 328         NextChar ();
 329     }
 330
 331     /* Setup values and attributes */
 332     NextTok.Tok  = TOK_CCONST;
 333
 334     /* Translate into target charset */
 335     NextTok.IVal = SignExtendChar (TgtTranslateChar (C));
 336
 337     /* Character constants have type int */
 338     NextTok.Type = type_int;
 339 }
 340
 341
 342
 343 static void StringConst (void)
 344 /* Parse a quoted string */
 345 {
 346     NextTok.IVal = GetLiteralPoolOffs ();
 347     NextTok.Tok  = TOK_SCONST;
 348
 349     /* Be sure to concatenate strings */
 350     while (CurC == '\"') {
 351
 352         /* Skip the quote char */
 353         NextChar ();
 354
 355         while (CurC != '\"') {
 356             if (CurC == '\0') {
 357                 Error ("Unexpected newline");
 358                 break;
 359             }
 360             AddLiteralChar (ParseChar ());
 361         }
 362
 363         /* Skip closing quote char if there was one */
 364         NextChar ();
 365
 366         /* Skip white space, read new input */
 367         SkipWhite ();
 368
 369     }
 370
 371     /* Terminate the string */
 372     AddLiteralChar ('\0');
 373 }
 374
 375
 376
 377 void NextToken (void)
 378 /* Get next token from input stream */
 379 {
 380     ident token;
 381
 382     /* We have to skip white space here before shifting tokens, since the
 383      * tokens and the current line info is invalid at startup and will get
 384      * initialized by reading the first time from the file. Remember if
 385      * we were at end of input and handle that later.
 386      */
 387     int GotEOF = (SkipWhite() == 0);
 388
 389     /* Current token is the lookahead token */
 390     if (CurTok.LI) {
 391         ReleaseLineInfo (CurTok.LI);
 392     }
 393     CurTok = NextTok;
 394
 395     /* Remember the starting position of the next token */
 396     NextTok.LI = UseLineInfo (GetCurLineInfo ());
 397
 398     /* Now handle end of input. */
 399     if (GotEOF) {
 400         /* End of file reached */
 401         NextTok.Tok = TOK_CEOF;
 402         return;
 403     }
 404
 405     /* Determine the next token from the lookahead */
 406     if (IsDigit (CurC)) {
 407
 408         /* A number */
 409         int HaveSuffix;         /* True if we have a type suffix */
 410         unsigned types;         /* Possible types */
 411         unsigned Base;
 412         unsigned DigitVal;
 413         unsigned long k;        /* Value */
 414
 415         k     = 0;
 416         Base  = 10;
 417         types = IT_INT | IT_LONG | IT_ULONG;
 418
 419         if (CurC == '0') {
 420             /* Octal or hex constants may also be of type unsigned int */
 421             types = IT_INT | IT_UINT | IT_LONG | IT_ULONG;
 422             /* gobble 0 and examin next char */
 423             NextChar ();
 424             if (toupper (CurC) == 'X') {
 425                 Base = 16;
 426                 NextTok.Type = type_uint;
 427                 NextChar ();    /* gobble "x" */
 428             } else {
 429                 Base = 8;
 430             }
 431         }
 432         while (IsXDigit (CurC) && (DigitVal = HexVal (CurC)) < Base) {
 433             k = k * Base + DigitVal;
 434             NextChar ();
 435         }
 436         /* Check for errorneous digits */
 437         if (Base == 8 && IsDigit (CurC)) {
 438             Error ("Numeric constant contains digits beyond the radix");
 439             /* Do error recovery */
 440             do {
 441                 NextChar ();
 442             } while (IsDigit (CurC));
 443         } else if (Base != 16 && IsXDigit (CurC)) {
 444             Error ("Nondigits in number and not hexadecimal");
 445             do {
 446                 NextChar ();
 447             } while (IsXDigit (CurC));
 448         }
 449
 450         /* Check for a suffix */
 451         HaveSuffix = 1;
 452         if (CurC == 'u' || CurC == 'U') {
 453             /* Unsigned type */
 454             NextChar ();
 455             if (toupper (CurC) != 'L') {
 456                 types = IT_UINT | IT_ULONG;
 457             } else {
 458                 NextChar ();
 459                 types = IT_ULONG;
 460             }
 461         } else if (CurC == 'l' || CurC == 'L') {
 462             /* Long type */
 463             NextChar ();
 464             if (toupper (CurC) != 'U') {
 465                 types = IT_LONG | IT_ULONG;
 466             } else {
 467                 NextChar ();
 468                 types = IT_ULONG;
 469             }
 470         } else {
 471             HaveSuffix = 0;
 472         }
 473
 474         /* Check the range to determine the type */
 475         if (k > 0x7FFF) {
 476             /* Out of range for int */
 477             types &= ~IT_INT;
 478             /* If the value is in the range 0x8000..0xFFFF, unsigned int is not
 479              * allowed, and we don't have a type specifying suffix, emit a
 480              * warning.
 481              */
 482             if (k <= 0xFFFF && (types & IT_UINT) == 0 && !HaveSuffix) {
 483                 Warning ("Constant is long");
 484             }
 485         }
 486         if (k > 0xFFFF) {
 487             /* Out of range for unsigned int */
 488             types &= ~IT_UINT;
 489         }
 490         if (k > 0x7FFFFFFF) {
 491             /* Out of range for long int */
 492             types &= ~IT_LONG;
 493         }
 494
 495         /* Now set the type string to the smallest type in types */
 496         if (types & IT_INT) {
 497             NextTok.Type = type_int;
 498         } else if (types & IT_UINT) {
 499             NextTok.Type = type_uint;
 500         } else if (types & IT_LONG) {
 501             NextTok.Type = type_long;
 502         } else {
 503             NextTok.Type = type_ulong;
 504         }
 505
 506         /* Set the value and the token */
 507         NextTok.IVal = k;
 508         NextTok.Tok  = TOK_ICONST;
 509         return;
 510     }
 511
 512     if (IsSym (token)) {
 513
 514         /* Check for a keyword */
 515         if ((NextTok.Tok = FindKey (token)) != TOK_IDENT) {
 516             /* Reserved word found */
 517             return;
 518         }
 519         /* No reserved word, check for special symbols */
 520         if (token [0] == '_') {
 521             /* Special symbols */
 522             if (strcmp (token, "__FILE__") == 0) {
 523                 NextTok.IVal = AddLiteral (GetCurrentFile());
 524                 NextTok.Tok  = TOK_SCONST;
 525                 return;
 526             } else if (strcmp (token, "__LINE__") == 0) {
 527                 NextTok.Tok  = TOK_ICONST;
 528                 NextTok.IVal = GetCurrentLine();
 529                 NextTok.Type = type_int;
 530                 return;
 531             } else if (strcmp (token, "__func__") == 0) {
 532                 /* __func__ is only defined in functions */
 533                 if (CurrentFunc) {
 534                     NextTok.IVal = AddLiteral (F_GetFuncName (CurrentFunc));
 535                     NextTok.Tok  = TOK_SCONST;
 536                     return;
 537                 }
 538             }
 539         }
 540
 541         /* No reserved word but identifier */
 542         strcpy (NextTok.Ident, token);
 543         NextTok.Tok = TOK_IDENT;
 544         return;
 545     }
 546
 547     /* Monstrous switch statement ahead... */
 548     switch (CurC) {
 549
 550         case '!':
 551             NextChar ();
 552             if (CurC == '=') {
 553                 SetTok (TOK_NE);
 554             } else {
 555                 NextTok.Tok = TOK_BOOL_NOT;
 556             }
 557             break;
 558
 559         case '\"':
 560             StringConst ();
 561             break;
 562
 563         case '%':
 564             NextChar ();
 565             if (CurC == '=') {
 566                 SetTok (TOK_MOD_ASSIGN);
 567             } else {
 568                 NextTok.Tok = TOK_MOD;
 569             }
 570             break;
 571
 572         case '&':
 573             NextChar ();
 574             switch (CurC) {
 575                 case '&':
 576                     SetTok (TOK_BOOL_AND);
 577                     break;
 578                 case '=':
 579                     SetTok (TOK_AND_ASSIGN);
 580                     break;
 581                 default:
 582                     NextTok.Tok = TOK_AND;
 583             }
 584             break;
 585
 586         case '\'':
 587             CharConst ();
 588             break;
 589
 590         case '(':
 591             SetTok (TOK_LPAREN);
 592             break;
 593
 594         case ')':
 595             SetTok (TOK_RPAREN);
 596             break;
 597
 598         case '*':
 599             NextChar ();
 600             if (CurC == '=') {
 601                 SetTok (TOK_MUL_ASSIGN);
 602             } else {
 603                 NextTok.Tok = TOK_STAR;
 604             }
 605             break;
 606
 607         case '+':
 608             NextChar ();
 609             switch (CurC) {
 610                 case '+':
 611                     SetTok (TOK_INC);
 612                     break;
 613                 case '=':
 614                     SetTok (TOK_PLUS_ASSIGN);
 615                     break;
 616                 default:
 617                     NextTok.Tok = TOK_PLUS;
 618             }
 619             break;
 620
 621         case ',':
 622             SetTok (TOK_COMMA);
 623             break;
 624
 625         case '-':
 626             NextChar ();
 627             switch (CurC) {
 628                 case '-':
 629                     SetTok (TOK_DEC);
 630                     break;
 631                 case '=':
 632                     SetTok (TOK_MINUS_ASSIGN);
 633                     break;
 634                 case '>':
 635                     SetTok (TOK_PTR_REF);
 636                     break;
 637                 default:
 638                     NextTok.Tok = TOK_MINUS;
 639             }
 640             break;
 641
 642         case '.':
 643             NextChar ();
 644             if (CurC == '.') {
 645                 NextChar ();
 646                 if (CurC == '.') {
 647                     SetTok (TOK_ELLIPSIS);
 648                 } else {
 649                     UnknownChar (CurC);
 650                 }
 651             } else {
 652                 NextTok.Tok = TOK_DOT;
 653             }
 654             break;
 655
 656         case '/':
 657             NextChar ();
 658             if (CurC == '=') {
 659                 SetTok (TOK_DIV_ASSIGN);
 660             } else {
 661                 NextTok.Tok = TOK_DIV;
 662             }
 663             break;
 664
 665         case ':':
 666             SetTok (TOK_COLON);
 667             break;
 668
 669         case ';':
 670             SetTok (TOK_SEMI);
 671             break;
 672
 673         case '<':
 674             NextChar ();
 675             switch (CurC) {
 676                 case '=':
 677                     SetTok (TOK_LE);
 678                     break;
 679                 case '<':
 680                     NextChar ();
 681                     if (CurC == '=') {
 682                         SetTok (TOK_SHL_ASSIGN);
 683                     } else {
 684                         NextTok.Tok = TOK_SHL;
 685                     }
 686                     break;
 687                 default:
 688                     NextTok.Tok = TOK_LT;
 689             }
 690             break;
 691
 692         case '=':
 693             NextChar ();
 694             if (CurC == '=') {
 695                 SetTok (TOK_EQ);
 696             } else {
 697                 NextTok.Tok = TOK_ASSIGN;
 698             }
 699             break;
 700
 701         case '>':
 702             NextChar ();
 703             switch (CurC) {
 704                 case '=':
 705                     SetTok (TOK_GE);
 706                     break;
 707                 case '>':
 708                     NextChar ();
 709                     if (CurC == '=') {
 710                         SetTok (TOK_SHR_ASSIGN);
 711                     } else {
 712                         NextTok.Tok = TOK_SHR;
 713                     }
 714                     break;
 715                 default:
 716                     NextTok.Tok = TOK_GT;
 717             }
 718             break;
 719
 720         case '?':
 721             SetTok (TOK_QUEST);
 722             break;
 723
 724         case '[':
 725             SetTok (TOK_LBRACK);
 726             break;
 727
 728         case ']':
 729             SetTok (TOK_RBRACK);
 730             break;
 731
 732         case '^':
 733             NextChar ();
 734             if (CurC == '=') {
 735                 SetTok (TOK_XOR_ASSIGN);
 736             } else {
 737                 NextTok.Tok = TOK_XOR;
 738             }
 739             break;
 740
 741         case '{':
 742             SetTok (TOK_LCURLY);
 743             break;
 744
 745         case '|':
 746             NextChar ();
 747             switch (CurC) {
 748                 case '|':
 749                     SetTok (TOK_BOOL_OR);
 750                     break;
 751                 case '=':
 752                     SetTok (TOK_OR_ASSIGN);
 753                     break;
 754                 default:
 755                     NextTok.Tok = TOK_OR;
 756             }
 757             break;
 758
 759         case '}':
 760             SetTok (TOK_RCURLY);
 761             break;
 762
 763         case '~':
 764             SetTok (TOK_COMP);
 765             break;
 766
 767         default:
 768             UnknownChar (CurC);
 769
 770     }
 771
 772 }
 773
 774
 775
 776 void SkipTokens (const token_t* TokenList, unsigned TokenCount)
 777 /* Skip tokens until we reach TOK_CEOF or a token in the given token list.
 778  * This routine is used for error recovery.
 779  */
 780 {
 781     while (CurTok.Tok != TOK_CEOF) {
 782
 783         /* Check if the current token is in the token list */
 784         unsigned I;
 785         for (I = 0; I < TokenCount; ++I) {
 786             if (CurTok.Tok == TokenList[I]) {
 787                 /* Found a token in the list */
 788                 return;
 789             }
 790         }
 791
 792         /* Not in the list: Skip it */
 793         NextToken ();
 794
 795     }
 796 }
 797
 798
 799
 800 int Consume (token_t Token, const char* ErrorMsg)
 801 /* Eat token if it is the next in the input stream, otherwise print an error
 802  * message. Returns true if the token was found and false otherwise.
 803  */
 804 {
 805     if (CurTok.Tok == Token) {
 806         NextToken ();
 807         return 1;
 808     } else {
 809         Error (ErrorMsg);
 810         return 0;
 811     }
 812 }
 813
 814
 815
 816 int ConsumeColon (void)
 817 /* Check for a colon and skip it. */
 818 {
 819     return Consume (TOK_COLON, "`:' expected");
 820 }
 821
 822
 823
 824 int ConsumeSemi (void)
 825 /* Check for a semicolon and skip it. */
 826 {
 827     /* Try do be smart about typos... */
 828     if (CurTok.Tok == TOK_SEMI) {
 829         NextToken ();
 830         return 1;
 831     } else {
 832         Error ("`;' expected");
 833         if (CurTok.Tok == TOK_COLON || CurTok.Tok == TOK_COMMA) {
 834             NextToken ();
 835         }
 836         return 0;
 837     }
 838 }
 839
 840
 841
 842 int ConsumeComma (void)
 843 /* Check for a comma and skip it. */
 844 {
 845     /* Try do be smart about typos... */
 846     if (CurTok.Tok == TOK_COMMA) {
 847         NextToken ();
 848         return 1;
 849     } else {
 850         Error ("`,' expected");
 851         if (CurTok.Tok == TOK_SEMI) {
 852             NextToken ();
 853         }
 854         return 0;
 855     }
 856 }
 857
 858
 859
 860 int ConsumeLParen (void)
 861 /* Check for a left parenthesis and skip it */
 862 {
 863     return Consume (TOK_LPAREN, "`(' expected");
 864 }
 865
 866
 867
 868 int ConsumeRParen (void)
 869 /* Check for a right parenthesis and skip it */
 870 {
 871     return Consume (TOK_RPAREN, "`)' expected");
 872 }
 873
 874
 875
 876 int ConsumeLBrack (void)
 877 /* Check for a left bracket and skip it */
 878 {
 879     return Consume (TOK_LBRACK, "`[' expected");
 880 }
 881
 882
 883
 884 int ConsumeRBrack (void)
 885 /* Check for a right bracket and skip it */
 886 {
 887     return Consume (TOK_RBRACK, "`]' expected");
 888 }
 889
 890
 891
 892 int ConsumeLCurly (void)
 893 /* Check for a left curly brace and skip it */
 894 {
 895     return Consume (TOK_LCURLY, "`{' expected");
 896 }
 897
 898
 899
 900 int ConsumeRCurly (void)
 901 /* Check for a right curly brace and skip it */
 902 {
 903     return Consume (TOK_RCURLY, "`}' expected");
 904 }
 905
 906
 907