2001-05-22 09:32:24 +00:00
|
|
|
/*****************************************************************************/
|
|
|
|
/* */
|
|
|
|
/* scanner.c */
|
|
|
|
/* */
|
|
|
|
/* Source file line info structure */
|
|
|
|
/* */
|
|
|
|
/* */
|
|
|
|
/* */
|
2002-09-23 21:37:01 +00:00
|
|
|
/* (C) 1998-2002 Ullrich von Bassewitz */
|
2001-05-22 09:32:24 +00:00
|
|
|
/* Wacholderweg 14 */
|
|
|
|
/* D-70597 Stuttgart */
|
|
|
|
/* EMail: uz@musoftware.de */
|
|
|
|
/* */
|
|
|
|
/* */
|
|
|
|
/* This software is provided 'as-is', without any expressed or implied */
|
|
|
|
/* warranty. In no event will the authors be held liable for any damages */
|
|
|
|
/* arising from the use of this software. */
|
|
|
|
/* */
|
|
|
|
/* Permission is granted to anyone to use this software for any purpose, */
|
|
|
|
/* including commercial applications, and to alter it and redistribute it */
|
|
|
|
/* freely, subject to the following restrictions: */
|
|
|
|
/* */
|
|
|
|
/* 1. The origin of this software must not be misrepresented; you must not */
|
|
|
|
/* claim that you wrote the original software. If you use this software */
|
|
|
|
/* in a product, an acknowledgment in the product documentation would be */
|
|
|
|
/* appreciated but is not required. */
|
|
|
|
/* 2. Altered source versions must be plainly marked as such, and must not */
|
|
|
|
/* be misrepresented as being the original software. */
|
|
|
|
/* 3. This notice may not be removed or altered from any source */
|
|
|
|
/* distribution. */
|
|
|
|
/* */
|
|
|
|
/*****************************************************************************/
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <ctype.h>
|
2000-09-14 19:26:13 +00:00
|
|
|
|
2000-08-23 06:45:55 +00:00
|
|
|
/* common */
|
2001-01-05 19:24:47 +00:00
|
|
|
#include "chartype.h"
|
2000-08-23 06:45:55 +00:00
|
|
|
#include "tgttrans.h"
|
2000-05-28 13:40:48 +00:00
|
|
|
|
2000-08-23 06:45:55 +00:00
|
|
|
/* cc65 */
|
2000-05-28 13:40:48 +00:00
|
|
|
#include "datatype.h"
|
|
|
|
#include "error.h"
|
|
|
|
#include "function.h"
|
|
|
|
#include "global.h"
|
2002-09-29 21:09:47 +00:00
|
|
|
#include "hexval.h"
|
2000-05-28 13:40:48 +00:00
|
|
|
#include "ident.h"
|
2000-06-14 21:01:37 +00:00
|
|
|
#include "input.h"
|
2000-05-28 13:40:48 +00:00
|
|
|
#include "litpool.h"
|
|
|
|
#include "preproc.h"
|
|
|
|
#include "symtab.h"
|
|
|
|
#include "util.h"
|
|
|
|
#include "scanner.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* data */
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Token CurTok; /* The current token */
|
|
|
|
Token NextTok; /* The next token */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Token types */
|
|
|
|
#define TT_C 0 /* ANSI C token */
|
|
|
|
#define TT_EXT 1 /* cc65 extension */
|
|
|
|
|
|
|
|
/* Token table */
|
2000-06-21 21:02:44 +00:00
|
|
|
static const struct Keyword {
|
2000-05-28 13:40:48 +00:00
|
|
|
char* Key; /* Keyword name */
|
|
|
|
unsigned char Tok; /* The token */
|
|
|
|
unsigned char Type; /* Token type */
|
|
|
|
} Keywords [] = {
|
2002-09-29 21:09:47 +00:00
|
|
|
{ "_Pragma", TOK_PRAGMA, TT_C },
|
2000-08-16 09:10:50 +00:00
|
|
|
{ "__A__", TOK_A, TT_C },
|
2000-06-12 18:31:40 +00:00
|
|
|
{ "__AX__", TOK_AX, TT_C },
|
|
|
|
{ "__EAX__", TOK_EAX, TT_C },
|
2000-08-16 09:10:50 +00:00
|
|
|
{ "__X__", TOK_X, TT_C },
|
|
|
|
{ "__Y__", TOK_Y, TT_C },
|
2000-06-12 18:31:40 +00:00
|
|
|
{ "__asm__", TOK_ASM, TT_C },
|
|
|
|
{ "__attribute__", TOK_ATTRIBUTE, TT_C },
|
2000-08-14 22:18:26 +00:00
|
|
|
{ "__far__", TOK_FAR, TT_C },
|
2000-06-12 18:31:40 +00:00
|
|
|
{ "__fastcall__", TOK_FASTCALL, TT_C },
|
|
|
|
{ "asm", TOK_ASM, TT_EXT },
|
|
|
|
{ "auto", TOK_AUTO, TT_C },
|
|
|
|
{ "break", TOK_BREAK, TT_C },
|
|
|
|
{ "case", TOK_CASE, TT_C },
|
|
|
|
{ "char", TOK_CHAR, TT_C },
|
|
|
|
{ "const", TOK_CONST, TT_C },
|
|
|
|
{ "continue", TOK_CONTINUE, TT_C },
|
|
|
|
{ "default", TOK_DEFAULT, TT_C },
|
|
|
|
{ "do", TOK_DO, TT_C },
|
|
|
|
{ "double", TOK_DOUBLE, TT_C },
|
|
|
|
{ "else", TOK_ELSE, TT_C },
|
|
|
|
{ "enum", TOK_ENUM, TT_C },
|
|
|
|
{ "extern", TOK_EXTERN, TT_C },
|
2000-08-14 22:18:26 +00:00
|
|
|
{ "far", TOK_FAR, TT_EXT },
|
2000-06-12 18:31:40 +00:00
|
|
|
{ "fastcall", TOK_FASTCALL, TT_EXT },
|
|
|
|
{ "float", TOK_FLOAT, TT_C },
|
|
|
|
{ "for", TOK_FOR, TT_C },
|
|
|
|
{ "goto", TOK_GOTO, TT_C },
|
|
|
|
{ "if", TOK_IF, TT_C },
|
|
|
|
{ "int", TOK_INT, TT_C },
|
|
|
|
{ "long", TOK_LONG, TT_C },
|
|
|
|
{ "register", TOK_REGISTER, TT_C },
|
|
|
|
{ "return", TOK_RETURN, TT_C },
|
|
|
|
{ "short", TOK_SHORT, TT_C },
|
|
|
|
{ "signed", TOK_SIGNED, TT_C },
|
|
|
|
{ "sizeof", TOK_SIZEOF, TT_C },
|
|
|
|
{ "static", TOK_STATIC, TT_C },
|
|
|
|
{ "struct", TOK_STRUCT, TT_C },
|
|
|
|
{ "switch", TOK_SWITCH, TT_C },
|
|
|
|
{ "typedef", TOK_TYPEDEF, TT_C },
|
|
|
|
{ "union", TOK_UNION, TT_C },
|
|
|
|
{ "unsigned", TOK_UNSIGNED, TT_C },
|
|
|
|
{ "void", TOK_VOID, TT_C },
|
|
|
|
{ "volatile", TOK_VOLATILE, TT_C },
|
|
|
|
{ "while", TOK_WHILE, TT_C },
|
2000-05-28 13:40:48 +00:00
|
|
|
};
|
|
|
|
#define KEY_COUNT (sizeof (Keywords) / sizeof (Keywords [0]))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Stuff for determining the type of an integer constant */
|
|
|
|
#define IT_INT 0x01
|
|
|
|
#define IT_UINT 0x02
|
|
|
|
#define IT_LONG 0x04
|
|
|
|
#define IT_ULONG 0x08
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
/* code */
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int CmpKey (const void* Key, const void* Elem)
|
|
|
|
/* Compare function for bsearch */
|
|
|
|
{
|
|
|
|
return strcmp ((const char*) Key, ((const struct Keyword*) Elem)->Key);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
static int FindKey (const char* Key)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Find a keyword and return the token. Return IDENT if the token is not a
|
|
|
|
* keyword.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
struct Keyword* K;
|
|
|
|
K = bsearch (Key, Keywords, KEY_COUNT, sizeof (Keywords [0]), CmpKey);
|
|
|
|
if (K && (K->Type != TT_EXT || ANSI == 0)) {
|
|
|
|
return K->Tok;
|
|
|
|
} else {
|
2000-06-12 18:31:40 +00:00
|
|
|
return TOK_IDENT;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-08-14 22:18:26 +00:00
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
static int SkipWhite (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Skip white space in the input stream, reading and preprocessing new lines
|
|
|
|
* if necessary. Return 0 if end of file is reached, return 1 otherwise.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
while (1) {
|
2000-06-21 21:02:44 +00:00
|
|
|
while (CurC == 0) {
|
2000-06-14 08:18:19 +00:00
|
|
|
if (NextLine () == 0) {
|
2000-05-28 13:40:48 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2000-06-21 21:02:44 +00:00
|
|
|
Preprocess ();
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
2001-06-24 16:08:35 +00:00
|
|
|
if (IsSpace (CurC)) {
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
void SymName (char* s)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Get symbol from input stream */
|
|
|
|
{
|
|
|
|
unsigned k = 0;
|
|
|
|
do {
|
2000-06-21 21:02:44 +00:00
|
|
|
if (k != MAX_IDENTLEN) {
|
|
|
|
++k;
|
|
|
|
*s++ = CurC;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2001-01-05 19:24:47 +00:00
|
|
|
} while (IsIdent (CurC) || IsDigit (CurC));
|
2000-05-28 13:40:48 +00:00
|
|
|
*s = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
int IsSym (char *s)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Get symbol from input stream or return 0 if not a symbol. */
|
|
|
|
{
|
2000-06-21 21:02:44 +00:00
|
|
|
if (IsIdent (CurC)) {
|
|
|
|
SymName (s);
|
2000-05-28 13:40:48 +00:00
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2001-05-22 09:32:24 +00:00
|
|
|
static void UnknownChar (char C)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Error message for unknown character */
|
|
|
|
{
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("Invalid input character with code %02X", C & 0xFF);
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar (); /* Skip */
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void SetTok (int tok)
|
2001-05-22 09:32:24 +00:00
|
|
|
/* Set NextTok.Tok and bump line ptr */
|
2000-05-28 13:40:48 +00:00
|
|
|
{
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = tok;
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
static int ParseChar (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Parse a character. Converts \n into EOL, etc. */
|
|
|
|
{
|
|
|
|
int i;
|
2000-06-21 21:02:44 +00:00
|
|
|
unsigned val;
|
|
|
|
int C;
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Check for escape chars */
|
2000-06-21 21:02:44 +00:00
|
|
|
if (CurC == '\\') {
|
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case 'b':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\b';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
2000-06-21 21:02:44 +00:00
|
|
|
case 'f':
|
|
|
|
C = '\f';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case 'r':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\r';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case 'n':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\n';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case 't':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\t';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '\"':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\"';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '\'':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\'';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '\\':
|
2000-06-21 21:02:44 +00:00
|
|
|
C = '\\';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case 'x':
|
|
|
|
case 'X':
|
|
|
|
/* Hex character constant */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2002-09-23 21:37:01 +00:00
|
|
|
val = HexVal (CurC) << 4;
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2002-09-23 21:37:01 +00:00
|
|
|
C = val | HexVal (CurC); /* Do not translate */
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '0':
|
|
|
|
case '1':
|
|
|
|
/* Octal constant */
|
|
|
|
i = 0;
|
2000-06-21 21:02:44 +00:00
|
|
|
C = CurC - '0';
|
|
|
|
while (NextC >= '0' && NextC <= '7' && i++ < 4) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextChar ();
|
2000-06-21 21:02:44 +00:00
|
|
|
C = (C << 3) | (CurC - '0');
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("Illegal character constant");
|
2000-06-21 21:02:44 +00:00
|
|
|
C = ' ';
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
2000-06-21 21:02:44 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
C = CurC;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
/* Skip the character read */
|
|
|
|
NextChar ();
|
|
|
|
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Do correct sign extension */
|
2000-06-21 21:02:44 +00:00
|
|
|
return SignExtendChar (C);
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void CharConst (void)
|
|
|
|
/* Parse a character constant. */
|
|
|
|
{
|
2000-06-21 21:02:44 +00:00
|
|
|
int C;
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Skip the quote */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Get character */
|
2000-06-21 21:02:44 +00:00
|
|
|
C = ParseChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Check for closing quote */
|
2000-06-21 21:02:44 +00:00
|
|
|
if (CurC != '\'') {
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("`\'' expected");
|
2000-06-21 21:02:44 +00:00
|
|
|
} else {
|
|
|
|
/* Skip the quote */
|
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup values and attributes */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_CCONST;
|
2000-08-23 06:45:55 +00:00
|
|
|
|
|
|
|
/* Translate into target charset */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.IVal = SignExtendChar (TgtTranslateChar (C));
|
2000-08-23 06:45:55 +00:00
|
|
|
|
|
|
|
/* Character constants have type int */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Type = type_int;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void StringConst (void)
|
|
|
|
/* Parse a quoted string */
|
|
|
|
{
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.IVal = GetLiteralPoolOffs ();
|
|
|
|
NextTok.Tok = TOK_SCONST;
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Be sure to concatenate strings */
|
2000-06-21 21:02:44 +00:00
|
|
|
while (CurC == '\"') {
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Skip the quote char */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
while (CurC != '\"') {
|
|
|
|
if (CurC == '\0') {
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("Unexpected newline");
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
}
|
2000-06-21 21:02:44 +00:00
|
|
|
AddLiteralChar (ParseChar ());
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip closing quote char if there was one */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Skip white space, read new input */
|
2000-06-21 21:02:44 +00:00
|
|
|
SkipWhite ();
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Terminate the string */
|
|
|
|
AddLiteralChar ('\0');
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-06-12 18:31:40 +00:00
|
|
|
void NextToken (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Get next token from input stream */
|
2002-09-30 18:46:08 +00:00
|
|
|
{
|
2000-05-28 13:40:48 +00:00
|
|
|
ident token;
|
|
|
|
|
2001-06-24 16:08:35 +00:00
|
|
|
/* We have to skip white space here before shifting tokens, since the
|
2001-05-22 09:32:24 +00:00
|
|
|
* tokens and the current line info is invalid at startup and will get
|
|
|
|
* initialized by reading the first time from the file. Remember if
|
|
|
|
* we were at end of input and handle that later.
|
|
|
|
*/
|
|
|
|
int GotEOF = (SkipWhite() == 0);
|
|
|
|
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Current token is the lookahead token */
|
2001-05-22 09:32:24 +00:00
|
|
|
if (CurTok.LI) {
|
|
|
|
ReleaseLineInfo (CurTok.LI);
|
|
|
|
}
|
2000-05-28 13:40:48 +00:00
|
|
|
CurTok = NextTok;
|
|
|
|
|
|
|
|
/* Remember the starting position of the next token */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.LI = UseLineInfo (GetCurLineInfo ());
|
2000-05-28 13:40:48 +00:00
|
|
|
|
2001-05-22 09:32:24 +00:00
|
|
|
/* Now handle end of input. */
|
2001-06-24 16:08:35 +00:00
|
|
|
if (GotEOF) {
|
2000-05-28 13:40:48 +00:00
|
|
|
/* End of file reached */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_CEOF;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine the next token from the lookahead */
|
2001-01-05 19:24:47 +00:00
|
|
|
if (IsDigit (CurC)) {
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* A number */
|
|
|
|
int HaveSuffix; /* True if we have a type suffix */
|
|
|
|
unsigned types; /* Possible types */
|
2002-09-30 18:46:08 +00:00
|
|
|
unsigned Base;
|
|
|
|
unsigned DigitVal;
|
|
|
|
unsigned long k; /* Value */
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
k = 0;
|
2002-09-30 18:46:08 +00:00
|
|
|
Base = 10;
|
2000-05-28 13:40:48 +00:00
|
|
|
types = IT_INT | IT_LONG | IT_ULONG;
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
if (CurC == '0') {
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Octal or hex constants may also be of type unsigned int */
|
|
|
|
types = IT_INT | IT_UINT | IT_LONG | IT_ULONG;
|
|
|
|
/* gobble 0 and examin next char */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (toupper (CurC) == 'X') {
|
2002-09-30 18:46:08 +00:00
|
|
|
Base = 16;
|
|
|
|
NextTok.Type = type_uint;
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar (); /* gobble "x" */
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2002-09-30 18:46:08 +00:00
|
|
|
Base = 8;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
}
|
2002-09-30 18:46:08 +00:00
|
|
|
while (IsXDigit (CurC) && (DigitVal = HexVal (CurC)) < Base) {
|
|
|
|
k = k * Base + DigitVal;
|
|
|
|
NextChar ();
|
|
|
|
}
|
|
|
|
/* Check for errorneous digits */
|
|
|
|
if (Base == 8 && IsDigit (CurC)) {
|
|
|
|
Error ("Numeric constant contains digits beyond the radix");
|
|
|
|
/* Do error recovery */
|
|
|
|
do {
|
|
|
|
NextChar ();
|
|
|
|
} while (IsDigit (CurC));
|
|
|
|
} else if (Base != 16 && IsXDigit (CurC)) {
|
|
|
|
Error ("Nondigits in number and not hexadecimal");
|
|
|
|
do {
|
|
|
|
NextChar ();
|
|
|
|
} while (IsXDigit (CurC));
|
|
|
|
}
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Check for a suffix */
|
|
|
|
HaveSuffix = 1;
|
2000-06-21 21:02:44 +00:00
|
|
|
if (CurC == 'u' || CurC == 'U') {
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Unsigned type */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (toupper (CurC) != 'L') {
|
2000-05-28 13:40:48 +00:00
|
|
|
types = IT_UINT | IT_ULONG;
|
|
|
|
} else {
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
types = IT_ULONG;
|
|
|
|
}
|
2000-06-21 21:02:44 +00:00
|
|
|
} else if (CurC == 'l' || CurC == 'L') {
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Long type */
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (toupper (CurC) != 'U') {
|
2000-05-28 13:40:48 +00:00
|
|
|
types = IT_LONG | IT_ULONG;
|
|
|
|
} else {
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
2000-05-28 13:40:48 +00:00
|
|
|
types = IT_ULONG;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
HaveSuffix = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check the range to determine the type */
|
|
|
|
if (k > 0x7FFF) {
|
|
|
|
/* Out of range for int */
|
|
|
|
types &= ~IT_INT;
|
|
|
|
/* If the value is in the range 0x8000..0xFFFF, unsigned int is not
|
|
|
|
* allowed, and we don't have a type specifying suffix, emit a
|
|
|
|
* warning.
|
|
|
|
*/
|
|
|
|
if (k <= 0xFFFF && (types & IT_UINT) == 0 && !HaveSuffix) {
|
2000-10-15 19:52:01 +00:00
|
|
|
Warning ("Constant is long");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (k > 0xFFFF) {
|
|
|
|
/* Out of range for unsigned int */
|
|
|
|
types &= ~IT_UINT;
|
|
|
|
}
|
|
|
|
if (k > 0x7FFFFFFF) {
|
|
|
|
/* Out of range for long int */
|
|
|
|
types &= ~IT_LONG;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now set the type string to the smallest type in types */
|
|
|
|
if (types & IT_INT) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Type = type_int;
|
2000-05-28 13:40:48 +00:00
|
|
|
} else if (types & IT_UINT) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Type = type_uint;
|
2000-05-28 13:40:48 +00:00
|
|
|
} else if (types & IT_LONG) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Type = type_long;
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Type = type_ulong;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the value and the token */
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.IVal = k;
|
|
|
|
NextTok.Tok = TOK_ICONST;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-06-21 21:02:44 +00:00
|
|
|
if (IsSym (token)) {
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
/* Check for a keyword */
|
2001-05-22 09:32:24 +00:00
|
|
|
if ((NextTok.Tok = FindKey (token)) != TOK_IDENT) {
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Reserved word found */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* No reserved word, check for special symbols */
|
|
|
|
if (token [0] == '_') {
|
|
|
|
/* Special symbols */
|
2002-09-23 21:37:01 +00:00
|
|
|
if (strcmp (token, "__FILE__") == 0) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.IVal = AddLiteral (GetCurrentFile());
|
|
|
|
NextTok.Tok = TOK_SCONST;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
} else if (strcmp (token, "__LINE__") == 0) {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_ICONST;
|
|
|
|
NextTok.IVal = GetCurrentLine();
|
|
|
|
NextTok.Type = type_int;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
} else if (strcmp (token, "__func__") == 0) {
|
|
|
|
/* __func__ is only defined in functions */
|
|
|
|
if (CurrentFunc) {
|
2002-06-12 12:12:04 +00:00
|
|
|
NextTok.IVal = AddLiteral (F_GetFuncName (CurrentFunc));
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_SCONST;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No reserved word but identifier */
|
|
|
|
strcpy (NextTok.Ident, token);
|
2000-06-12 18:31:40 +00:00
|
|
|
NextTok.Tok = TOK_IDENT;
|
2000-05-28 13:40:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Monstrous switch statement ahead... */
|
2000-06-21 21:02:44 +00:00
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
case '!':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_NE);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_BOOL_NOT;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '\"':
|
|
|
|
StringConst ();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '%':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_MOD_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_MOD;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '&':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '&':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_BOOL_AND);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_AND_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_AND;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '\'':
|
|
|
|
CharConst ();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '(':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_LPAREN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ')':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_RPAREN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '*':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_MUL_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_STAR;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '+':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '+':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_INC);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_PLUS_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_PLUS;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ',':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_COMMA);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '-':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '-':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_DEC);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_MINUS_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '>':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_PTR_REF);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_MINUS;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '.':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '.') {
|
|
|
|
NextChar ();
|
|
|
|
if (CurC == '.') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_ELLIPSIS);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
UnknownChar (CurC);
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_DOT;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '/':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_DIV_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_DIV;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ':':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_COLON);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ';':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_SEMI);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '<':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_LE);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '<':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_SHL_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_SHL;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_LT;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '=':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_EQ);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_ASSIGN;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '>':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_GE);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '>':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_SHR_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_SHR;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_GT;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '?':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_QUEST);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '[':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_LBRACK);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ']':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_RBRACK);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '^':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
if (CurC == '=') {
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_XOR_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_XOR;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '{':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_LCURLY);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '|':
|
2000-06-21 21:02:44 +00:00
|
|
|
NextChar ();
|
|
|
|
switch (CurC) {
|
2000-05-28 13:40:48 +00:00
|
|
|
case '|':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_BOOL_OR);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
case '=':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_OR_ASSIGN);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
NextTok.Tok = TOK_OR;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '}':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_RCURLY);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case '~':
|
2000-06-12 18:31:40 +00:00
|
|
|
SetTok (TOK_COMP);
|
2000-05-28 13:40:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2001-05-22 09:32:24 +00:00
|
|
|
UnknownChar (CurC);
|
2000-05-28 13:40:48 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2001-09-09 20:49:20 +00:00
|
|
|
void SkipTokens (const token_t* TokenList, unsigned TokenCount)
|
|
|
|
/* Skip tokens until we reach TOK_CEOF or a token in the given token list.
|
|
|
|
* This routine is used for error recovery.
|
|
|
|
*/
|
2002-06-12 12:12:04 +00:00
|
|
|
{
|
2001-09-09 20:49:20 +00:00
|
|
|
while (CurTok.Tok != TOK_CEOF) {
|
|
|
|
|
|
|
|
/* Check if the current token is in the token list */
|
|
|
|
unsigned I;
|
|
|
|
for (I = 0; I < TokenCount; ++I) {
|
|
|
|
if (CurTok.Tok == TokenList[I]) {
|
|
|
|
/* Found a token in the list */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Not in the list: Skip it */
|
|
|
|
NextToken ();
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int Consume (token_t Token, const char* ErrorMsg)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Eat token if it is the next in the input stream, otherwise print an error
|
2002-09-29 21:09:47 +00:00
|
|
|
* message. Returns true if the token was found and false otherwise.
|
2000-05-28 13:40:48 +00:00
|
|
|
*/
|
|
|
|
{
|
2001-05-22 09:32:24 +00:00
|
|
|
if (CurTok.Tok == Token) {
|
2000-06-12 18:31:40 +00:00
|
|
|
NextToken ();
|
2002-09-29 21:09:47 +00:00
|
|
|
return 1;
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2000-11-02 21:22:33 +00:00
|
|
|
Error (ErrorMsg);
|
2002-09-29 21:09:47 +00:00
|
|
|
return 0;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeColon (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a colon and skip it. */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_COLON, "`:' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeSemi (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a semicolon and skip it. */
|
|
|
|
{
|
|
|
|
/* Try do be smart about typos... */
|
2001-05-22 09:32:24 +00:00
|
|
|
if (CurTok.Tok == TOK_SEMI) {
|
2002-09-29 21:09:47 +00:00
|
|
|
NextToken ();
|
|
|
|
return 1;
|
2000-05-28 13:40:48 +00:00
|
|
|
} else {
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("`;' expected");
|
2001-05-22 09:32:24 +00:00
|
|
|
if (CurTok.Tok == TOK_COLON || CurTok.Tok == TOK_COMMA) {
|
2000-06-12 18:31:40 +00:00
|
|
|
NextToken ();
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
2002-09-29 21:09:47 +00:00
|
|
|
return 0;
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeComma (void)
|
2000-09-14 19:26:13 +00:00
|
|
|
/* Check for a comma and skip it. */
|
|
|
|
{
|
|
|
|
/* Try do be smart about typos... */
|
|
|
|
if (CurTok.Tok == TOK_COMMA) {
|
2002-09-29 21:09:47 +00:00
|
|
|
NextToken ();
|
|
|
|
return 1;
|
2000-09-14 19:26:13 +00:00
|
|
|
} else {
|
2000-11-02 21:22:33 +00:00
|
|
|
Error ("`,' expected");
|
2000-09-14 19:26:13 +00:00
|
|
|
if (CurTok.Tok == TOK_SEMI) {
|
|
|
|
NextToken ();
|
|
|
|
}
|
2002-09-29 21:09:47 +00:00
|
|
|
return 0;
|
2000-09-14 19:26:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeLParen (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a left parenthesis and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_LPAREN, "`(' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeRParen (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a right parenthesis and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_RPAREN, "`)' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeLBrack (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a left bracket and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_LBRACK, "`[' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeRBrack (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a right bracket and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_RBRACK, "`]' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeLCurly (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a left curly brace and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_LCURLY, "`{' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2002-09-29 21:09:47 +00:00
|
|
|
int ConsumeRCurly (void)
|
2000-05-28 13:40:48 +00:00
|
|
|
/* Check for a right curly brace and skip it */
|
|
|
|
{
|
2002-09-29 21:09:47 +00:00
|
|
|
return Consume (TOK_RCURLY, "`}' expected");
|
2000-05-28 13:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|