-int parse(struct lex_file *file) {
- struct parsenode *parsetree = NULL;
- struct parsenode *parseroot = NULL;
-
- /*
- * Allocate memory for our parse tree:
- * the parse tree is just a singly linked list which will contain
- * all the data for code generation.
- */
- if (!parseroot) {
- parseroot = mem_a(sizeof(struct parsenode));
- if (!parseroot)
- return error(ERROR_INTERNAL, "Ran out of memory", " ");
- parsetree = parseroot;
- }
-
- int token = 0;
- while ((token = lex_token(file)) != ERROR_LEX && \
- token != ERROR_COMPILER && \
- token != ERROR_INTERNAL && \
- token != ERROR_PARSE && \
- token != ERROR_PREPRO && file->length >= 0) {
- switch (token) {
- case TOKEN_IF:
- token = lex_token(file);
- while ((token == ' ' || token == '\n') && file->length >= 0)
- token = lex_token(file);
-
- if (token != '(')
- error(ERROR_PARSE, "Expected `(` after if\n", "");
-
- PARSE_TREE_ADD(PARSE_TYPE_IF);
- break;
- case TOKEN_ELSE:
- token = lex_token(file);
- while ((token == ' ' || token == '\n') && file->length >= 0)
- token = lex_token(file);
-
- PARSE_TREE_ADD(PARSE_TYPE_ELSE);
- break;
- case TOKEN_FOR:
- token = lex_token(file);
- while ((token == ' ' || token == '\n') && file->length >= 0)
- token = lex_token(file);
-
- PARSE_TREE_ADD(PARSE_TYPE_FOR);
- break;
-
- case LEX_IDENT:
- token = lex_token(file);
- break;
-
- /*
- * This is a quick and easy way to do typedefs at parse time
- * all power is in typedef_add(), in typedef.c. We handle
- * the tokens accordingly here.
- */
- case TOKEN_TYPEDEF: {
- char *f = NULL;
- char *t = NULL;
- token = lex_token(file);
- token = lex_token(file); f = strdup(file->lastok);
- token = lex_token(file);
- token = lex_token(file); t = strdup(file->lastok);
-
- typedef_add(f, t);
-
- /* free stdup strings */
- mem_d(f);
- mem_d(t);
- break;
- }
-
-
- case TOKEN_DO: PARSE_TODO(PARSE_TYPE_DO);
- case TOKEN_WHILE: PARSE_TODO(PARSE_TYPE_WHILE);
- case TOKEN_BREAK: PARSE_TODO(PARSE_TYPE_BREAK);
- case TOKEN_CONTINUE: PARSE_TODO(PARSE_TYPE_CONTINUE);
- case TOKEN_RETURN: PARSE_TODO(PARSE_TYPE_RETURN);
- case TOKEN_GOTO: PARSE_TODO(PARSE_TYPE_GOTO);
- case TOKEN_VOID: PARSE_TODO(PARSE_TYPE_VOID);
- case TOKEN_STRING: PARSE_TODO(PARSE_TYPE_STRING);
- case TOKEN_FLOAT: PARSE_TODO(PARSE_TYPE_FLOAT);
- case TOKEN_VECTOR: PARSE_TODO(PARSE_TYPE_VECTOR);
- case TOKEN_ENTITY: PARSE_TODO(PARSE_TYPE_ENTITY);
-
- /*
- * From here down is all language punctuation: There is no
- * need to actual create tokens from these because they're already
- * tokenized as these individual tokens (which are in a special area
- * of the ascii table which doesn't conflict with our other tokens
- * which are higer than the ascii table.)
- */
- case '#':
- /*
- * Skip the preprocessor for now: We'll implement our own
- * eventually. For now we need to make sure directives are
- * not accidently tokenized.
- */
- token = lex_token(file);
- token = lex_token(file);
-
- /* skip all tokens to end of directive */
- while (token != '\n')
- token = lex_token(file);
- break;
-
- case '&': /* & */
- token = lex_token(file);
- if (token == '&') { /* && */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LAND);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_BAND);
- break;
- case '|': /* | */
- token = lex_token(file);
- if (token == '|') { /* || */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LOR);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_BOR);
- break;
- case '!':
- token = lex_token(file);
- if (token == '=') { /* != */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LNEQ);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_LNOT);
- break;
- case '<': /* < */
- token = lex_token(file);
- if (token == '=') { /* <= */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LTEQ);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_LT);
- break;
- case '>': /* > */
- token = lex_token(file);
- if (token == '=') { /* >= */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_GTEQ);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_GT);
- break;
- case '=':
- token = lex_token(file);
- if (token == '=') { /* == */
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_EQEQ);
- break;
- }
- PARSE_TREE_ADD(PARSE_TYPE_EQUAL);
- break;
- case ';':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_DONE);
- break;
- case '-':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_MINUS);
- break;
- case '+':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_ADD);
- break;
- case '(':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LPARTH);
- break;
- case ')':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_RPARTH);
- break;
- case '{':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_LBS);
- break;
- case '}':
- token = lex_token(file);
- PARSE_TREE_ADD(PARSE_TYPE_RBS);
- break;
- }
- }
- parse_debug(parseroot);
- lex_reset(file);
-
- return 1;
-}
+ /* strings are in file->lastok */
+ switch (type) {
+ case TOKEN_VOID:
+ error(file, ERROR_PARSE, "Cannot assign value to type void\n");
+
+ /* TODO: Validate (end quote), strip quotes for constant add, name constant */
+ case TOKEN_STRING:
+ if (*file->lastok != '"')
+ error(file, ERROR_PARSE, "Expected a '\"' (quote) for string constant\n");
+ /* add the compile-time constant */
+ {
+ constant c;
+ c.name = util_strdup(name),
+ c.type = TYPE_STRING,
+ c.value[0] = 0;
+ c.value[1] = 0;
+ c.value[2] = 0;
+ c.string = util_strdup(file->lastok);
+ compile_constants_add(c);
+ }
+ break;
+ /* TODO: name constant, old qc vec literals, whitespace fixes, name constant */
+ case TOKEN_VECTOR: {
+ float compile_calc_x = 0;
+ float compile_calc_y = 0;
+ float compile_calc_z = 0;
+ int compile_calc_d = 0; /* dot? */
+ int compile_calc_s = 0; /* sign (-, +) */
+
+ char compile_data[1024];
+ char *compile_eval = compile_data;
+
+ if (token != '{')
+ error(file, ERROR_PARSE, "Expected initializer list {} for vector constant\n");
+
+ /*
+ * This parses a single vector element: x,y & z. This will handle all the
+ * complicated mechanics of a vector, and can be extended as well. This
+ * is a rather large macro, and is #undef'd after it's use below.
+ */
+ #define PARSE_VEC_ELEMENT(NAME, BIT) \
+ token = lex_token(file); \
+ if (token == ' ') \
+ token = lex_token(file); \
+ if (token == '.') \
+ compile_calc_d = 1; \
+ if (!isdigit(token) && !compile_calc_d && token != '+' && token != '-') \
+ error(file, ERROR_PARSE,"Invalid constant initializer element %c for vector, must be numeric\n", NAME); \
+ if (token == '+') \
+ compile_calc_s = '+'; \
+ if (token == '-' && !compile_calc_s) \
+ compile_calc_s = '-'; \
+ while (isdigit(token) || token == '.' || token == '+' || token == '-') { \
+ *compile_eval++ = token; \
+ token = lex_token(file); \
+ if (token == '.' && compile_calc_d) { \
+ error(file, ERROR_PARSE, "Invalid constant initializer element %c for vector, must be numeric.\n", NAME); \
+ token = lex_token(file); \
+ } \
+ if ((token == '-' || token == '+') && compile_calc_s) { \
+ error(file, ERROR_PARSE, "Invalid constant initializer sign for vector element %c\n", NAME); \
+ token = lex_token(file); \
+ } \
+ else if (token == '.' && !compile_calc_d) \
+ compile_calc_d = 1; \
+ else if (token == '-' && !compile_calc_s) \
+ compile_calc_s = '-'; \
+ else if (token == '+' && !compile_calc_s) \
+ compile_calc_s = '+'; \
+ } \
+ if (token == ' ') \
+ token = lex_token(file); \
+ if (NAME != 'z') { \
+ if (token != ',' && token != ' ') \
+ error(file, ERROR_PARSE, "invalid constant initializer element %c for vector (missing spaces, or comma delimited list?)\n", NAME); \
+ } else if (token != '}') { \
+ error(file, ERROR_PARSE, "Expected `}` on end of constant initialization for vector\n"); \
+ } \
+ compile_calc_##BIT = atof(compile_data); \
+ compile_calc_d = 0; \
+ compile_calc_s = 0; \
+ compile_eval = &compile_data[0]; \
+ memset(compile_data, 0, sizeof(compile_data))
+
+ /*
+ * Parse all elements using the macro above.
+ * We must undef the macro afterwards.
+ */
+ PARSE_VEC_ELEMENT('x', x);
+ PARSE_VEC_ELEMENT('y', y);
+ PARSE_VEC_ELEMENT('z', z);
+ #undef PARSE_VEC_ELEMENT
+
+ /* Check for the semi-colon... */
+ token = lex_token(file);
+ if (token == ' ')
+ token = lex_token(file);
+ if (token != ';')
+ error(file, ERROR_PARSE, "Expected `;` on end of constant initialization for vector\n");
+
+ /* add the compile-time constant */
+ {
+ constant c;
+
+ c.name = util_strdup(name),
+ c.type = TYPE_VECTOR,
+ c.value[0] = compile_calc_x;
+ c.value[1] = compile_calc_y;
+ c.value[2] = compile_calc_z;
+ c.string = NULL;
+ compile_constants_add(c);
+ }
+ break;
+ }
+
+ case TOKEN_ENTITY:
+ case TOKEN_FLOAT: /*TODO: validate, constant generation, name constant */
+ if (!isdigit(token))
+ error(file, ERROR_PARSE, "Expected numeric constant for float constant\n");
+ /* constant */
+ {
+ constant c;
+ c.name = util_strdup(name),
+ c.type = TOKEN_FLOAT,
+ c.value[0] = 0;
+ c.value[1] = 0;
+ c.value[2] = 0;
+ c.string = NULL;
+ compile_constants_add(c);
+ }
+ break;
+ }
+ } else if (token == '(') {
+ printf("FUNCTION ??\n");
+ }
+ mem_d(name);
+ }}
+
+ /*
+ * From here down is all language punctuation: There is no
+ * need to actual create tokens from these because they're already
+ * tokenized as these individual tokens (which are in a special area
+ * of the ascii table which doesn't conflict with our other tokens
+ * which are higer than the ascii table.)
+ */
+ case '#':
+ token = lex_token(file); /* skip '#' */
+ if (token == ' ')
+ token = lex_token(file);
+ /*
+ * If we make it here we found a directive, the supported
+ * directives so far are #include.
+ */
+ if (strncmp(file->lastok, "include", sizeof("include")) == 0) {
+ char *copy = NULL;
+ lex_file *next = NULL;
+ /*
+ * We only suport include " ", not <> like in C (why?)
+ * because the latter is silly.
+ */
+ while (*file->lastok != '"' && token != '\n')
+ token = lex_token(file);
+ if (token == '\n')
+ return error(file, ERROR_PARSE, "Invalid use of include preprocessor directive: wanted #include \"file.h\"\n");
+
+ copy = util_strdup(file->lastok);
+ next = lex_include(file, copy);
+
+ if (!next) {
+ error(file, ERROR_INTERNAL, "Include subsystem failure\n");
+ exit (-1);
+ }
+ /* constant */
+ {
+ constant c;
+ c.name = "#include",
+ c.type = TYPE_VOID,
+ c.value[0] = 0;
+ c.value[1] = 0;
+ c.value[2] = 0;
+ c.string = copy;
+ compile_constants_add(c);
+ }
+ parse_gen(next);
+ mem_d (copy);
+ lex_close(next);
+ }
+ /* skip all tokens to end of directive */
+ while (token != '\n')
+ token = lex_token(file);
+ break;
+
+ case LEX_IDENT:
+ token = lex_token(file);
+ break;
+ }
+ }
+ compile_constant_debug();
+ lex_reset(file);
+ /* free constants */
+ {
+ size_t i = 0;
+ for (; i < compile_constants_elements; i++) {
+ mem_d(compile_constants_data[i].name);
+ mem_d(compile_constants_data[i].string);
+ }
+ mem_d(compile_constants_data);
+ }
+ return 1;
+}