#ifndef LEX_H__
#define LEX_H__ 1
#include "driver.h"
#include "typedefs.h"
#ifndef USE_NEW_INLINES
#include "strfuns.h"
#endif
/* --- Types --- */
typedef struct source_file_s source_file_t; /* forward */
/* --- struct source_loc_s: location within a source file ---
*
* This structure is used to identify the location of lexical elements
* in the input source. The pointers contained become invalid after
* a compilation has finished.
*/
typedef struct source_loc_s
{
source_file_t * file; /* The source file, if any, or NULL */
int line; /* The source line */
} source_loc_t;
/* --- struct source_file_s: a source file ---
*
* This structure is used to describe a source file used in the compilation.
* The embedded source_loc_t structure references the file this particular
* source file was included from.
*
* Together the structures form a tree, describing the include structure
* of the compiled program. With the end of the compilation, all contained
* pointers become invalid.
*
* The structures are additionally linked together into a singly linked list
* in order of allocation; the list is used by the lexer to deallocate the
* tree.
*/
struct source_file_s
{
source_file_t * next; /* next source_file structure, or NULL */
char * name; /* Allocated: the name of the file */
source_loc_t parent; /* the file/line this source was included from;
* or NULL if none.
*/
};
/* --- struct lpc_predef_s: predefined preprocessor macros ---
*
* The structures are used in a list to store macro definitions
* given to the driver on the commandline. The list is evaluated
* when the lexer is first initialised.
*/
struct lpc_predef_s
{
char * flag;
/* The raw text of the definition in the form 'NAME' or 'NAME=<value>'
* in its own allocated memory.
*/
struct lpc_predef_s *next;
/* Next predefinition in the list, or NULL.
*/
};
/* --- typedef defn_fun: dynamic macro expansion ---
*
* Functions of this type are used to provide dynamic macro expansions.
* When used in a macro definition instead of a static replacement text,
* they are called at every point of macro use.
*
* If the implemented macro takes no argument, NULL is passed
* in the call and the function has to return a fresh allocation of
* the replacement text.
*
* If the macro takes arguments, they are passed as char** with as
* many arguments as the definition requires. The macro has to add
* the replacement text via add_input() and return NULL.
*
* TODO: Also, the different handling of the replacement text is ugly.
*/
typedef char * (*defn_fun)(char **);
/* --- struct defn: definition of a macro ---
*
* Macros are stored in the ident_table[] as I_TYPE_DEFINEs. Their replacement
* can be given as literal text, or as the result of a function called every
* time the macro is used.
*
* The function is passed an char*[] with the current macro argument values,
* terminated with a NULL, and has to return an allocated c-string with
* the replacement text.
*
* The replacement text must not contain comments.
*
* Function macros (.nargs >= 0) expect the replacement text to contain
* special MARKS sequences ('@' followed by another character) to mark
* the places where the function arguments are to be inserted. The code
* of the second character minus ('@'+1) gives the number of the argument
* to insert. The sequence '@@' stands for the literal '@' character.
*
* Plain macros (.nargs < 0) take the replacement text as it is.
*/
struct defn
{
union { /* The replacement text: */
char *str; /* given as tabled literal (.special is false) */
defn_fun fun; /* return by fun() (.special is true) */
} exps;
short nargs; /* Number of arguments, 0 for non-function macros
*/
SBool permanent; /* true: permanent define */
SBool special; /* true: <fun> returns the replacement text */
source_loc_t loc; /* location of the definition,
* NULL for predefined macros.
*/
};
/* --- struct ident_s: known identifiers ---
*
* The structure is used to keep the information about all identifiers
* encountered so far (including reserved words, efuns, etc).
*
* There can several entries for the same identifier name but with
* different types in the table. These entries are put into a list formed
* by their .inferior pointers, sorted by falling type values. The entry
* with the highest type is the one linked into the hash chain.
*
* The identifiers are stored in a table of chains, hashed over their names.
* The most recently identifier always brought to the head of its hash-chain.
*
* Additionally, all efuns and defines are stored in their
* own 'all_...' lists, linked by the '.next_all' field.
*/
struct ident_s
{
string_t *name; /* Name of the identifier (tabled string)
* The inferiour structures (if any) and this
* structure all share the same reference to
* the string. */
short type; /* Type of this entry */
short hash; /* Hashvalue of this identifier */
ident_t *next; /* Next in hash chain */
ident_t *inferior; /* Ident of same name, but lower type */
union { /* Type-depend data: */
struct defn define; /* Macro definition */
int code; /* Reserved word: lexem code */
struct { /* Global identifier: */
short function;
/* >= 0: lfun: Index number of the lfun in den function table,
* < 0: Undefined
*/
short variable;
/* >= 0: variable: Index number in the variable table.
* During compilation, virtual variables are offset
* by VIRTUAL_VAR_TAG.
* < 0: -2: efun/sefun, -1: lfun/inherited hidden var
*/
short efun;
/* efun: Index in instrs[], negative else
* < 0: -1: gvar/sefun
*/
short sim_efun;
/* simul-efun: Index in simul_efun[], negative else
* < 0: -1: efun/gvar
*/
#ifdef USE_STRUCTS
short struct_id;
/* struct index ('id') in the current program's struct table.
* < 0: undefined
*/
#endif
} global;
struct { /* Local identifier: */
int num; /* Number, also the index on the stack */
int context; /* -1 for normal locals, or the index
* in the context frame. In that case,
* .num is either -1 or the index
* of the related local of the defining
* function.
*/
int depth; /* Definition depth */
} local;
} u;
ident_t *next_all; /* 'all_...' list link */
};
/* ident_t.type values: */
#define I_TYPE_UNKNOWN 0
#define I_TYPE_GLOBAL 2 /* function, variable or efuns/simul_efuns */
#define I_TYPE_LOCAL 3
#define I_TYPE_RESWORD 4 /* reserved word */
#define I_TYPE_DEFINE 5
/* ident_t.global magic values */
#define I_GLOBAL_FUNCTION_OTHER (-1)
#define I_GLOBAL_VARIABLE_OTHER (-1)
#define I_GLOBAL_VARIABLE_FUN (-2)
#define I_GLOBAL_EFUN_OTHER (-1)
#define I_GLOBAL_SEFUN_OTHER (-1)
#ifdef USE_STRUCTS
#define I_GLOBAL_STRUCT_NONE (-1)
#endif
#define lookup_predef(p) (p->type == I_TYPE_GLOBAL ? p->u.global.efun : -1)
#ifndef USE_NEW_INLINES
/* --- struct inline_fun: linked list element of saved function texts ---
*
* The functions inlined by (: ... :) have their code (plus the function
* header and trailer) saved for later parsing in a list of these
* structures.
*/
struct inline_fun
{
strbuf_t buf; /* the complete function text */
struct inline_fun * next; /* next list element */
};
#endif /* USE_NEW_INLINES */
/* --- Variables --- */
extern struct lpc_predef_s * lpc_predefs;
extern int total_lines;
extern source_loc_t current_loc;
extern Bool pragma_strict_types;
extern Bool pragma_use_local_scopes;
extern Bool pragma_save_types;
extern Bool pragma_combine_strings;
extern Bool pragma_verbose_errors;
extern Bool pragma_no_clone;
extern Bool pragma_no_inherit;
extern Bool pragma_no_shadow;
extern Bool pragma_pedantic;
extern Bool pragma_range_check;
extern Bool pragma_warn_missing_return;
extern Bool pragma_warn_deprecated;
extern Bool pragma_warn_empty_casts;
extern Bool pragma_check_overloads;
extern Bool pragma_share_variables;
extern string_t *last_lex_string;
extern ident_t *all_efuns;
#ifndef USE_NEW_INLINES
extern struct inline_fun * first_inline_fun;
extern Bool insert_inline_fun_now;
extern unsigned int next_inline_fun;
#endif /* USE_NEW_INLINES */
/* Values of pragma_strict_types */
#define PRAGMA_WEAK_TYPES 0
#define PRAGMA_STRONG_TYPES 1
#define PRAGMA_STRICT_TYPES 2
/* --- Prototypes --- */
extern void init_lexer(void);
extern int symbol_operator(const char *symbol, const char **endp);
extern void symbol_efun_str(const char *str, size_t len, svalue_t *sp, Bool is_efun);
extern void symbol_efun(string_t *name, svalue_t *sp);
extern void init_global_identifier (ident_t * ident, Bool bVariable);
extern ident_t *lookfor_shared_identifier(char *, int, int, Bool);
#define make_shared_identifier(s,n,d) lookfor_shared_identifier(s,n,d, MY_TRUE)
#define find_shared_identifier(s,n,d) lookfor_shared_identifier(s,n,d, MY_FALSE)
extern ident_t *make_global_identifier(char *, int);
extern void free_shared_identifier(ident_t*);
extern int yylex(void);
extern void end_new_file(void);
extern void lex_close(char *msg);
extern void start_new_file(int fd, const char * fname);
extern char *get_f_name(int n);
extern void free_defines(void);
extern size_t show_lexer_status (strbuf_t * sbuf, Bool verbose);
extern void set_inc_list(vector_t *v);
extern void remove_unknown_identifier(void);
extern char *lex_error_context(void);
extern svalue_t *f_expand_define(svalue_t *sp);
extern char * lex_parse_number (char * cp, unsigned long * p_num, Bool * p_overflow);
#ifdef USE_NEW_INLINES
extern void * get_include_handle (void);
#endif /* USE_NEW_INLINES */
#ifdef GC_SUPPORT
extern void count_lex_refs(void);
#endif /* GC_SUPPORT */
#endif /* LEX_H__ */
