Removed the qc_type enum and replaced all qc_* by TYPE_*

diff --git a/ast.c b/ast.c
index 35e72eb6dfea051c4540ba7f03dfc1a936d499e9..3639168c5b9ef3105490856404fdd22c33a2e4a7 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -89,7 +89,7 @@ void ast_value_delete(ast_value* self)
     if (self->isconst) {
         switch (self->vtype)
         {
-        case qc_string:
+        case TYPE_STRING:
             mem_d((void*)self->constval.vstring);
             break;
         /* NOTE: delete function? currently collected in

diff --git a/astir.h b/astir.h
index 05700694d5e287c27114ce2d3910c4e7d625b651..dff1bdc36f9ca50722dd88b7c9cbb842596ef5d3 100644 (file)
--- a/astir.h
+++ b/astir.h
@@ -134,22 +134,6 @@ MEM_VEC_FUNCTIONS(Tself, Twhat, mem)             \
 _MEM_VEC_FUN_CLEAR(Tself, mem)                   \
 _MEM_VEC_FUN_FIND(Tself, Twhat, mem)
 
-enum qc_types {
-    /* Main QC types */
-    qc_void,
-    qc_float,
-    qc_vector,
-    qc_entity,
-    qc_string,
-
-    qc_int,
-
-    /* "virtual" and internal types */
-    qc_pointer,
-    qc_variant, /* eg. OFS_RETURN/PARAM... */
-    qc_function,
-};
-
 enum store_types {
     store_global,
     store_local,  /* local, assignable for now, should get promoted later */

diff --git a/gmqcc.h b/gmqcc.h
index 2b92f8b4c6625a411413d32e7a5406fbd61d1d58..2e49982e08a05ad8ec10752ade17057a851caa21 100644 (file)
--- a/gmqcc.h
+++ b/gmqcc.h
@@ -276,7 +276,9 @@ enum {
     TYPE_ENTITY   ,
     TYPE_FIELD    ,
     TYPE_FUNCTION ,
-    TYPE_POINTER
+    TYPE_POINTER  ,
+    /* TYPE_INTEGER  , */
+    TYPE_VARIANT  ,
 };
 
 /*

diff --git a/ir.c b/ir.c
index 7bb1f6d7c4af7b3ab96c4cb6534783dc00b05d11..0bfa8d7b4bc905e78586b7cdaa63127da4d90a1a 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -45,7 +45,7 @@ ir_builder* ir_builder_new(const char *modulename)
     /* globals which always exist */
 
     /* for now we give it a vector size */
-    ir_builder_create_global(self, "OFS_RETURN", qc_variant);
+    ir_builder_create_global(self, "OFS_RETURN", TYPE_VARIANT);
 
     return self;
 }
@@ -147,7 +147,7 @@ ir_function* ir_function_new(ir_builder* owner)
     self->owner = owner;
     self->context.file = "<@no context>";
     self->context.line = 0;
-    self->retype = qc_void;
+    self->retype = TYPE_VOID;
     MEM_VECTOR_INIT(self, params);
     MEM_VECTOR_INIT(self, blocks);
     MEM_VECTOR_INIT(self, values);
@@ -414,7 +414,7 @@ void ir_value_delete(ir_value* self)
     mem_d((void*)self->name);
     if (self->isconst)
     {
-        if (self->vtype == qc_string)
+        if (self->vtype == TYPE_STRING)
             mem_d((void*)self->constval.vstring);
     }
     MEM_VECTOR_CLEAR(self, reads);
@@ -432,7 +432,7 @@ void ir_value_set_name(ir_value *self, const char *name)
 
 bool ir_value_set_float(ir_value *self, float f)
 {
-    if (self->vtype != qc_float)
+    if (self->vtype != TYPE_FLOAT)
         return false;
     self->constval.vfloat = f;
     self->isconst = true;
@@ -441,7 +441,7 @@ bool ir_value_set_float(ir_value *self, float f)
 
 bool ir_value_set_vector(ir_value *self, vector_t v)
 {
-    if (self->vtype != qc_vector)
+    if (self->vtype != TYPE_VECTOR)
         return false;
     self->constval.vvec = v;
     self->isconst = true;
@@ -450,21 +450,23 @@ bool ir_value_set_vector(ir_value *self, vector_t v)
 
 bool ir_value_set_string(ir_value *self, const char *str)
 {
-    if (self->vtype != qc_string)
+    if (self->vtype != TYPE_STRING)
         return false;
     self->constval.vstring = util_strdup(str);
     self->isconst = true;
     return true;
 }
 
+#if 0
 bool ir_value_set_int(ir_value *self, int i)
 {
-    if (self->vtype != qc_int)
+    if (self->vtype != TYPE_INTEGER)
         return false;
     self->constval.vint = i;
     self->isconst = true;
     return true;
 }
+#endif
 
 bool ir_value_lives(ir_value *self, size_t at)
 {
@@ -582,38 +584,38 @@ bool ir_block_create_store(ir_block *self, ir_value *target, ir_value *what)
 {
     int op = 0;
     int vtype;
-    if (target->vtype == qc_variant)
+    if (target->vtype == TYPE_VARIANT)
         vtype = what->vtype;
     else
         vtype = target->vtype;
 
     switch (vtype) {
-        case qc_float:
+        case TYPE_FLOAT:
 #if 0
-            if (what->vtype == qc_int)
+            if (what->vtype == TYPE_INTEGER)
                 op = INSTR_CONV_ITOF;
             else
 #endif
                 op = INSTR_STORE_F;
             break;
-        case qc_vector:
+        case TYPE_VECTOR:
             op = INSTR_STORE_V;
             break;
-        case qc_entity:
+        case TYPE_ENTITY:
             op = INSTR_STORE_ENT;
             break;
-        case qc_string:
+        case TYPE_STRING:
             op = INSTR_STORE_S;
             break;
 #if 0
-        case qc_int:
-            if (what->vtype == qc_int)
+        case TYPE_INTEGER:
+            if (what->vtype == TYPE_INTEGER)
                 op = INSTR_CONV_FTOI;
             else
                 op = INSTR_STORE_I;
             break;
 #endif
-        case qc_pointer:
+        case TYPE_POINTER:
 #if 0
             op = INSTR_STORE_I;
 #else
@@ -654,7 +656,7 @@ bool ir_block_create_if(ir_block *self, ir_value *v,
         return false;
     }
     self->final = true;
-    //in = ir_instr_new(self, (v->vtype == qc_string ? INSTR_IF_S : INSTR_IF_F));
+    //in = ir_instr_new(self, (v->vtype == TYPE_STRING ? INSTR_IF_S : INSTR_IF_F));
     in = ir_instr_new(self, VINSTR_COND);
     if (!in)
         return false;
@@ -783,7 +785,7 @@ ir_value* ir_block_create_binop(ir_block *self,
                                 const char *label, int opcode,
                                 ir_value *left, ir_value *right)
 {
-    int ot = qc_void;
+    int ot = TYPE_VOID;
     switch (opcode) {
         case INSTR_ADD_F:
         case INSTR_SUB_F:
@@ -815,7 +817,7 @@ ir_value* ir_block_create_binop(ir_block *self,
         case INSTR_EQ_I:
         case INSTR_NE_I:
 #endif
-            ot = qc_float;
+            ot = TYPE_FLOAT;
             break;
 #if 0
         case INSTR_ADD_I:
@@ -831,7 +833,7 @@ ir_value* ir_block_create_binop(ir_block *self,
         case INSTR_XOR_I:
         case INSTR_RSHIFT_I:
         case INSTR_LSHIFT_I:
-            ot = qc_int;
+            ot = TYPE_INTEGER;
             break;
 #endif
         case INSTR_ADD_V:
@@ -843,27 +845,27 @@ ir_value* ir_block_create_binop(ir_block *self,
         case INSTR_MUL_IV:
         case INSTR_MUL_VI:
 #endif
-            ot = qc_vector;
+            ot = TYPE_VECTOR;
             break;
 #if 0
         case INSTR_ADD_SF:
-            ot = qc_pointer;
+            ot = TYPE_POINTER;
             break;
 #endif
         default:
             // ranges:
             /* boolean operations result in floats */
             if (opcode >= INSTR_EQ_F && opcode <= INSTR_GT)
-                ot = qc_float;
+                ot = TYPE_FLOAT;
             else if (opcode >= INSTR_LE && opcode <= INSTR_GT)
-                ot = qc_float;
+                ot = TYPE_FLOAT;
 #if 0
             else if (opcode >= INSTR_LE_I && opcode <= INSTR_EQ_FI)
-                ot = qc_float;
+                ot = TYPE_FLOAT;
 #endif
             break;
     };
-    if (ot == qc_void) {
+    if (ot == TYPE_VOID) {
         /* The AST or parser were supposed to check this! */
         return NULL;
     }
@@ -906,23 +908,23 @@ ir_value* ir_block_create_add(ir_block *self,
         switch (l) {
             default:
                 return NULL;
-            case qc_float:
+            case TYPE_FLOAT:
                 op = INSTR_ADD_F;
                 break;
 #if 0
-            case qc_int:
+            case TYPE_INTEGER:
                 op = INSTR_ADD_I;
                 break;
 #endif
-            case qc_vector:
+            case TYPE_VECTOR:
                 op = INSTR_ADD_V;
                 break;
         }
     } else {
 #if 0
-        if ( (l == qc_float && r == qc_int) )
+        if ( (l == TYPE_FLOAT && r == TYPE_INTEGER) )
             op = INSTR_ADD_FI;
-        else if ( (l == qc_int && r == qc_float) )
+        else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) )
             op = INSTR_ADD_IF;
         else
 #endif
@@ -943,23 +945,23 @@ ir_value* ir_block_create_sub(ir_block *self,
         switch (l) {
             default:
                 return NULL;
-            case qc_float:
+            case TYPE_FLOAT:
                 op = INSTR_SUB_F;
                 break;
 #if 0
-            case qc_int:
+            case TYPE_INTEGER:
                 op = INSTR_SUB_I;
                 break;
 #endif
-            case qc_vector:
+            case TYPE_VECTOR:
                 op = INSTR_SUB_V;
                 break;
         }
     } else {
 #if 0
-        if ( (l == qc_float && r == qc_int) )
+        if ( (l == TYPE_FLOAT && r == TYPE_INTEGER) )
             op = INSTR_SUB_FI;
-        else if ( (l == qc_int && r == qc_float) )
+        else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) )
             op = INSTR_SUB_IF;
         else
 #endif
@@ -980,31 +982,31 @@ ir_value* ir_block_create_mul(ir_block *self,
         switch (l) {
             default:
                 return NULL;
-            case qc_float:
+            case TYPE_FLOAT:
                 op = INSTR_MUL_F;
                 break;
 #if 0
-            case qc_int:
+            case TYPE_INTEGER:
                 op = INSTR_MUL_I;
                 break;
 #endif
-            case qc_vector:
+            case TYPE_VECTOR:
                 op = INSTR_MUL_V;
                 break;
         }
     } else {
-        if ( (l == qc_vector && r == qc_float) )
+        if ( (l == TYPE_VECTOR && r == TYPE_FLOAT) )
             op = INSTR_MUL_VF;
-        else if ( (l == qc_float && r == qc_vector) )
+        else if ( (l == TYPE_FLOAT && r == TYPE_VECTOR) )
             op = INSTR_MUL_FV;
 #if 0
-        else if ( (l == qc_vector && r == qc_int) )
+        else if ( (l == TYPE_VECTOR && r == TYPE_INTEGER) )
             op = INSTR_MUL_VI;
-        else if ( (l == qc_int && r == qc_vector) )
+        else if ( (l == TYPE_INTEGER && r == TYPE_VECTOR) )
             op = INSTR_MUL_IV;
-        else if ( (l == qc_float && r == qc_int) )
+        else if ( (l == TYPE_FLOAT && r == TYPE_INTEGER) )
             op = INSTR_MUL_FI;
-        else if ( (l == qc_int && r == qc_float) )
+        else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) )
             op = INSTR_MUL_IF;
 #endif
         else
@@ -1025,22 +1027,22 @@ ir_value* ir_block_create_div(ir_block *self,
         switch (l) {
             default:
                 return NULL;
-            case qc_float:
+            case TYPE_FLOAT:
                 op = INSTR_DIV_F;
                 break;
 #if 0
-            case qc_int:
+            case TYPE_INTEGER:
                 op = INSTR_DIV_I;
                 break;
 #endif
         }
     } else {
 #if 0
-        if ( (l == qc_vector && r == qc_float) )
+        if ( (l == TYPE_VECTOR && r == TYPE_FLOAT) )
             op = INSTR_DIV_VF;
-        else if ( (l == qc_float && r == qc_int) )
+        else if ( (l == TYPE_FLOAT && r == TYPE_INTEGER) )
             op = INSTR_DIV_FI;
-        else if ( (l == qc_int && r == qc_float) )
+        else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) )
             op = INSTR_DIV_IF;
         else
 #endif

diff --git a/ir.h b/ir.h
index 49b337039efa87591190ef7a7e4748152ca161b6..c51bc84eb24648be8ddcdf8c067576acc519bcec 100644 (file)
--- a/ir.h
+++ b/ir.h
@@ -71,7 +71,9 @@ MEM_VECTOR_PROTO_ALL(ir_value, struct ir_instr_s*, reads)
 MEM_VECTOR_PROTO_ALL(ir_value, struct ir_instr_s*, writes)
 
 bool GMQCC_WARN ir_value_set_float(ir_value*, float f);
+#if 0
 bool GMQCC_WARN ir_value_set_int(ir_value*, int i);
+#endif
 bool GMQCC_WARN ir_value_set_string(ir_value*, const char *s);
 bool GMQCC_WARN ir_value_set_vector(ir_value*, vector_t v);
 /*bool   ir_value_set_pointer_v(ir_value*, ir_value* p); */