mirror of https://github.com/cc65/cc65.git
341 lines
9.4 KiB
C
341 lines
9.4 KiB
C
/*****************************************************************************/
|
|
/* */
|
|
/* scanner.h */
|
|
/* */
|
|
/* Source file line info structure */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* (C) 1998-2010, Ullrich von Bassewitz */
|
|
/* Roemerstrasse 52 */
|
|
/* D-70794 Filderstadt */
|
|
/* EMail: uz@cc65.org */
|
|
/* */
|
|
/* */
|
|
/* 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. */
|
|
/* */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
#ifndef SCANNER_H
|
|
#define SCANNER_H
|
|
|
|
|
|
|
|
/* common */
|
|
#include "fp.h"
|
|
|
|
/* cc65 */
|
|
#include "datatype.h"
|
|
#include "ident.h"
|
|
#include "lineinfo.h"
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Token definitions */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
typedef enum token_t {
|
|
TOK_INVALID,
|
|
TOK_CEOF,
|
|
|
|
/* Storage specifiers */
|
|
TOK_FIRST_STORAGE_CLASS,
|
|
TOK_AUTO = TOK_FIRST_STORAGE_CLASS,
|
|
TOK_EXTERN,
|
|
TOK_REGISTER,
|
|
TOK_STATIC,
|
|
TOK_TYPEDEF,
|
|
TOK_LAST_STORAGE_CLASS = TOK_TYPEDEF,
|
|
|
|
/* Tokens denoting type qualifiers */
|
|
TOK_FIRST_TYPEQUAL,
|
|
TOK_CONST = TOK_FIRST_TYPEQUAL,
|
|
TOK_VOLATILE,
|
|
TOK_RESTRICT,
|
|
TOK_LAST_TYPEQUAL = TOK_RESTRICT,
|
|
|
|
/* Function specifiers */
|
|
TOK_INLINE,
|
|
TOK_FASTCALL,
|
|
TOK_CDECL,
|
|
|
|
/* Address sizes */
|
|
TOK_FAR,
|
|
TOK_NEAR,
|
|
|
|
/* Tokens denoting types */
|
|
TOK_FIRST_TYPE,
|
|
TOK_ENUM = TOK_FIRST_TYPE,
|
|
TOK_CHAR,
|
|
TOK_INT,
|
|
TOK_DOUBLE,
|
|
TOK_FLOAT,
|
|
TOK_LONG,
|
|
TOK_UNSIGNED,
|
|
TOK_SIGNED,
|
|
TOK_SHORT,
|
|
TOK_STRUCT,
|
|
TOK_UNION,
|
|
TOK_VOID,
|
|
TOK_LAST_TYPE = TOK_VOID,
|
|
|
|
/* Selection statements */
|
|
TOK_IF,
|
|
TOK_ELSE,
|
|
TOK_SWITCH,
|
|
|
|
/* Iteration statements */
|
|
TOK_WHILE,
|
|
TOK_DO,
|
|
TOK_FOR,
|
|
|
|
/* Jump statements */
|
|
TOK_GOTO,
|
|
TOK_CONTINUE,
|
|
TOK_BREAK,
|
|
TOK_RETURN,
|
|
|
|
/* Labels */
|
|
TOK_CASE,
|
|
TOK_DEFAULT,
|
|
|
|
/* Misc. */
|
|
TOK_ATTRIBUTE,
|
|
TOK_PRAGMA,
|
|
TOK_STATIC_ASSERT,
|
|
TOK_ASM,
|
|
TOK_SIZEOF,
|
|
|
|
/* Punctuators */
|
|
TOK_FIRST_PUNC,
|
|
TOK_LBRACK = TOK_FIRST_PUNC,
|
|
TOK_RBRACK,
|
|
TOK_LPAREN,
|
|
TOK_RPAREN,
|
|
TOK_LCURLY,
|
|
TOK_RCURLY,
|
|
TOK_DOT,
|
|
TOK_PTR_REF,
|
|
TOK_INC,
|
|
TOK_DEC,
|
|
TOK_ADDR,
|
|
TOK_AND = TOK_ADDR, /* Alias */
|
|
TOK_STAR,
|
|
TOK_MUL = TOK_STAR, /* Alias */
|
|
TOK_PLUS,
|
|
TOK_MINUS,
|
|
TOK_COMP,
|
|
TOK_BOOL_NOT,
|
|
TOK_DIV,
|
|
TOK_MOD,
|
|
TOK_SHL,
|
|
TOK_SHR,
|
|
TOK_LT,
|
|
TOK_GT,
|
|
TOK_LE,
|
|
TOK_GE,
|
|
TOK_EQ,
|
|
TOK_NE,
|
|
TOK_XOR,
|
|
TOK_OR,
|
|
TOK_BOOL_AND,
|
|
TOK_BOOL_OR,
|
|
TOK_QUEST,
|
|
TOK_COLON,
|
|
TOK_SEMI,
|
|
TOK_ELLIPSIS,
|
|
TOK_ASSIGN,
|
|
TOK_MUL_ASSIGN,
|
|
TOK_DIV_ASSIGN,
|
|
TOK_MOD_ASSIGN,
|
|
TOK_PLUS_ASSIGN,
|
|
TOK_MINUS_ASSIGN,
|
|
TOK_SHL_ASSIGN,
|
|
TOK_SHR_ASSIGN,
|
|
TOK_AND_ASSIGN,
|
|
TOK_XOR_ASSIGN,
|
|
TOK_OR_ASSIGN,
|
|
TOK_COMMA,
|
|
TOK_HASH,
|
|
TOK_HASH_HASH,
|
|
TOK_DOUBLE_HASH = TOK_HASH_HASH, /* Alias */
|
|
TOK_LAST_PUNC = TOK_DOUBLE_HASH,
|
|
|
|
/* Primary expressions */
|
|
TOK_ICONST,
|
|
TOK_CCONST,
|
|
TOK_WCCONST,
|
|
TOK_FCONST,
|
|
TOK_SCONST,
|
|
TOK_WCSCONST,
|
|
TOK_IDENT,
|
|
TOK_A,
|
|
TOK_X,
|
|
TOK_Y,
|
|
TOK_AX,
|
|
TOK_EAX
|
|
} token_t;
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Data */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
/* Forward for struct Literal */
|
|
struct Literal;
|
|
|
|
/* Token stuff */
|
|
typedef struct Token Token;
|
|
struct Token {
|
|
token_t Tok; /* The token itself */
|
|
long IVal; /* The integer attribute */
|
|
Double FVal; /* The float attribute */
|
|
struct Literal* SVal; /* String literal is any */
|
|
ident Ident; /* Identifier if IDENT */
|
|
LineInfo* LI; /* Source line where the token comes from */
|
|
const Type* Type; /* Type if integer or float constant */
|
|
};
|
|
|
|
extern Token CurTok; /* The current token */
|
|
extern Token NextTok; /* The next token */
|
|
extern int PPParserRunning; /* Is tokenizer used by the preprocessor */
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Code */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE int TokIsPunc (const Token* T)
|
|
/* Return true if the token is a punctuator */
|
|
{
|
|
return (T->Tok >= TOK_FIRST_PUNC && T->Tok <= TOK_LAST_PUNC);
|
|
}
|
|
#else
|
|
# define TokIsPunc(T) \
|
|
((T)->Tok >= TOK_FIRST_PUNC && (T)->Tok <= TOK_LAST_PUNC)
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE int TokIsStorageClass (const Token* T)
|
|
/* Return true if the token is a storage class specifier */
|
|
{
|
|
return (T->Tok >= TOK_FIRST_STORAGE_CLASS && T->Tok <= TOK_LAST_STORAGE_CLASS);
|
|
}
|
|
#else
|
|
# define TokIsStorageClass(T) \
|
|
((T)->Tok >= TOK_FIRST_STORAGE_CLASS && (T)->Tok <= TOK_LAST_STORAGE_CLASS)
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE int TokIsType (const Token* T)
|
|
/* Return true if the token is a type */
|
|
{
|
|
return (T->Tok >= TOK_FIRST_TYPE && T->Tok <= TOK_LAST_TYPE);
|
|
}
|
|
#else
|
|
# define TokIsType(T) ((T)->Tok >= TOK_FIRST_TYPE && (T)->Tok <= TOK_LAST_TYPE)
|
|
#endif
|
|
|
|
#if defined(HAVE_INLINE)
|
|
INLINE int TokIsTypeQual (const Token* T)
|
|
/* Return true if the token is a type qualifier */
|
|
{
|
|
return (T->Tok >= TOK_FIRST_TYPEQUAL && T->Tok <= TOK_LAST_TYPEQUAL);
|
|
}
|
|
#else
|
|
# define TokIsTypeQual(T) ((T)->Tok >= TOK_FIRST_TYPEQUAL && (T)->Tok <= TOK_LAST_TYPEQUAL)
|
|
#endif
|
|
|
|
int TokIsFuncSpec (const Token* T);
|
|
/* Return true if the token is a function specifier */
|
|
|
|
void SymName (char* S);
|
|
/* Read a symbol from the input stream. The first character must have been
|
|
** checked before calling this function. The buffer is expected to be at
|
|
** least of size MAX_IDENTLEN+1.
|
|
*/
|
|
|
|
int IsSym (char* S);
|
|
/* If a symbol follows, read it and return 1, otherwise return 0 */
|
|
|
|
int IsPPNumber (int Cur, int Next);
|
|
/* Return 1 if the two successive characters indicate a pp-number, otherwise
|
|
** return 0.
|
|
*/
|
|
|
|
void CopyPPNumber (StrBuf* Target);
|
|
/* Copy a pp-number from the input to Target */
|
|
|
|
void NextToken (void);
|
|
/* Get next token from input stream */
|
|
|
|
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.
|
|
*/
|
|
|
|
int Consume (token_t Token, const char* ErrorMsg);
|
|
/* Eat token if it is the next in the input stream, otherwise print an error
|
|
** message. Returns true if the token was found and false otherwise.
|
|
*/
|
|
|
|
int ConsumeColon (void);
|
|
/* Check for a colon and skip it. */
|
|
|
|
int ConsumeSemi (void);
|
|
/* Check for a semicolon and skip it. */
|
|
|
|
int ConsumeComma (void);
|
|
/* Check for a comma and skip it. */
|
|
|
|
int ConsumeLParen (void);
|
|
/* Check for a left parenthesis and skip it */
|
|
|
|
int ConsumeRParen (void);
|
|
/* Check for a right parenthesis and skip it */
|
|
|
|
int ConsumeLBrack (void);
|
|
/* Check for a left bracket and skip it */
|
|
|
|
int ConsumeRBrack (void);
|
|
/* Check for a right bracket and skip it */
|
|
|
|
int ConsumeLCurly (void);
|
|
/* Check for a left curly brace and skip it */
|
|
|
|
int ConsumeRCurly (void);
|
|
/* Check for a right curly brace and skip it */
|
|
|
|
|
|
|
|
/* End of scanner.h */
|
|
|
|
#endif
|