+#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
+/*
+ * This is a hack to silent clang regarding empty
+ * body if statements.
+ */
+#define GMQCC_SUPRESS_EMPTY_BODY do { } while (0)
+
+/*
+ * Inline is not supported in < C90, however some compilers
+ * like gcc and clang might have an inline attribute we can
+ * use if present.
+ */
+#if __STDC_VERSION__ < 199901L
+# if defined(__GNUC__) || defined (__CLANG__)
+# if __GNUC__ < 2
+# define GMQCC_INLINE
+# else
+# define GMQCC_INLINE __attribute__ ((always_inline))
+# endif
+# else
+# define GMQCC_INLINE
+# endif
+#else
+# define GMQCC_INLINE inline
+#endif
+
+/*
+ * stdint.h and inttypes.h -less subset
+ * for systems that don't have it, which we must
+ * assume is all systems. (int8_t not required)
+ */
+#if CHAR_MIN == -128
+ typedef unsigned char uint8_t; /* same as below */
+#elif SCHAR_MIN == -128
+ typedef unsigned char uint8_t; /* same as above */
+#endif
+#if SHRT_MAX == 0x7FFF
+ typedef short int16_t;
+ typedef unsigned short uint16_t;
+#elif INT_MAX == 0x7FFF
+ typedef int int16_t;
+ typedef unsigned int uint16_t;
+#endif
+#if INT_MAX == 0x7FFFFFFF
+ typedef int int32_t;
+ typedef unsigned int uint32_t;
+ typedef long int64_t;
+ typedef unsigned long uint64_t;
+#elif LONG_MAX == 0x7FFFFFFF
+ typedef long int32_t;
+ typedef unsigned long uint32_t;
+
+ /*
+ * It's nearly impossible to figure out a 64bit type at
+ * this point without making assumptions about the build
+ * enviroment. So if clang or gcc is detected use some
+ * compiler builtins to create a 64 signed and unsigned
+ * type.
+ */
+# if defined(__GNUC__) || defined (__CLANG__)
+ typedef int int64_t __attribute__((__mode__(__DI__)));
+ typedef unsigned int uint64_t __attribute__((__mode__(__DI__)));
+# else
+ /*
+ * Incoorectly size the types so static assertions below will
+ * fail. There is no valid way to get a 64bit type at this point
+ * without making assumptions of too many things.
+ */
+ typedef char int64_t;
+ typedef char uint64_t;
+# endif
+#endif
+#ifdef _LP64 /* long pointer == 64 */
+ typedef unsigned long uintptr_t;
+ typedef long intptr_t;
+#else
+ typedef unsigned int uintptr_t;
+ typedef int intptr_t;
+#endif
+/* Ensure type sizes are correct: */
+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 uint64_size_is_correct [sizeof(uint64_t) == 8?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];
+typedef char int64_size_is_correct [sizeof(int64_t) == 8?1:-1];
+/* intptr_t / uintptr_t correct size check */
+typedef char uintptr_size_is_correct[sizeof(intptr_t) == sizeof(int*)?1:-1];
+typedef char intptr_size_is_correct [sizeof(uintptr_t)== sizeof(int*)?1:-1];
+
+/*===================================================================*/
+/*============================ lex.c ================================*/
+/*===================================================================*/
+typedef struct lex_file_t {
+ FILE *file; /* file handler */
+ char *name; /* name of file */
+ char peek [5];
+ char lastok[8192];
+
+ int last; /* last token */
+ int current; /* current token */
+ int length; /* bytes left to parse */
+ int size; /* never changes (size of file) */
+ int line; /* what line are we on? */
+} lex_file;