Updated language and started scanner.

src/SQL.c

@@ -5,27 +5,66 @@
 #include <malloc.h>
 #include "SQL.h"
 
-T_Value *new_t_value() {
-    T_Value *value = malloc(sizeof(T_Value));
+Value *new_value() {
+    Value *value = malloc(sizeof(Value));
     value->number = 0;
     value->string = NULL;
     return value;
 }
 
-void free_t_value(T_Value *value) {
+void free_value(Value *value) {
     if (value->string != NULL) {
         free(value->string);
     }
     free(value);
 }
 
-T_Assignment *new_t_assignment() {
-    T_Assignment *assignment = malloc(sizeof(T_Assignment));
+Comparison *new_comparison() {
+    Comparison* comparison = malloc(sizeof(Comparison));
+    comparison->identifier = NULL;
+    comparison->value = NULL;
+    comparison->comp = COMP_NONE;
+    return comparison;
+}
+void free_comparison(Comparison *comparison) {
+    if (comparison->value != NULL) {
+        free(comparison->value);
+    }
+    if(comparison->identifier != NULL) {
+        free(comparison->identifier);
+    }
+    free(comparison);
+}
+
+ComparisonGroup *new_comparision_group() {
+    ComparisonGroup *group = malloc(sizeof(ComparisonGroup));
+    group->comparisons = NULL;
+    group->length = 0;
+    return group;
+}
+void free_comparison_group(ComparisonGroup* group) {
+    if (group->length > 0) {
+        for(size_t i=0; i<group->length; i++) {
+            free(group->comparisons[i]);
+        }
+        free(group->comparisons);
+        group->length = 0;
+    }
+    free(group);
+}
+void append_comparison_group(ComparisonGroup *group, Comparison *comparison) {
+    group->length++;
+    group->comparisons = realloc(group->comparisons, sizeof(Assignment) * group->length);
+    group->comparisons[group->length - 1] = comparison;
+}
+
+Assignment *new_assignment() {
+    Assignment *assignment = malloc(sizeof(Assignment));
     assignment->value = NULL;
     assignment->identifier = NULL;
 }
 
-void free_t_assignment(T_Assignment *assignment) {
+void free_assignment(Assignment *assignment) {
     if (assignment->identifier != NULL) {
         free(assignment->identifier);
     }
@@ -35,17 +74,17 @@ void free_t_assignment(T_Assignment *assignment) {
     free(assignment);
 }
 
-T_AssignmentList *new_t_assignment_list() {
-    T_AssignmentList *assignmentList = malloc(sizeof(T_AssignmentList));
+AssignmentList *new_assignment_list() {
+    AssignmentList *assignmentList = malloc(sizeof(AssignmentList));
     assignmentList->assignments = NULL;
     assignmentList->length = 0;
     return assignmentList;
 }
 
-void free_t_assignment_list(T_AssignmentList *assignmentList) {
+void free_assignment_list(AssignmentList *assignmentList) {
     if (assignmentList->length > 0) {
         for (size_t i = 0; i < assignmentList->length; i++) {
-            free_t_assignment(assignmentList->assignments[i]);
+            free_assignment(assignmentList->assignments[i]);
         }
         free(assignmentList->assignments);
         assignmentList->length = 0;
@@ -53,20 +92,20 @@ void free_t_assignment_list(T_AssignmentList *assignmentList) {
     free(assignmentList);
 }
 
-void append_t_assignment_list(T_AssignmentList *list, T_Assignment *assignment) {
+void append_assignment_list(AssignmentList *list, Assignment *assignment) {
     list->length++;
-    list->assignments = realloc(list->assignments, sizeof(T_Assignment) * list->length);
+    list->assignments = realloc(list->assignments, sizeof(Assignment) * list->length);
     list->assignments[list->length - 1] = assignment;
 }
 
-T_FieldList *new_t_field_list() {
-    T_FieldList *list = malloc(sizeof(T_FieldList));
+FieldList *new_field_list() {
+    FieldList *list = malloc(sizeof(FieldList));
     list->length = 0;
     list->fields = NULL;
     return list;
 }
 
-void free_t_field_list(T_FieldList *list) {
+void free_field_list(FieldList *list) {
     if (list->length > 0) {
         for (size_t i = 0; i < list->length; i++) {
             free(list->fields[i]);
@@ -78,14 +117,14 @@ void free_t_field_list(T_FieldList *list) {
     free(list);
 }
 
-void append_t_field_list(T_FieldList *list, char *field) {
+void append_field_list(FieldList *list, char *field) {
     list->length++;
     list->fields = realloc(list->fields, sizeof(char *) * list->length);
     list->fields[list->length - 1] = field;
 }
 
-T_ColumnSpec *new_t_column_spec() {
-    T_ColumnSpec *spec = malloc(sizeof(T_ColumnSpec));
+ColumnSpec *new_column_spec() {
+    ColumnSpec *spec = malloc(sizeof(ColumnSpec));
     spec->identifier = NULL;
     spec->option = COLOPT_NONE;
     spec->size = 0;
@@ -93,24 +132,24 @@ T_ColumnSpec *new_t_column_spec() {
     return spec;
 }
 
-void free_t_column_spec(T_ColumnSpec *spec) {
+void free_column_spec(ColumnSpec *spec) {
     if (spec->identifier != NULL) {
         free(spec->identifier);
     }
     free(spec);
 }
 
-T_ColumnSpecList *new_t_column_spec_list() {
-    T_ColumnSpecList *list = malloc(sizeof(T_ColumnSpecList));
+ColumnSpecList *new_column_spec_list() {
+    ColumnSpecList *list = malloc(sizeof(ColumnSpecList));
     list->length = 0;
     list->columns = NULL;
     return list;
 }
 
-void free_t_column_spec_list(T_ColumnSpecList *list) {
+void free_column_spec_list(ColumnSpecList *list) {
     if (list->length > 0) {
         for (size_t i = 0; i < list->length; i++) {
-            free_t_column_spec(list->columns[i]);
+            free_column_spec(list->columns[i]);
         }
         free(list->columns);
         list->columns = NULL;
@@ -119,43 +158,43 @@ void free_t_column_spec_list(T_ColumnSpecList *list) {
     free(list);
 }
 
-void append_t_column_spec_list(T_ColumnSpecList *list, T_ColumnSpec *spec) {
+void append_column_spec_list(ColumnSpecList *list, ColumnSpec *spec) {
     list->length++;
-    list->columns = realloc(list->columns, sizeof(T_ColumnSpec) * list->length);
+    list->columns = realloc(list->columns, sizeof(ColumnSpec) * list->length);
     list->columns[list->length - 1] = spec;
 }
 
-T_SelectStmt *new_t_select_stmt() {
-    T_SelectStmt *stmt = malloc(sizeof(T_SelectStmt));
+SelectStmt *new_select_stmt() {
+    SelectStmt *stmt = malloc(sizeof(SelectStmt));
     stmt->fields = NULL;
     stmt->tableName = NULL;
     stmt->where = NULL;
     return stmt;
 }
 
-void free_t_select_stmt(T_SelectStmt *stmt) {
+void free_select_stmt(SelectStmt *stmt) {
     if (stmt->where != NULL) {
-        free_t_assignment_list(stmt->where);
+        free_assignment_list(stmt->where);
     }
     if (stmt->tableName != NULL) {
         free(stmt->tableName);
     }
     if (stmt->fields != NULL) {
-        free_t_field_list(stmt->fields);
+        free_field_list(stmt->fields);
     }
     free(stmt);
 }
 
-T_InsertStmt *new_t_insert_stmt() {
-    T_InsertStmt *stmt = malloc(sizeof(T_InsertStmt));
+InsertStmt *new_insert_stmt() {
+    InsertStmt *stmt = malloc(sizeof(InsertStmt));
     stmt->tableName = NULL;
     stmt->values = NULL;
     return stmt;
 }
 
-void free_t_insert_stmt(T_InsertStmt *stmt) {
+void free_insert_stmt(InsertStmt *stmt) {
     if (stmt->values != NULL) {
-        free_t_assignment_list(stmt->values);
+        free_assignment_list(stmt->values);
     }
     if (stmt->tableName != NULL) {
         free(stmt->tableName);
@@ -163,99 +202,99 @@ void free_t_insert_stmt(T_InsertStmt *stmt) {
     free(stmt);
 }
 
-T_UpdateStmt *new_t_update_stmt() {
-    T_UpdateStmt *stmt = malloc(sizeof(T_UpdateStmt));
+UpdateStmt *new_update_stmt() {
+    UpdateStmt *stmt = malloc(sizeof(UpdateStmt));
     stmt->tableName = NULL;
     stmt->values = NULL;
     stmt->where = NULL;
     return stmt;
 }
 
-void free_t_update_stmt(T_UpdateStmt *stmt) {
+void free_update_stmt(UpdateStmt *stmt) {
     if (stmt->tableName != NULL) {
         free(stmt->tableName);
     }
     if (stmt->where != NULL) {
-        free_t_assignment_list(stmt->where);
+        free_assignment_list(stmt->where);
     }
     if (stmt->values != NULL) {
-        free_t_assignment_list(stmt->values);
+        free_assignment_list(stmt->values);
     }
     free(stmt);
 }
 
-T_DeleteStmt *new_t_delete_stmt() {
-    T_DeleteStmt *stmt = malloc(sizeof(T_DeleteStmt));
+DeleteStmt *new_delete_stmt() {
+    DeleteStmt *stmt = malloc(sizeof(DeleteStmt));
     stmt->tableName = NULL;
     stmt->where = NULL;
 }
 
-void free_t_delete_stmt(T_DeleteStmt *stmt) {
+void free_delete_stmt(DeleteStmt *stmt) {
     if (stmt->tableName != NULL) {
         free(stmt->tableName);
     }
     if (stmt->where != NULL) {
-        free_t_assignment_list(stmt->where);
+        free_assignment_list(stmt->where);
     }
     free(stmt);
 }
 
-T_CreateStmt *new_t_create_stmt() {
-    T_CreateStmt *spec = malloc(sizeof(T_CreateStmt));
+CreateStmt *new_create_stmt() {
+    CreateStmt *spec = malloc(sizeof(CreateStmt));
     spec->tableName = NULL;
     spec->columns = NULL;
     return spec;
 }
 
-void free_t_create_stmt(T_CreateStmt *spec) {
+void free_create_stmt(CreateStmt *spec) {
     if (spec->tableName != NULL) {
         free(spec->tableName);
     }
     if (spec->columns != NULL) {
-        free_t_column_spec_list(spec->columns);
+        free_column_spec_list(spec->columns);
     }
     free(spec);
 }
 
-T_DropStmt *new_t_drop_stmt() {
-    T_DropStmt *stmt = malloc(sizeof(T_DropStmt));
+DropStmt *new_drop_stmt() {
+    DropStmt *stmt = malloc(sizeof(DropStmt));
     stmt->tableName = NULL;
     return stmt;
 }
 
-void free_t_drop_stmt(T_DropStmt *stmt) {
+void free_drop_stmt(DropStmt *stmt) {
     if (stmt->tableName != NULL) {
         free(stmt->tableName);
     }
     free(stmt);
 }
 
-T_Statement *new_t_statement() {
-    T_Statement *stmt = malloc(sizeof(T_Statement));
+Statement *new_statement() {
+    Statement *stmt = malloc(sizeof(Statement));
     stmt->type = STMT_NONE;
     stmt->stmt = NULL;
     return stmt;
 }
 
-void free_t_statement(T_Statement *stmt) {
+void free_statement(Statement *stmt) {
     switch (stmt->type) {
         case STMT_SELECT:
-            free_t_select_stmt(stmt->stmt);
+            free_select_stmt(stmt->stmt);
             break;
         case STMT_INSERT:
-            free_t_insert_stmt(stmt->stmt);
+            free_insert_stmt(stmt->stmt);
             break;
         case STMT_UPDATE:
-            free_t_update_stmt(stmt->stmt);
+            free_update_stmt(stmt->stmt);
             break;
         case STMT_DELETE:
-            free_t_delete_stmt(stmt->stmt);
+            free_delete_stmt(stmt->stmt);
             break;
         case STMT_CREATE:
-            free_t_create_stmt(stmt->stmt);
+            free_create_stmt(stmt->stmt);
             break;
         case STMT_DROP:
-            free_t_drop_stmt(stmt->stmt);
+            free_drop_stmt(stmt->stmt);
             break;
         default:
             break;
@@ -265,17 +304,17 @@ void free_t_statement(T_Statement *stmt) {
     free(stmt);
 }
 
-T_StatementList *new_t_statement_list() {
-    T_StatementList *list = malloc(sizeof(T_StatementList));
+StatementList *new_statement_list() {
+    StatementList *list = malloc(sizeof(StatementList));
     list->length = 0;
     list->statements = NULL;
     return list;
 }
 
-void free_t_statement_list(T_StatementList *list) {
+void free_statement_list(StatementList *list) {
     if (list->length > 0) {
         for (size_t i = 0; i < list->length; i++) {
-            free_t_statement(list->statements[i]);
+            free_statement(list->statements[i]);
         }
         free(list->statements);
         list->statements = NULL;
@@ -284,8 +323,8 @@ void free_t_statement_list(T_StatementList *list) {
     free(list);
 }
 
-void append_t_statement_list(T_StatementList *list, T_Statement *statement) {
+void append_statement_list(StatementList *list, Statement *statement) {
     list->length++;
-    list->statements = realloc(list->statements, sizeof(T_Statement) * list->length);
+    list->statements = realloc(list->statements, sizeof(Statement) * list->length);
     list->statements[list->length - 1] = statement;
 }