/*
* 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
#include <string.h>
#include <stdio.h>
#include <ctype.h>
+
+#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 <stdbool.h>). 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
+
/*
* stdint.h and inttypes.h -less subset
* for systems that don't have it, which we must
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 */
//===================================================================
//============================ lex.c ================================
//===================================================================
-struct lex_file {
+typedef struct lex_file_t {
FILE *file; /* file handler */
char *name; /* name of file */
char peek [5];
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
* 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 ================================
#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 ==============================
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 ();
-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);
+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);
uint32_t util_crc32(const char *, int, register const short);
# 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_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; \
}
+/* Builds a full vector inspot */
+#define VECTOR_MAKE(T,N) \
+ VECTOR_TYPE(T,N); \
+ VECTOR_CORE(T,N)
+/* Builds a vector add function pointer for inside structures */
+#define VECTOR_IMPL(T,N) int (*N##_add)(T)
//===================================================================
//=========================== 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
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,
};
/*
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;
//======================================================================
//============================= main.c =================================
//======================================================================
-extern int opts_debug;
-extern int opts_memchk;
+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; \
+ free((void*) self->mem); \
+ self->mem = NULL; \
+ self->mem##_count = 0; \
+ self->mem##_alloc = 0; \
+}
+
+#define MEM_VECTOR_CLEAR(owner, mem) \
+ if ((owner)->mem) \
+ free((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_t;
+
+/*
+ * A shallow copy of a lex_file to remember where which ast node
+ * came from.
+ */
+typedef struct lex_ctx {
+ const char *file;
+ size_t line;
+} lex_ctx_t;
#endif