+++ /dev/null
-/*
- * Copyright (C) 2012
- * Dale Weiler
- *
- * 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
- * the Software without restriction, including without limitation the rights to
- * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is furnished to do
- * so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-#include "gmqcc.h"
-/*
- * Following parse states:
- * ASM_FUNCTION -- in a function accepting input statements
- * ....
- */
-typedef enum {
- ASM_NULL,
- ASM_FUNCTION
-} asm_state;
-
-typedef struct {
- char *name;
- char type; /* type, float, vector, string, function*/
- char elem; /* 0=x, 1=y, or 2=Z? */
- int offset; /* location in globals */
- bool isconst;
-} asm_sym;
-VECTOR_MAKE(asm_sym, asm_symbols);
-
-/*
- * Assembly text processing: this handles the internal collection
- * of text to allow parsing and assemblation.
- */
-static char* asm_getline(size_t *byte, FILE *fp) {
- char *line = NULL;
- size_t read = util_getline(&line, byte, fp);
- *byte = read;
- if (read == -1) {
- mem_d (line);
- return NULL;
- }
- return line;
-}
-
-/*
- * Entire external interface for main.c - to perform actual assemblation
- * of assembly files.
- */
-void asm_init(const char *file, FILE **fp) {
- *fp = fopen(file, "r");
- code_init();
-}
-void asm_close(FILE *fp) {
- fclose(fp);
- code_write("program.dat");
-}
-void asm_clear() {
- size_t i = 0;
- for (; i < asm_symbols_elements; i++)
- mem_d(asm_symbols_data[i].name);
- mem_d(asm_symbols_data);
-}
-
-/*
- * Dumps all values of all constants and assembly related
- * information obtained during the assembly procedure.
- */
-void asm_dumps() {
- size_t i = 0;
- for (; i < asm_symbols_elements; i++) {
- asm_sym *g = &asm_symbols_data[i];
- if (!g->isconst) continue;
- switch (g->type) {
- case TYPE_VECTOR: {
- util_debug("ASM", "vector %s %c[%f]\n", g->name,
- (g->elem == 0) ? 'X' :(
- (g->elem == 1) ? 'Y' :
- (g->elem == 2) ? 'Z' :' '),
- INT2FLT(code_globals_data[g->offset])
- );
- break;
- }
- case TYPE_FUNCTION: {
- util_debug("ASM", "function %s\n", g->name);
- }
- }
- }
-}
-
-/*
- * Parses a type, could be global or not depending on the
- * assembly state: global scope with assignments are constants.
- * globals with no assignments are globals. Function body types
- * are locals.
- */
-static GMQCC_INLINE bool asm_parse_type(const char *skip, size_t line, asm_state *state) {
- if ((strstr(skip, "FLOAT:") != &skip[0]) &&
- (strstr(skip, "VECTOR:") != &skip[0]) &&
- (strstr(skip, "ENTITY:") != &skip[0]) &&
- (strstr(skip, "FIELD:") != &skip[0]) &&
- (strstr(skip, "STRING:") != &skip[0])) return false;
-
- /* TODO: determine if constant, global, or local */
- switch (*skip) {
- /* VECTOR */ case 'V': {
- float val1;
- float val2;
- float val3;
- asm_sym sym;
-
- char *find = (char*)skip + 7;
- char *name = (char*)skip + 7;
- while (*find == ' ' || *find == '\t') find++;
-
- /* constant? */
- if (strchr(find, ',')) {
- /* strip name */
- *strchr((name = util_strdup(find)), ',')='\0';
- /* find data */
- find += strlen(name) + 1;
- while (*find == ' ' || *find == '\t') find++;
- /* valid name */
- if (util_strupper(name) || isdigit(*name)) {
- printf("invalid name for vector variable\n");
- mem_d(name);
- }
- /*
- * Parse all three elements of the vector. This will only
- * pass the first try if we hit a constant, otherwise it's
- * a global.
- */
- #define PARSE_ELEMENT(X,Y,Z) \
- if (isdigit(*X) || *X == '-'||*X == '+') { \
- bool negated = (*X == '-'); \
- if (negated || *X == '+') { X++; } \
- Y = (negated)?-atof(X):atof(X); \
- X = strchr(X, ','); \
- Z \
- }
-
- PARSE_ELEMENT(find, val1, { find ++; while (*find == ' ') { find ++; } });
- PARSE_ELEMENT(find, val2, { find ++; while (*find == ' ') { find ++; } });
- PARSE_ELEMENT(find, val3, { find ++; /* no need to do anything here */ });
- #undef PARSE_ELEMENT
- #define BUILD_ELEMENT(X,Y) \
- sym.type = TYPE_VECTOR; \
- sym.name = util_strdup(name); \
- sym.elem = (X); \
- sym.offset = code_globals_elements; \
- asm_symbols_add(sym); \
- code_globals_add(FLT2INT(Y))
- BUILD_ELEMENT(0, val1);
- BUILD_ELEMENT(1, val2);
- BUILD_ELEMENT(2, val3);
- #undef BUILD_ELEMENT
- mem_d(name);
- } else {
- /* TODO global not constant */
- }
- break;
- }
- /* ENTITY */ case 'E': {
- const char *find = skip + 7;
- while (*find == ' ' || *find == '\t') find++;
- printf("found ENTITY %s\n", find);
- break;
- }
- /* STRING */ case 'S': {
- const char *find = skip + 7;
- while (*find == ' ' || *find == '\t') find++;
- printf("found STRING %s\n", find);
- break;
- }
- }
-
- return false;
-}
-
-/*
- * Parses a function: trivial case, handles occurances of duplicated
- * names among other things. Ensures valid name as well, and even
- * internal engine function selection.
- */
-static GMQCC_INLINE bool asm_parse_func(const char *skip, size_t line, asm_state *state) {
- if (*state == ASM_FUNCTION)
- return false;
-
- if (strstr(skip, "FUNCTION:") == &skip[0]) {
- asm_sym sym;
- char *look = util_strdup(skip+10);
- char *copy = look;
- char *name = NULL;
- while (*copy == ' ' || *copy == '\t') copy++;
-
- memset(&sym, 0, sizeof(asm_sym));
-
- /*
- * Chop the function name out of the string, this allocates
- * a new string.
- */
- name = util_strchp(copy, strchr(copy, '\0'));
-
- /* TODO: failure system, missing name */
- if (!name) {
- printf("expected name on function\n");
- mem_d(copy);
- mem_d(name);
- return false;
- }
- /* TODO: failure system, invalid name */
- if (!isalpha(*name) || util_strupper(name)) {
- printf("invalid identifer for function name\n");
- mem_d(copy);
- mem_d(name);
- return false;
- }
-
- /*
- * Function could be internal function, look for $
- * to determine this.
- */
- if (strchr(name, ',')) {
- char *find = strchr(name, ',') + 1;
- prog_section_function function;
- prog_section_def def;
- memset(&function, 0, sizeof(prog_section_function));
- memset(&def, 0, sizeof(prog_section_def));
-
- /* skip whitespace */
- while (*find == ' ' || *find == '\t')
- find++;
-
- if (*find != '$') {
- printf("expected $ for internal function selection, got %s instead\n", find);
- mem_d(copy);
- mem_d(name);
- return false;
- }
- find ++;
- if (!isdigit(*find)) {
- printf("invalid internal identifier, expected valid number\n");
- mem_d(copy);
- mem_d(name);
- return false;
- }
- *strchr(name, ',')='\0';
-
- /*
- * Now add the following items to the code system:
- * function
- * definition (optional)
- * global (optional)
- * name
- */
- function.entry = -atoi(find);
- function.firstlocal = 0;
- function.locals = 0;
- function.profile = 0;
- function.name = code_chars_elements;
- function.file = 0;
- function.nargs = 0;
- def.type = TYPE_FUNCTION;
- def.offset = code_globals_elements;
- def.name = code_chars_elements;
- code_functions_add(function);
- code_defs_add (def);
- code_chars_put (name, strlen(name));
- code_chars_add ('\0');
- sym.type = TYPE_FUNCTION;
- sym.name = util_strdup(name);
- sym.offset = function.entry;
- asm_symbols_add(sym);
-
- util_debug("ASM", "added internal function %s to function table\n", name);
-
- /*
- * Sanatize the numerical constant used to select the
- * internal function. Must ensure it's all numeric, since
- * atoi can silently drop characters from a string and still
- * produce a valid constant that would lead to runtime problems.
- */
- if (util_strdigit(find))
- util_debug("ASM", "found internal function %s, -%d\n", name, atoi(find));
- else
- printf("invalid internal function identifier, must be all numeric\n");
-
- } else {
- /*
- * The function isn't an internal one. Determine the name and
- * amount of arguments the function accepts by searching for
- * the `#` (pound sign).
- */
- int args = 0;
- int size = 0;
- char *find = strchr(name, '#');
- char *peek = find;
-
- /*
- * Code structures for filling after determining the correct
- * information to add to the code write system.
- */
- prog_section_function function;
- prog_section_def def;
- memset(&function, 0, sizeof(prog_section_function));
- memset(&def, 0, sizeof(prog_section_def));
- if (find) {
- find ++;
-
- /* skip whitespace */
- if (*find == ' ' || *find == '\t')
- find++;
-
- /*
- * If the input is larger than eight, it's considered
- * invalid and shouldn't be allowed. The QuakeC VM only
- * allows a maximum of eight arguments.
- */
- if (*find == '9') {
- printf("invalid number of arguments, must be a valid number from 0-8\n");
- mem_d(copy);
- mem_d(name);
- return false;
- }
-
- if (*find != '0') {
- /*
- * if we made it this far we have a valid number for the
- * argument count, so fall through a switch statement and
- * do it.
- */
- switch (*find) {
- case '8': args++; case '7': args++;
- case '6': args++; case '5': args++;
- case '4': args++; case '3': args++;
- case '2': args++; case '1': args++;
- }
- }
- /*
- * We need to parse the argument size now by determining
- * the argument identifer list used after the amount of
- * arguments.
- */
- memset(function.argsize, 0, sizeof(function.argsize));
- find ++; /* skip the number */
- while (*find == ' ' || *find == '\t') find++;
- while (size < args) {
- switch (*find) {
- case 'V': case 'v': function.argsize[size]=3; break;
- case 'S': case 's':
- case 'F': case 'f':
- case 'E': case 'e': function.argsize[size]=1; break;
- case '\0':
- printf("missing argument identifer, expected %d\n", args);
- return false;
- default:
- printf("error invalid function argument identifier\n");
- return false;
- }
- size++,find++;
- }
- while (*find == ' ' || *find == '\t') find++;
- if (*find != '\0') {
- printf("too many function argument identifers expected %d\n", args);
- return false;
- }
- } else {
- printf("missing number of argument count in function %s\n", name);
- return false;
- }
-
- /*
- * Now we need to strip the name apart into it's exact size
- * by working in the peek buffer till we hit the name again.
- */
- if (*peek == '#') {
- peek --; /* '#' */
- peek --; /* number */
- }
- while (*peek == ' ' || *peek == '\t') peek--;
-
- /*
- * We're guranteed to be exactly where we need to be in the
- * peek buffer to null terminate and get our name from name
- * without any garbage before or after it.
- */
- *++peek='\0';
-
- /*
- * We got valid function structure information now. Lets add
- * the function to the code writer function table.
- */
- function.entry = code_statements_elements;
- function.firstlocal = 0;
- function.locals = 0;
- function.profile = 0;
- function.name = code_chars_elements;
- function.file = 0;
- function.nargs = args;
- def.type = TYPE_FUNCTION;
- def.offset = code_globals_elements;
- def.name = code_chars_elements;
- code_functions_add(function);
- code_globals_add (code_statements_elements);
- code_chars_put (name, strlen(name));
- code_chars_add ('\0');
- sym.type = TYPE_FUNCTION;
- sym.name = util_strdup(name);
- sym.offset = function.entry;
- asm_symbols_add(sym);
-
- /* update assembly state */
-
- *state = ASM_FUNCTION;
- util_debug("ASM", "added context function %s to function table\n", name);
- }
-
- mem_d(copy);
- mem_d(name);
- return true;
- }
- return false;
-}
-
-static GMQCC_INLINE bool asm_parse_stmt(const char *skip, size_t line, asm_state *state) {
- /*
- * This parses a valid statement in assembly and adds it to the code
- * table to be wrote. This needs to handle correct checking of all
- * statements to ensure the correct amount of operands are passed to
- * the menomic. This must also check for valid function calls (ensure
- * the names selected exist in the program scope) and ensure the correct
- * CALL* is used (depending on the amount of arguments the function
- * is expected to take)
- */
- enum {
- EXPECT_FUNCTION = 1,
- EXPECT_VARIABLE = 2,
- EXPECT_VALUE = 3
- };
-
- char *c = (char*)skip;
- size_t i = 0;
- char expect = 0;
- prog_section_statement s;
- memset(&s, 0, sizeof(prog_section_statement));
-
- /*
- * statements are only allowed when inside a function body
- * otherwise the assembly is invalid.
- */
- if (*state != ASM_FUNCTION)
- return false;
-
- /*
- * Skip any possible whitespace, it's not wanted we're searching
- * for an instruction. TODO: recrusive decent parser skip on line
- * entry instead of pre-op.
- */
- while (*skip == ' ' || *skip == '\t')
- skip++;
-
- for (; i < sizeof(asm_instr)/sizeof(*asm_instr); i++) {
- /*
- * Iterate all possible instructions and check if the selected
- * instructure in the input stream `skip` is actually a valid
- * instruction.
- */
- if (!strncmp(skip, asm_instr[i].m, asm_instr[i].l)) {
-
- /*
- * We hit the end of a function scope, retarget the state
- * and add a DONE statement to the statment table.
- */
- if (i == AINSTR_END) {
- s.opcode = i;
- code_statements_add(s);
- *state = ASM_NULL;
- return true;
- }
-
- /*
- * Check the instruction type to see what sort of data
- * it's expected to have.
- */
- if (i >= INSTR_CALL0 && i <= INSTR_CALL8)
- expect = EXPECT_FUNCTION;
- else
- expect = EXPECT_VARIABLE;
-
- util_debug(
- "ASM",
- "found statement %s expecting: `%s` (%ld operand(s))\n",
- asm_instr[i].m,
- (expect == EXPECT_FUNCTION)?"function name":(
- (expect == EXPECT_VARIABLE)?"variable name":(
- (expect == EXPECT_VALUE ?"value" : "unknown"))),
- asm_instr[i].o
- );
- /*
- * Parse the operands for `i` (the instruction). The order
- * of asm_instr is in the order of the menomic encoding so
- * `i` == menomic encoding.
- */
- s.opcode = i;
- switch (asm_instr[i].o) {
- /*
- * Each instruction can have from 0-3 operands; and can
- * be used with less or more operands depending on it's
- * selected use.
- *
- * DONE for example can use either 0 operands, or 1 (to
- * emulate the effect of RETURN)
- *
- * TODO: parse operands correctly figure out what it is
- * that the assembly is trying to do, i.e string table
- * lookup, function calls etc.
- *
- * This needs to have a fall state, we start from the
- * end of the string and work backwards.
- */
- #define OPEATS(X,Y) X##Y
- #define OPCCAT(X,Y) OPEATS(X,Y)
- #define OPLOAD(X,Y) \
- do { \
- util_debug("ASM", "loading operand data ...\n"); \
- if (expect == EXPECT_VARIABLE) { \
- size_t f=0; \
- for (; f<asm_symbols_elements; f++) { \
- if (!strncmp(asm_symbols_data[f].name, (Y), strlen(Y)) && \
- asm_symbols_data[f].type != TYPE_FUNCTION) { \
- (X)=asm_symbols_data[f].offset; \
- goto OPCCAT(foundv, __LINE__); \
- } \
- } \
- printf("no variable named %s\n", (Y)); \
- break; \
- OPCCAT(foundv,__LINE__) : \
- printf("operand loaded for %s\n", (Y)); \
- } else if (expect == EXPECT_FUNCTION) { \
- /* \
- * It's a function call not a variable association with an instruction \
- * these are harder to handle. \
- */ \
- size_t f=0; \
- if (strchr(Y, ' ')) { \
- *strchr(Y, ' ')='\0'; \
- } \
- for (; f<asm_symbols_elements; f++) { \
- if (!strncmp(asm_symbols_data[f].name, (Y), strlen(Y)) && \
- asm_symbols_data[f].type == TYPE_FUNCTION) { \
- (X)=asm_symbols_data[f].offset; \
- goto OPCCAT(foundf, __LINE__); \
- } \
- } \
- printf("no function named [%s]\n", (Y)); \
- break; \
- OPCCAT(foundf,__LINE__) : \
- printf("operand loaded for [%s]\n", (Y)); \
- } \
- } while (0)
- case 3: { OPLOAD(s.o3.s1,c); break; }
- case 2: { OPLOAD(s.o2.s1,c); break; }
- case 1: {
- while (*c == ' ' || *c == '\t') c++;
- c += asm_instr[i].l;
- while (*c == ' ' || *c == '\t') c++;
- OPLOAD(s.o1.s1, c);
- break;
- }
- #undef OPLOAD
- #undef OPCCAT
- }
- /* add the statement now */
- code_statements_add(s);
- }
- }
- return true;
-}
-
-void asm_parse(FILE *fp) {
- char *data = NULL;
- long line = 1; /* current line */
- size_t size = 0; /* size of line */
- asm_state state = ASM_NULL;
-
- #define asm_end(x) \
- do { \
- mem_d(data); \
- line ++; \
- util_debug("ASM", x); \
- } while (0); continue
-
- while ((data = asm_getline (&size, fp)) != NULL) {
- char *copy = data;
- char *skip = copy;
- while (*copy == ' ' || *copy == '\t') copy++;
- while (*skip != '\n') skip++;
- *skip='\0';
-
- if (asm_parse_type(copy, line, &state)){ asm_end("asm_parse_type\n"); }
- if (asm_parse_func(copy, line, &state)){ asm_end("asm_parse_func\n"); }
- if (asm_parse_stmt(copy, line, &state)){ asm_end("asm_parse_stmt\n"); }
- asm_end("asm_parse_white\n");
- }
- #undef asm_end
- asm_dumps();
- asm_clear();
-}
projects / xonotic / gmqcc.git / commitdiff