#include <stdio.h>
#include <ctype.h>
+
#define GMQCC_VERSION_MAJOR 0
#define GMQCC_VERSION_MINOR 1
#define GMQCC_VERSION_PATCH 0
typedef long int32_t;
typedef unsigned long uint32_t;
- /* bail on 64 bit type! */
- typedef char int64_t;
- typedef char uint64_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;
bool util_strupper (const char *);
bool util_strdigit (const char *);
+bool util_strncmpexact (const char *, const char *, size_t);
char *util_strdup (const char *);
char *util_strrq (const char *);
char *util_strrnl (const char *);
# define mem_d(x) util_memory_d((x), __LINE__, __FILE__)
#endif
+/*
+ * TODO: make these safer to use. Currently this only works on
+ * x86 and x86_64, some systems will likely not like this. Such
+ * as BE systems.
+ */
+#define FLT2INT(Y) *((int32_t*)&(Y))
+#define INT2FLT(Y) *((float *)&(Y))
+
/* Builds vector type (usefull for inside structures) */
#define VECTOR_SNAP(X,Y) X ## Y
#define VECTOR_FILL(X,Y) VECTOR_SNAP(X,Y)
return N##_elements; \
} \
typedef char VECTOR_FILL(extra_semicolon_,__COUNTER__)
-/* Builds a full vector inspot */
+#define VECTOR_PROT(T,N) \
+ extern T* N##_data ; \
+ extern long N##_elements ; \
+ extern long N##_allocated; \
+ int N##_add(T); \
+ int N##_put(T *, size_t)
#define VECTOR_MAKE(T,N) \
VECTOR_TYPE(T,N); \
VECTOR_CORE(T,N)
} o1;
/* operand 2 */
union {
- int16_t s2; /* signed */
- uint16_t u2; /* unsigned */
+ int16_t s1; /* signed */
+ uint16_t u1; /* unsigned */
} o2;
/* operand 3 */
union {
- int16_t s3; /* signed */
- uint16_t u3; /* unsigned */
+ int16_t s1; /* signed */
+ uint16_t u1; /* unsigned */
} o3;
/*
INSTR_BITAND,
INSTR_BITOR,
- /* Virtual instructions used by the IR
+ /*
+ * Virtual instructions used by the assembler
+ * keep at the end but before virtual instructions
+ * for the IR below.
+ */
+ AINSTR_END,
+
+ /*
+ * Virtual instructions used by the IR
* Keep at the end!
*/
VINSTR_PHI,
* VECTOR_MAKE(int, code_globals );
* VECTOR_MAKE(char, code_chars );
*/
-int code_statements_add(prog_section_statement);
-int code_defs_add (prog_section_def);
-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_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;
-extern long code_functions_elements;
-extern long code_fields_elements;
-extern long code_defs_elements;
+VECTOR_PROT(prog_section_statement, code_statements);
+VECTOR_PROT(prog_section_statement, code_statements);
+VECTOR_PROT(prog_section_def, code_defs );
+VECTOR_PROT(prog_section_field, code_fields );
+VECTOR_PROT(prog_section_function, code_functions );
+VECTOR_PROT(int, code_globals );
+VECTOR_PROT(char, code_chars );
/*
* code_write -- writes out the compiled file
* code_init -- prepares the code file
*/
-void code_write ();
-void code_init ();
+bool code_write (const char *filename);
+void code_init ();
+uint32_t code_genstring (const char *string);
+uint32_t code_cachedstring(const char *string);
/*===================================================================*/
/*========================= assembler.c =============================*/
{ "NOT_FNC" , 0, 7 },
{ "IF" , 0, 2 },
{ "IFNOT" , 0, 5 },
- { "CALL0" , 0, 5 },
- { "CALL1" , 0, 5 },
- { "CALL2" , 0, 5 },
- { "CALL3" , 0, 5 },
- { "CALL4" , 0, 5 },
- { "CALL5" , 0, 5 },
- { "CALL6" , 0, 5 },
- { "CALL7" , 0, 5 },
- { "CALL8" , 0, 5 },
+ { "CALL0" , 1, 5 },
+ { "CALL1" , 2, 5 },
+ { "CALL2" , 3, 5 },
+ { "CALL3" , 4, 5 },
+ { "CALL4" , 5, 5 },
+ { "CALL5" , 6, 5 },
+ { "CALL6" , 7, 5 },
+ { "CALL7" , 8, 5 },
+ { "CALL8" , 9, 5 },
{ "STATE" , 0, 5 },
{ "GOTO" , 0, 4 },
{ "AND" , 0, 3 },
{ "OR" , 0, 2 },
{ "BITAND" , 0, 6 },
- { "BITOR" , 0, 5 }
+ { "BITOR" , 0, 5 },
+ { "END" , 0, 3 } /* virtual assembler instruction */
};
void asm_init (const char *, FILE **);