X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=gmqcc.h;h=d8697120f4193a9a9208d6f7dbb0505effb82683;hp=f1004ebf3c96ac8d53fdc358bca7175b1a69d58f;hb=a5e1f40b85faff802b8471c25ba9eb6f51e98ed5;hpb=857cb72a94c366998ae6bf21df9072d3343d0769 diff --git a/gmqcc.h b/gmqcc.h index f1004eb..d869712 100644 --- a/gmqcc.h +++ b/gmqcc.h @@ -1,6 +1,6 @@ /* * Copyright (C) 2012 - * Dale Weiler + * Dale Weiler, Wolfgang Bumiller * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in @@ -27,6 +27,53 @@ #include #include #include + +#define GMQCC_VERSION_MAJOR 0 +#define GMQCC_VERSION_MINOR 1 +#define GMQCC_VERSION_PATCH 0 +#define GMQCC_VERSION_BUILD(J,N,P) (((J)<<16)|((N)<<8)|(P)) +#define GMQCC_VERSION \ + GMQCC_VERSION_BUILD(GMQCC_VERSION_MAJOR, GMQCC_VERSION_MINOR, GMQCC_VERSION_PATCH) + +/* + * We cannoy rely on C99 at all, since compilers like MSVC + * simply don't support it. We define our own boolean type + * as a result (since we cannot include ). For + * compilers that are in 1999 mode (C99 compliant) we can use + * the language keyword _Bool which can allow for better code + * on GCC and GCC-like compilers, opposed to `int`. + */ +#ifndef __cplusplus +# ifdef false +# undef false +# endif /* !false */ +# ifdef true +# undef true +# endif /* !true */ +# define false (0) +# define true (1) +# define bool _Bool +# if __STDC_VERSION__ < 199901L && __GNUC__ < 3 + typedef int _Bool +# endif +# endif /* !__cplusplus */ + +/* + * Of some functions which are generated we want to make sure + * that the result isn't ignored. To find such function calls, + * we use this macro. + */ +#if defined(__GNUC__) || defined(__CLANG__) +# define GMQCC_WARN __attribute__((warn_unused_result)) +#else +# define GMQCC_WARN +#endif +/* + * This is a hack to silent clang regarding empty + * body if statements. + */ +#define GMQCC_SUPRESS_EMPTY_BODY do { } while (0) + /* * stdint.h and inttypes.h -less subset * for systems that don't have it, which we must @@ -62,7 +109,6 @@ typedef char uint8_size_is_correct [sizeof(uint8_t) == 1?1:-1]; typedef char uint16_size_if_correct [sizeof(uint16_t) == 2?1:-1]; typedef char uint32_size_is_correct [sizeof(uint32_t) == 4?1:-1]; -typedef char int8_size_is_correct [sizeof(int8_t) == 1?1:-1]; typedef char int16_size_if_correct [sizeof(int16_t) == 2?1:-1]; typedef char int32_size_is_correct [sizeof(int32_t) == 4?1:-1]; /* intptr_t / uintptr_t correct size check */ @@ -72,7 +118,7 @@ typedef char intptr_size_is_correct [sizeof(uintptr_t)== sizeof(int*)?1:-1]; //=================================================================== //============================ lex.c ================================ //=================================================================== -struct lex_file { +typedef struct lex_file_t { FILE *file; /* file handler */ char *name; /* name of file */ char peek [5]; @@ -83,30 +129,32 @@ struct lex_file { int length; /* bytes left to parse */ int size; /* never changes (size of file) */ int line; /* what line are we on? */ -}; +} lex_file; /* * It's important that this table never exceed 32 keywords, the ascii * table starts at 33 (and we don't want conflicts) */ -#define TOKEN_DO 0 -#define TOKEN_ELSE 1 -#define TOKEN_IF 2 -#define TOKEN_WHILE 3 -#define TOKEN_BREAK 4 -#define TOKEN_CONTINUE 5 -#define TOKEN_RETURN 6 -#define TOKEN_GOTO 7 -#define TOKEN_FOR 8 // extension -#define TOKEN_TYPEDEF 9 // extension - -// ensure the token types are out of the -// bounds of anyothers that may conflict. -#define TOKEN_FLOAT 110 -#define TOKEN_VECTOR 111 -#define TOKEN_STRING 112 -#define TOKEN_ENTITY 113 -#define TOKEN_VOID 114 +enum { + TOKEN_DO , + TOKEN_ELSE , + TOKEN_IF , + TOKEN_WHILE , + TOKEN_BREAK , + TOKEN_CONTINUE , + TOKEN_RETURN , + TOKEN_GOTO , + TOKEN_FOR , // extension + TOKEN_TYPEDEF , // extension + + // ensure the token types are out of the + // bounds of anyothers that may conflict. + TOKEN_FLOAT = 110, + TOKEN_VECTOR , + TOKEN_STRING , + TOKEN_ENTITY , + TOKEN_VOID +}; /* * Lexer state constants, these are numbers for where exactly in @@ -114,16 +162,19 @@ struct lex_file { * error occurs. These numbers must be > where the ascii-table ends * and > the last type token which is TOKEN_VOID */ -#define LEX_COMMENT 1128 -#define LEX_CHRLIT 1129 -#define LEX_STRLIT 1130 -#define LEX_IDENT 1131 +enum { + LEX_COMMENT = 1128, + LEX_CHRLIT , + LEX_STRLIT , + LEX_IDENT +}; -int lex_token (struct lex_file *); -void lex_reset (struct lex_file *); -void lex_close (struct lex_file *); -struct lex_file *lex_include(struct lex_file *, char *); -struct lex_file *lex_open (FILE *); +int lex_token (lex_file *); +void lex_reset (lex_file *); +void lex_close (lex_file *); +void lex_parse (lex_file *); +lex_file *lex_include(lex_file *, const char *); +void lex_init (const char *, lex_file **); //=================================================================== //========================== error.c ================================ @@ -133,12 +184,12 @@ struct lex_file *lex_open (FILE *); #define ERROR_INTERNAL (SHRT_MAX+2) #define ERROR_COMPILER (SHRT_MAX+3) #define ERROR_PREPRO (SHRT_MAX+4) -int error(struct lex_file *, int, const char *, ...); +int error(lex_file *, int, const char *, ...); //=================================================================== //========================== parse.c ================================ //=================================================================== -int parse_gen(struct lex_file *); +int parse_gen(lex_file *); //=================================================================== //========================== typedef.c ============================== @@ -150,22 +201,28 @@ typedef struct typedef_node_t { void typedef_init(); void typedef_clear(); typedef_node *typedef_find(const char *); -int typedef_add (struct lex_file *file, const char *, const char *); +int typedef_add (lex_file *file, const char *, const char *); //=================================================================== //=========================== util.c ================================ //=================================================================== -void *util_memory_a (unsigned int, unsigned int, const char *); -void util_memory_d (void *, unsigned int, const char *); -void util_meminfo (); +void *util_memory_a (unsigned int, unsigned int, const char *); +void util_memory_d (void *, unsigned int, const char *); +void util_meminfo (); + +bool util_strupper (const char *); +bool util_strdigit (const char *); +char *util_strdup (const char *); +char *util_strrq (const char *); +char *util_strrnl (const char *); +char *util_strsws (const char *); +char *util_strchp (const char *, const char *); +void util_debug (const char *, const char *, ...); +int util_getline (char **, size_t *, FILE *); +void util_endianswap (void *, int, int); -char *util_strdup (const char *); -char *util_strrq (char *); -char *util_strrnl (char *); -void util_debug (const char *, const char *, ...); -int util_getline (char **, size_t *, FILE *); -void util_endianswap(void *, int, int); +uint32_t util_crc32(const char *, int, register const short); #ifdef NOTRACK # define mem_a(x) malloc(x) @@ -175,41 +232,61 @@ void util_endianswap(void *, int, int); # define mem_d(x) util_memory_d((x), __LINE__, __FILE__) #endif -#define VECTOR_MAKE(T,N) \ - T* N##_data = NULL; \ - long N##_elements = 0; \ - long N##_allocated = 0; \ - int N##_add(T element) { \ - if (N##_elements == N##_allocated) { \ - if (N##_allocated == 0) { \ - N##_allocated = 12; \ - } else { \ - N##_allocated *= 2; \ - } \ - void *temp = mem_a(N##_allocated * sizeof(T)); \ - if (!temp) { \ - mem_d(temp); \ - return -1; \ - } \ - memcpy(temp, N##_data, (N##_elements * sizeof(T))); \ - mem_d(N##_data); \ - N##_data = (T*)temp; \ - } \ - N##_data[N##_elements] = element; \ - return N##_elements++; \ - } +/* Builds vector type (usefull for inside structures) */ +#define VECTOR_SNAP(X,Y) X ## Y +#define VECTOR_FILL(X,Y) VECTOR_SNAP(X,Y) +#define VECTOR_TYPE(T,N) \ + T* N##_data = NULL; \ + long N##_elements = 0; \ + long N##_allocated = 0 +/* Builds vector add */ +#define VECTOR_CORE(T,N) \ + int N##_add(T element) { \ + if (N##_elements == N##_allocated) { \ + if (N##_allocated == 0) { \ + N##_allocated = 12; \ + } else { \ + N##_allocated *= 2; \ + } \ + void *temp = mem_a(N##_allocated * sizeof(T)); \ + if (!temp) { \ + mem_d(temp); \ + return -1; \ + } \ + memcpy(temp, N##_data, (N##_elements * sizeof(T))); \ + mem_d(N##_data); \ + N##_data = (T*)temp; \ + } \ + N##_data[N##_elements] = element; \ + return N##_elements++; \ + } \ + int N##_put(T* elements, size_t len) { \ + len --; \ + elements--; \ + while (N##_add(*++elements) != -1 && len--); \ + return N##_elements; \ + } \ + typedef char VECTOR_FILL(extra_semicolon_,__COUNTER__) +/* Builds a full vector inspot */ +#define VECTOR_MAKE(T,N) \ + VECTOR_TYPE(T,N); \ + VECTOR_CORE(T,N) //=================================================================== //=========================== code.c ================================ //=================================================================== -#define TYPE_VOID 0 -#define TYPE_STRING 1 -#define TYPE_FLOAT 2 -#define TYPE_VECTOR 3 -#define TYPE_ENTITY 4 -#define TYPE_FIELD 5 -#define TYPE_FUNCTION 6 -#define TYPE_POINTER 7 +enum { + TYPE_VOID , + TYPE_STRING , + TYPE_FLOAT , + TYPE_VECTOR , + TYPE_ENTITY , + TYPE_FIELD , + TYPE_FUNCTION , + TYPE_POINTER , + /* TYPE_INTEGER , */ + TYPE_VARIANT , +}; /* * Each paramater incerements by 3 since vector types hold @@ -233,17 +310,17 @@ typedef struct { union { int16_t s1; /* signed */ uint16_t u1; /* unsigned */ - }; + } o1; /* operand 2 */ union { int16_t s2; /* signed */ uint16_t u2; /* unsigned */ - }; + } o2; /* operand 3 */ union { int16_t s3; /* signed */ uint16_t u3; /* unsigned */ - }; + } o3; /* * This is the same as the structure in darkplaces @@ -357,7 +434,14 @@ enum { INSTR_AND, INSTR_OR, INSTR_BITAND, - INSTR_BITOR + INSTR_BITOR, + + /* Virtual instructions used by the IR + * Keep at the end! + */ + VINSTR_PHI, + VINSTR_JUMP, + VINSTR_COND, }; /* @@ -377,7 +461,12 @@ int code_fields_add (prog_section_field); int code_functions_add (prog_section_function); int code_globals_add (int); int code_chars_add (char); -int code_strings_add (const char *); /* function wrapping code_chars_add */ +int code_statements_put(prog_section_statement*, size_t); +int code_defs_put (prog_section_def*, size_t); +int code_fields_put (prog_section_field*, size_t); +int code_functions_put (prog_section_function*, size_t); +int code_globals_put (int*, size_t); +int code_chars_put (char*, size_t); extern long code_statements_elements; extern long code_chars_elements; extern long code_globals_elements; @@ -471,4 +560,149 @@ static const struct { void asm_init (const char *, FILE **); void asm_close(FILE *); void asm_parse(FILE *); +//====================================================================== +//============================= main.c ================================= +//====================================================================== +enum { + COMPILER_QCC, /* circa QuakeC */ + COMPILER_FTEQCC, /* fteqcc QuakeC */ + COMPILER_QCCX, /* qccx QuakeC */ + COMPILER_GMQCC /* this QuakeC */ +}; +extern bool opts_debug; +extern bool opts_memchk; +extern bool opts_darkplaces_stringtablebug; +extern bool opts_omit_nullcode; +extern int opts_compiler; +//====================================================================== +//============================= ast.c ================================== +//====================================================================== +#define MEM_VECTOR_PROTO(Towner, Tmem, mem) \ + bool GMQCC_WARN Towner##_##mem##_add(Towner*, Tmem); \ + bool GMQCC_WARN Towner##_##mem##_remove(Towner*, size_t) + +#define MEM_VECTOR_PROTO_ALL(Towner, Tmem, mem) \ + MEM_VECTOR_PROTO(Towner, Tmem, mem); \ + bool GMQCC_WARN Towner##_##mem##_find(Towner*, Tmem, size_t*); \ + void Towner##_##mem##_clear(Towner*) + +#define MEM_VECTOR_MAKE(Twhat, name) \ + Twhat *name; \ + size_t name##_count; \ + size_t name##_alloc + +#define _MEM_VEC_FUN_ADD(Tself, Twhat, mem) \ +bool GMQCC_WARN Tself##_##mem##_add(Tself *self, Twhat f) \ +{ \ + Twhat *reall; \ + if (self->mem##_count == self->mem##_alloc) { \ + if (!self->mem##_alloc) { \ + self->mem##_alloc = 16; \ + } else { \ + self->mem##_alloc *= 2; \ + } \ + reall = (Twhat*)mem_a(sizeof(Twhat) * self->mem##_alloc); \ + if (!reall) { \ + return false; \ + } \ + memcpy(reall, self->mem, sizeof(Twhat) * self->mem##_count); \ + mem_d(self->mem); \ + self->mem = reall; \ + } \ + self->mem[self->mem##_count++] = f; \ + return true; \ +} + +#define _MEM_VEC_FUN_REMOVE(Tself, Twhat, mem) \ +bool GMQCC_WARN Tself##_##mem##_remove(Tself *self, size_t idx) \ +{ \ + size_t i; \ + Twhat *reall; \ + if (idx >= self->mem##_count) { \ + return true; /* huh... */ \ + } \ + for (i = idx; i < self->mem##_count-1; ++i) { \ + self->mem[i] = self->mem[i+1]; \ + } \ + self->mem##_count--; \ + if (self->mem##_count < self->mem##_count/2) { \ + self->mem##_alloc /= 2; \ + reall = (Twhat*)mem_a(sizeof(Twhat) * self->mem##_count); \ + if (!reall) { \ + return false; \ + } \ + memcpy(reall, self->mem, sizeof(Twhat) * self->mem##_count); \ + mem_d(self->mem); \ + self->mem = reall; \ + } \ + return true; \ +} + +#define _MEM_VEC_FUN_FIND(Tself, Twhat, mem) \ +bool GMQCC_WARN Tself##_##mem##_find(Tself *self, Twhat obj, size_t *idx) \ +{ \ + size_t i; \ + for (i = 0; i < self->mem##_count; ++i) { \ + if (self->mem[i] == obj) { \ + if (idx) { \ + *idx = i; \ + } \ + return true; \ + } \ + } \ + return false; \ +} + +#define _MEM_VEC_FUN_CLEAR(Tself, mem) \ +void Tself##_##mem##_clear(Tself *self) \ +{ \ + if (!self->mem) \ + return; \ + mem_d((void*) self->mem); \ + self->mem = NULL; \ + self->mem##_count = 0; \ + self->mem##_alloc = 0; \ +} + +#define MEM_VECTOR_CLEAR(owner, mem) \ + if ((owner)->mem) \ + mem_d((void*)((owner)->mem)); \ + (owner)->mem = NULL; \ + (owner)->mem##_count = 0; \ + (owner)->mem##_alloc = 0 + +#define MEM_VECTOR_INIT(owner, mem) \ +{ \ + (owner)->mem = NULL; \ + (owner)->mem##_count = 0; \ + (owner)->mem##_alloc = 0; \ +} + +#define MEM_VEC_FUNCTIONS(Tself, Twhat, mem) \ +_MEM_VEC_FUN_REMOVE(Tself, Twhat, mem) \ +_MEM_VEC_FUN_ADD(Tself, Twhat, mem) + +#define MEM_VEC_FUNCTIONS_ALL(Tself, Twhat, mem) \ +MEM_VEC_FUNCTIONS(Tself, Twhat, mem) \ +_MEM_VEC_FUN_CLEAR(Tself, mem) \ +_MEM_VEC_FUN_FIND(Tself, Twhat, mem) + +enum store_types { + store_global, + store_local, /* local, assignable for now, should get promoted later */ + store_value, /* unassignable */ +}; + +typedef struct { + float x, y, z; +} vector; + +/* + * A shallow copy of a lex_file to remember where which ast node + * came from. + */ +typedef struct { + const char *file; + size_t line; +} lex_ctx; #endif