darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2024-11-23 20:33:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
Wolfgang Bumiller 2012-04-28 10:42:03 +02:00
parent e74ecabedd
commit da827e6098
5 changed files with 58 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ast.c
View file

@ -89,7 +89,7 @@ void ast_value_delete(ast_value* self)
if (self->isconst) { if (self->isconst) {
switch (self->vtype) switch (self->vtype)
{ {
case qc_string: case TYPE_STRING:
mem_d((void*)self->constval.vstring); mem_d((void*)self->constval.vstring);
break; break;
/* NOTE: delete function? currently collected in /* NOTE: delete function? currently collected in

16
astir.h
View file

@ -134,22 +134,6 @@ MEM_VEC_FUNCTIONS(Tself, Twhat, mem) \
_MEM_VEC_FUN_CLEAR(Tself, mem) \ _MEM_VEC_FUN_CLEAR(Tself, mem) \
_MEM_VEC_FUN_FIND(Tself, Twhat, 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 { enum store_types {
store_global, store_global,
store_local, /* local, assignable for now, should get promoted later */ store_local, /* local, assignable for now, should get promoted later */

4
gmqcc.h
View file

@ -276,7 +276,9 @@ enum {
TYPE_ENTITY , TYPE_ENTITY ,
TYPE_FIELD , TYPE_FIELD ,
TYPE_FUNCTION , TYPE_FUNCTION ,
TYPE_POINTER TYPE_POINTER ,
/* TYPE_INTEGER , */
TYPE_VARIANT ,
}; };
/* /*

102
ir.c
View file

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

2
ir.h
View file

@ -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) MEM_VECTOR_PROTO_ALL(ir_value, struct ir_instr_s*, writes)
bool GMQCC_WARN ir_value_set_float(ir_value*, float f); bool GMQCC_WARN ir_value_set_float(ir_value*, float f);
#if 0
bool GMQCC_WARN ir_value_set_int(ir_value*, int i); 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_string(ir_value*, const char *s);
bool GMQCC_WARN ir_value_set_vector(ir_value*, vector_t v); bool GMQCC_WARN ir_value_set_vector(ir_value*, vector_t v);
/*bool ir_value_set_pointer_v(ir_value*, ir_value* p); */ /*bool ir_value_set_pointer_v(ir_value*, ir_value* p); */