Cleanups

[xonotic/gmqcc.git] / parse.c

diff --git a/parse.c b/parse.c
index 4927013214b6b054a9991589577ce2adce5a3acd..0e1c6a511d84473c70187ebbd7cc0fa2f5e4f012 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -151,13 +151,15 @@ void parse_debug(struct parsenode *tree) {
 }
 
 /*
- * This just skips the token and throws it in the parse tree for later
- * checking / optimization / codegen, it doesn't do anything with it
- * like syntax check for legal use -- like it should as it's a TODO item
- * which is not implemented
+ * Performs a parse operation:  This is a macro to prevent bugs, if the
+ * calls to lex_token are'nt exactly enough to feed to the end of the
+ * actual lexees for the current thing that is being parsed, the state 
+ * of the next iteration in the creation of the parse tree will be wrong
+ * and everything will fail.
  */
-#define PARSE_TODO(X) {          \
+#define PARSE_PERFORM(X,C) {     \
        token = lex_token(file);     \
+       { C }                        \
        while (token != '\n') {      \
                token = lex_token(file); \
        }                            \
@@ -178,7 +180,11 @@ void parse_clear(struct parsenode *tree) {
        typedef_clear();
 }
 
-int parse(struct lex_file *file) {
+/*
+ * Generates a parse tree out of the lexees generated by the lexer.  This
+ * is where the tree is built.  This is where valid check is performed.
+ */
+int parse_tree(struct lex_file *file) {
        struct parsenode *parsetree = NULL;
        struct parsenode *parseroot = NULL;
        
@@ -203,29 +209,19 @@ int parse(struct lex_file *file) {
                    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);
+                               //token = lex_token(file);
                                while ((token == ' ' || token == '\n') && file->length >= 0)
                                        token = lex_token(file);
-                                       
-                               //PARSE_TREE_ADD(PARSE_TYPE_FOR);
-                               PARSE_TODO(PARSE_TYPE_FOR);
+                               PARSE_TREE_ADD(PARSE_TYPE_FOR);
                                break;
                        
                        /*
@@ -243,9 +239,6 @@ int parse(struct lex_file *file) {
                                
                                typedef_add(f, t);
                                
-                               /* free stdup strings */
-                               //mem_d(f);
-                               //mem_d(t);
                                free(f);
                                free(t);
                                
@@ -253,19 +246,27 @@ int parse(struct lex_file *file) {
                                        token = lex_token(file);
                                break;
                        }
+                       
+                       /*
+                        * Returns are addable as-is, statement checking is during
+                        * the actual parse tree check.
+                        */
+                       case TOKEN_RETURN:
+                               PARSE_TREE_ADD(PARSE_TYPE_RETURN);
+                               break;
+                               //PARSE_PERFORM(PARSE_TYPE_RETURN,  {});
+                       
                                
-                               
-                       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);
+                       case TOKEN_DO:        PARSE_PERFORM(PARSE_TYPE_DO,      {});
+                       case TOKEN_WHILE:     PARSE_PERFORM(PARSE_TYPE_WHILE,   {});
+                       case TOKEN_BREAK:     PARSE_PERFORM(PARSE_TYPE_BREAK,   {});
+                       case TOKEN_CONTINUE:  PARSE_PERFORM(PARSE_TYPE_CONTINUE,{});
+                       case TOKEN_GOTO:      PARSE_PERFORM(PARSE_TYPE_GOTO,    {});
+                       case TOKEN_VOID:      PARSE_PERFORM(PARSE_TYPE_VOID,    {});
+                       case TOKEN_STRING:    PARSE_PERFORM(PARSE_TYPE_STRING,  {});
+                       case TOKEN_FLOAT:     PARSE_PERFORM(PARSE_TYPE_FLOAT,   {});
+                       case TOKEN_VECTOR:    PARSE_PERFORM(PARSE_TYPE_VECTOR,  {});
+                       case TOKEN_ENTITY:    PARSE_PERFORM(PARSE_TYPE_ENTITY,  {});
                                
                        /*
                         * From here down is all language punctuation:  There is no
@@ -392,6 +393,5 @@ int parse(struct lex_file *file) {
        parse_debug(parseroot);
        lex_reset(file);
        parse_clear(parseroot);
-       
        return 1;
 }