286 lines
11 KiB
C
286 lines
11 KiB
C
|
// Copyright (C) 2007 Id Software, Inc.
|
||
|
|
//
|
||
|
|
|
||
|
|
#ifndef __PARSER_H__
|
||
|
|
#define __PARSER_H__
|
||
|
|
|
||
|
|
/*
|
||
|
|
===============================================================================
|
||
|
|
|
||
|
|
C/C++ compatible pre-compiler
|
||
|
|
|
||
|
|
===============================================================================
|
||
|
|
*/
|
||
|
|
|
||
|
|
#define DEFINE_FIXED 0x0001
|
||
|
|
|
||
|
|
#define BUILTIN_LINE 1
|
||
|
|
#define BUILTIN_FILE 2
|
||
|
|
#define BUILTIN_DATE 3
|
||
|
|
#define BUILTIN_TIME 4
|
||
|
|
#define BUILTIN_STDC 5
|
||
|
|
|
||
|
|
#define INDENT_IF 0x0001
|
||
|
|
#define INDENT_ELSE 0x0002
|
||
|
|
#define INDENT_ELIF 0x0004
|
||
|
|
#define INDENT_IFDEF 0x0008
|
||
|
|
#define INDENT_IFNDEF 0x0010
|
||
|
|
|
||
|
|
// macro definitions
|
||
|
|
struct define_t {
|
||
|
|
char * name; // define name
|
||
|
|
int flags; // define flags
|
||
|
|
int builtin; // > 0 if builtin define
|
||
|
|
int numparms; // number of define parameters
|
||
|
|
idToken * parms; // define parameters
|
||
|
|
idToken * tokens; // macro tokens (possibly containing parm tokens)
|
||
|
|
define_t * next; // next defined macro in a list
|
||
|
|
define_t * hashnext; // next define in the hash chain
|
||
|
|
};
|
||
|
|
|
||
|
|
// indents used for conditional compilation directives:
|
||
|
|
// #if, #else, #elif, #ifdef, #ifndef
|
||
|
|
struct indent_t {
|
||
|
|
int type; // indent type
|
||
|
|
int skip; // true if skipping current indent
|
||
|
|
int skipElse; // true if any following else sections should be skipped
|
||
|
|
idLexer * script; // script the indent was in
|
||
|
|
indent_t * next; // next indent on the indent stack
|
||
|
|
};
|
||
|
|
|
||
|
|
typedef void (*pragmaFunc_t)( void *data, const char *pragma );
|
||
|
|
|
||
|
|
class idParser {
|
||
|
|
|
||
|
|
public:
|
||
|
|
// constructor
|
||
|
|
idParser();
|
||
|
|
idParser( int flags );
|
||
|
|
idParser( const char *filename, int flags = 0, bool OSPath = false );
|
||
|
|
idParser( const char *ptr, int length, const char *name, int flags = 0 );
|
||
|
|
// destructor
|
||
|
|
~idParser();
|
||
|
|
// load a source file
|
||
|
|
int LoadFile( const char *filename, bool OSPath = false, int startLine = 1 );
|
||
|
|
// load a source from the given memory with the given length
|
||
|
|
// NOTE: the ptr is expected to point at a valid C string: ptr[length] == '\0'
|
||
|
|
int LoadMemory( const char *ptr, int length, const char *name, int startLine = 1 );
|
||
|
|
int LoadMemoryBinary( const byte *ptr, int length, const char *name, idTokenCache* globals );
|
||
|
|
|
||
|
|
void WriteBinary( idFile* f, idTokenCache* tokenCache = NULL );
|
||
|
|
|
||
|
|
void ResetBinaryParsing();
|
||
|
|
|
||
|
|
// free the current source
|
||
|
|
void FreeSource( bool keepDefines = false );
|
||
|
|
// returns true if a source is loaded
|
||
|
|
int IsLoaded( void ) const { return idParser::loaded; }
|
||
|
|
// read a token from the source
|
||
|
|
int ReadToken( idToken *token );
|
||
|
|
// expect a certain token, reads the token when available
|
||
|
|
bool ExpectTokenString( const char *string, idToken* other = NULL );
|
||
|
|
// expect a certain token type
|
||
|
|
int ExpectTokenType( int type, int subtype, idToken *token );
|
||
|
|
// expect a token
|
||
|
|
int ExpectAnyToken( idToken *token );
|
||
|
|
// returns true if the next token equals the given string and removes the token from the source
|
||
|
|
int CheckTokenString( const char *string );
|
||
|
|
// returns true if the next token equals the given type and removes the token from the source
|
||
|
|
int CheckTokenType( int type, int subtype, idToken *token );
|
||
|
|
// returns true if the next token equals the given string but does not remove the token from the source
|
||
|
|
int PeekTokenString( const char *string );
|
||
|
|
// returns true if the next token equals the given type but does not remove the token from the source
|
||
|
|
int PeekTokenType( int type, int subtype, idToken *token );
|
||
|
|
// skip tokens until the given token string is read
|
||
|
|
int SkipUntilString( const char *string, idToken *token );
|
||
|
|
// skip the rest of the current line
|
||
|
|
int SkipRestOfLine( void );
|
||
|
|
// skip the braced section
|
||
|
|
int SkipBracedSection( bool parseFirstBrace = true );
|
||
|
|
// parse a braced section into a string
|
||
|
|
const char * ParseBracedSection( idStr &out, int tabs = -1, bool parseFirstBrace = true, char intro = '{', char outro = '}' );
|
||
|
|
// parse the rest of the line
|
||
|
|
const char * ParseRestOfLine( idStr &out );
|
||
|
|
// unread the given token
|
||
|
|
void UnreadToken( const idToken& token );
|
||
|
|
// read a token only if on the current line
|
||
|
|
int ReadTokenOnLine( idToken *token );
|
||
|
|
// read a signed integer
|
||
|
|
int ParseInt( void );
|
||
|
|
// read a boolean
|
||
|
|
bool ParseBool( void );
|
||
|
|
// read a floating point number
|
||
|
|
float ParseFloat( bool* hadError = NULL );
|
||
|
|
// parse matrices with floats
|
||
|
|
int Parse1DMatrix( int x, float *m );
|
||
|
|
int Parse2DMatrix( int y, int x, float *m );
|
||
|
|
int Parse3DMatrix( int z, int y, int x, float *m );
|
||
|
|
// retrieves the white space after the last read token
|
||
|
|
int GetNextWhiteSpace( idStr &whiteSpace, bool currentLine );
|
||
|
|
// retrieves the white space before the last read token
|
||
|
|
int GetLastWhiteSpace( idStr &whiteSpace ) const;
|
||
|
|
// add a define to the source
|
||
|
|
int AddDefine( const char *string );
|
||
|
|
// add includes to the source
|
||
|
|
int AddIncludes( const idStrList& includes );
|
||
|
|
// add an include to the source
|
||
|
|
int AddInclude( const char *string );
|
||
|
|
// add builtin defines
|
||
|
|
void AddBuiltinDefines( void );
|
||
|
|
// set the source include path
|
||
|
|
void SetIncludePath( const char *path );
|
||
|
|
// set pragma callback
|
||
|
|
void SetPragmaCallback( void *data, pragmaFunc_t func );
|
||
|
|
// set the punctuation set
|
||
|
|
void SetPunctuations( const punctuation_t *p );
|
||
|
|
// returns a pointer to the punctuation with the given id
|
||
|
|
const char * GetPunctuationFromId( int id );
|
||
|
|
// get the id for the given punctuation
|
||
|
|
int GetPunctuationId( const char *p );
|
||
|
|
// set lexer flags
|
||
|
|
void SetFlags( int flags );
|
||
|
|
// get lexer flags
|
||
|
|
int GetFlags( void ) const;
|
||
|
|
// returns the current filename
|
||
|
|
const char * GetFileName( void ) const;
|
||
|
|
// get current offset in current script
|
||
|
|
const int GetFileOffset( void ) const;
|
||
|
|
// get file time for current script
|
||
|
|
const unsigned int GetFileTime( void ) const;
|
||
|
|
// returns the current line number
|
||
|
|
const int GetLineNum( void ) const;
|
||
|
|
// print an error message
|
||
|
|
void Error( const char *str, ... ) const;
|
||
|
|
// print a warning message
|
||
|
|
void Warning( const char *str, ... ) const;
|
||
|
|
// for enumerating only the current level
|
||
|
|
int GetCurrentDependency( void ) const;
|
||
|
|
// walk all included files, start from 0 to enumerate all
|
||
|
|
const char* GetNextDependency( int &index ) const;
|
||
|
|
// add a global define that will be added to all opened sources
|
||
|
|
static int AddGlobalDefine( const char *string );
|
||
|
|
// remove the given global define
|
||
|
|
static int RemoveGlobalDefine( const char *name );
|
||
|
|
// remove all global defines
|
||
|
|
static void RemoveAllGlobalDefines( void );
|
||
|
|
// set the base folder to load files from
|
||
|
|
static void SetBaseFolder( const char *path );
|
||
|
|
|
||
|
|
// save off the state of the dependencies list
|
||
|
|
void PushDependencies();
|
||
|
|
void PopDependencies();
|
||
|
|
|
||
|
|
private:
|
||
|
|
int loaded; // set when a source file is loaded from file or memory
|
||
|
|
idStr filename; // file name of the script
|
||
|
|
idStr includepath; // path to include files
|
||
|
|
bool OSPath; // true if the file was loaded from an OS path
|
||
|
|
const punctuation_t *punctuations; // punctuations to use
|
||
|
|
int flags; // flags used for script parsing
|
||
|
|
idLexer * scriptstack; // stack with scripts of the source
|
||
|
|
idToken * tokens; // tokens to read first
|
||
|
|
define_t * defines; // list with macro definitions
|
||
|
|
define_t ** definehash; // hash chain with defines
|
||
|
|
indent_t * indentstack; // stack with indents
|
||
|
|
int skip; // > 0 if skipping conditional code
|
||
|
|
pragmaFunc_t pragmaCallback; // called when a #pragma is parsed
|
||
|
|
void * pragmaData;
|
||
|
|
int startLine; // line offset
|
||
|
|
|
||
|
|
static define_t * globaldefines; // list with global defines added to every source loaded
|
||
|
|
|
||
|
|
idStrList dependencies; // list of filenames that have been included
|
||
|
|
sdStack< int > dependencyStateStack; // stack of the number of dependencies
|
||
|
|
|
||
|
|
|
||
|
|
private:
|
||
|
|
void PushIndent( int type, int skip, int skipElse );
|
||
|
|
void PopIndent( int &type, int &skip, int &skipElse );
|
||
|
|
bool PushScript( idLexer *script );
|
||
|
|
int ReadSourceToken( idToken *token );
|
||
|
|
int ReadLine( idToken *token, bool multiline );
|
||
|
|
bool UnreadSourceToken( const idToken& token );
|
||
|
|
int ReadDefineParms( define_t *define, idToken **parms, int maxparms );
|
||
|
|
int StringizeTokens( idToken *tokens, idToken *token );
|
||
|
|
int MergeTokens( idToken *t1, idToken *t2 );
|
||
|
|
int ExpandBuiltinDefine( idToken *deftoken, define_t *define, idToken **firsttoken, idToken **lasttoken );
|
||
|
|
int ExpandDefine( idToken *deftoken, define_t *define, idToken **firsttoken, idToken **lasttoken );
|
||
|
|
int ExpandDefineIntoSource( idToken *deftoken, define_t *define );
|
||
|
|
void AddGlobalDefinesToSource( void );
|
||
|
|
define_t * CopyDefine( define_t *define );
|
||
|
|
define_t * FindHashedDefine(define_t **definehash, const char *name);
|
||
|
|
int FindDefineParm( define_t *define, const char *name );
|
||
|
|
void AddDefineToHash(define_t *define, define_t **definehash);
|
||
|
|
static void PrintDefine( define_t *define );
|
||
|
|
static void FreeDefine( define_t *define );
|
||
|
|
static define_t * FindDefine( define_t *defines, const char *name );
|
||
|
|
static define_t * DefineFromString( const char *string );
|
||
|
|
define_t * CopyFirstDefine( void );
|
||
|
|
void UnreadSignToken( void );
|
||
|
|
|
||
|
|
int EvaluateTokens( idToken *tokens, signed long int *intvalue, double *floatvalue, int integer );
|
||
|
|
int Evaluate( signed long int *intvalue, double *floatvalue, int integer );
|
||
|
|
int DollarEvaluate( signed long int *intvalue, double *floatvalue, int integer);
|
||
|
|
|
||
|
|
int Directive_include( void );
|
||
|
|
int Directive_define( bool isTemplate );
|
||
|
|
int Directive_undef( void );
|
||
|
|
int Directive_if_def( int type );
|
||
|
|
int Directive_ifdef( void );
|
||
|
|
int Directive_ifndef( void );
|
||
|
|
int Directive_else( void );
|
||
|
|
int Directive_endif( void );
|
||
|
|
int Directive_elif( void );
|
||
|
|
int Directive_if( void );
|
||
|
|
int Directive_line( void );
|
||
|
|
int Directive_error( void );
|
||
|
|
int Directive_warning( void );
|
||
|
|
int Directive_pragma( void );
|
||
|
|
int ReadDirective( void );
|
||
|
|
|
||
|
|
int DollarDirective_if_def( int type );
|
||
|
|
int DollarDirective_ifdef( void );
|
||
|
|
int DollarDirective_ifndef( void );
|
||
|
|
int DollarDirective_else( void );
|
||
|
|
int DollarDirective_endif( void );
|
||
|
|
int DollarDirective_elif( void );
|
||
|
|
int DollarDirective_if( void );
|
||
|
|
int DollarDirective_evalint( void );
|
||
|
|
int DollarDirective_evalfloat( void );
|
||
|
|
int ReadDollarDirective( void );
|
||
|
|
};
|
||
|
|
|
||
|
|
ID_INLINE const char *idParser::GetFileName( void ) const {
|
||
|
|
if ( scriptstack ) {
|
||
|
|
return scriptstack->GetFileName();
|
||
|
|
} else {
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ID_INLINE const int idParser::GetFileOffset( void ) const {
|
||
|
|
if ( scriptstack ) {
|
||
|
|
return scriptstack->GetFileOffset();
|
||
|
|
} else {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ID_INLINE const unsigned int idParser::GetFileTime( void ) const {
|
||
|
|
if ( scriptstack ) {
|
||
|
|
return scriptstack->GetFileTime();
|
||
|
|
} else {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ID_INLINE const int idParser::GetLineNum( void ) const {
|
||
|
|
if ( scriptstack ) {
|
||
|
|
return scriptstack->GetLineNum();
|
||
|
|
} else {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /* !__PARSER_H__ */
|