darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-04-04 17:01:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

tempcommitting a whole bunch of to-c++ conversions

Browse source
This commit is contained in:
Wolfgang Bumiller 2015-05-02 09:48:24 +02:00
parent a9ac6987a6
commit ee3c1e43c9
4 changed files with 456 additions and 458 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
ast.cpp
View file

@ -1041,15 +1041,15 @@ bool ast_value::setGlobalArray()
for (i = 0; i != count; ++i) {
switch (m_next->m_vtype) {
case TYPE_FLOAT:
if (!ir_value_set_float(m_ir_values[i], m_initlist[i].vfloat))
if (!m_ir_values[i]->setFloat(m_initlist[i].vfloat))
return false;
break;
case TYPE_VECTOR:
if (!ir_value_set_vector(m_ir_values[i], m_initlist[i].vvec))
if (!m_ir_values[i]->setVector(m_initlist[i].vvec))
return false;
break;
case TYPE_STRING:
if (!ir_value_set_string(m_ir_values[i], m_initlist[i].vstring))
if (!m_ir_values[i]->setString(m_initlist[i].vstring))
return false;
break;
case TYPE_ARRAY:
@ -1069,7 +1069,7 @@ bool ast_value::setGlobalArray()
compile_error(m_context, "field constant generated before its field");
return false;
}
if (!ir_value_set_field(m_ir_values[i], m_initlist[i].vfield->m_ir_v))
if (!m_ir_values[i]->setField(m_initlist[i].vfield->m_ir_v))
return false;
break;
default:
@ -1115,9 +1115,9 @@ bool ast_value::generateGlobal(ir_builder *ir, bool isfield)
} else {
// Arrays don't do this since there's no "array" value which spans across the
// whole thing.
v = ir_builder_create_global(ir, m_name, m_vtype);
v = ir->createGlobal(m_name, m_vtype);
if (!v) {
compile_error(m_context, "ir_builder_create_global failed on `%s`", m_name);
compile_error(m_context, "ir_builder::createGlobal failed on `%s`", m_name);
return false;
}
codegen_output_type(this, v);
@ -1138,15 +1138,15 @@ bool ast_value::generateGlobal(ir_builder *ir, bool isfield)
switch (m_vtype)
{
case TYPE_FLOAT:
if (!ir_value_set_float(v, m_constval.vfloat))
if (!v->setFloat(m_constval.vfloat))
return false;
break;
case TYPE_VECTOR:
if (!ir_value_set_vector(v, m_constval.vvec))
if (!v->setVector(m_constval.vvec))
return false;
break;
case TYPE_STRING:
if (!ir_value_set_string(v, m_constval.vstring))
if (!v->setString(m_constval.vstring))
return false;
break;
case TYPE_ARRAY:
@ -1168,7 +1168,7 @@ bool ast_value::generateGlobal(ir_builder *ir, bool isfield)
compile_error(m_context, "field constant generated before its field");
return false;
}
if (!ir_value_set_field(v, m_constval.vfield->m_ir_v))
if (!v->setField(m_constval.vfield->m_ir_v))
return false;
break;
default:
@ -1182,7 +1182,7 @@ bool ast_value::generateGlobal(ir_builder *ir, bool isfield)
bool ast_value::generateGlobalFunction(ir_builder *ir)
{
ir_function *func = ir_builder_create_function(ir, m_name, m_next->m_vtype);
ir_function *func = ir->createFunction(m_name, m_next->m_vtype);
if (!func)
return false;
func->m_context = m_context;
@ -1222,9 +1222,9 @@ bool ast_value::generateGlobalField(ir_builder *ir)
ast_expression *elemtype = array->m_next;
qc_type vtype = elemtype->m_vtype;
ir_value *v = ir_builder_create_field(ir, m_name, vtype);
ir_value *v = ir->createField(m_name, vtype);
if (!v) {
compile_error(m_context, "ir_builder_create_global failed on `%s`", m_name);
compile_error(m_context, "ir_builder::createGlobal failed on `%s`", m_name);
return false;
}
v->m_context = m_context;
@ -1245,9 +1245,9 @@ bool ast_value::generateGlobalField(ir_builder *ir)
array->m_ir_values[0] = v;
for (size_t ai = 1; ai < array->m_count; ++ai) {
util_snprintf(name.get() + namelen, 16, "[%u]", (unsigned int)ai);
array->m_ir_values[ai] = ir_builder_create_field(ir, name.get(), vtype);
array->m_ir_values[ai] = ir->createField(name.get(), vtype);
if (!array->m_ir_values[ai]) {
compile_error(m_context, "ir_builder_create_global failed on `%s`", name.get());
compile_error(m_context, "ir_builder::createGlobal failed on `%s`", name.get());
return false;
}
array->m_ir_values[ai]->m_context = m_context;
@ -1259,7 +1259,7 @@ bool ast_value::generateGlobalField(ir_builder *ir)
}
else
{
ir_value *v = ir_builder_create_field(ir, m_name, m_next->m_vtype);
ir_value *v = ir->createField(m_name, m_next->m_vtype);
if (!v)
return false;
v->m_context = m_context;
@ -1287,9 +1287,9 @@ ir_value *ast_value::prepareGlobalArray(ir_builder *ir)
if (!checkArray(*this))
return nullptr;
ir_value *v = ir_builder_create_global(ir, m_name, vtype);
ir_value *v = ir->createGlobal(m_name, vtype);
if (!v) {
compile_error(m_context, "ir_builder_create_global failed `%s`", m_name);
compile_error(m_context, "ir_builder::createGlobal failed `%s`", m_name);
return nullptr;
}
v->m_context = m_context;
@ -1309,9 +1309,9 @@ ir_value *ast_value::prepareGlobalArray(ir_builder *ir)
m_ir_values[0] = v;
for (size_t ai = 1; ai < m_count; ++ai) {
util_snprintf(name.get() + namelen, 16, "[%u]", (unsigned int)ai);
m_ir_values[ai] = ir_builder_create_global(ir, name.get(), vtype);
m_ir_values[ai] = ir->createGlobal(name.get(), vtype);
if (!m_ir_values[ai]) {
compile_error(m_context, "ir_builder_create_global failed `%s`", name.get());
compile_error(m_context, "ir_builder::createGlobal failed `%s`", name.get());
return nullptr;
}
m_ir_values[ai]->m_context = m_context;
@ -1374,7 +1374,7 @@ bool ast_value::generateLocal(ir_function *func, bool param)
util_snprintf(name.get() + namelen, 16, "[%u]", (unsigned int)ai);
m_ir_values[ai] = ir_function_create_local(func, name.get(), vtype, param);
if (!m_ir_values[ai]) {
compile_error(m_context, "internal_error: ir_builder_create_global failed on `%s`", name.get());
compile_error(m_context, "internal_error: ir_builder::createGlobal failed on `%s`", name.get());
return false;
}
m_ir_values[ai]->m_context = m_context;
@ -1397,15 +1397,15 @@ bool ast_value::generateLocal(ir_function *func, bool param)
switch (m_vtype)
{
case TYPE_FLOAT:
if (!ir_value_set_float(v, m_constval.vfloat))
if (!v->setFloat(m_constval.vfloat))
goto error;
break;
case TYPE_VECTOR:
if (!ir_value_set_vector(v, m_constval.vvec))
if (!v->setVector(m_constval.vvec))
goto error;
break;
case TYPE_STRING:
if (!ir_value_set_string(v, m_constval.vstring))
if (!v->setString(m_constval.vstring))
goto error;
break;
default:
@ -1539,7 +1539,7 @@ bool ast_function::generateFunction(ir_builder *ir)
return false;
sub = ir_block_create_binop(m_curblock, m_context,
makeLabel("va_count"), INSTR_SUB_F,
ir_builder_get_va_count(ir), fixed);
ir->get_va_count(), fixed);
if (!sub)
return false;
if (!ir_block_create_store_op(m_curblock, m_context, INSTR_STORE_F,
@ -2112,7 +2112,7 @@ bool ast_member::codegen(ast_function *func, bool lvalue, ir_value **out)
return false;
}
*out = ir_value_vector_member(vec, m_field);
*out = vec->vectorMember(m_field);
m_outl = *out;
return (*out != nullptr);
@ -3027,7 +3027,7 @@ bool ast_call::codegen(ast_function *func, bool lvalue, ir_value **out)
if (!m_va_count->codegen(func, false, &va_count))
return false;
if (!ir_block_create_store_op(func->m_curblock, m_context, INSTR_STORE_F,
ir_builder_get_va_count(builder), va_count))
builder->get_va_count(), va_count))
{
return false;
}

784
ir.cpp
View file

File diff suppressed because it is too large Load diff

66
ir.h
View file

@ -37,8 +37,30 @@ enum {
struct ir_value {
ir_value(std::string&& name, store_type storetype, qc_type vtype);
ir_value(ir_function *owner, std::string&& name, store_type storetype, qc_type vtype);
~ir_value();
ir_value *vectorMember(unsigned int member);
bool GMQCC_WARN setFloat(float);
bool GMQCC_WARN setFunc(int);
bool GMQCC_WARN setString(const char*);
bool GMQCC_WARN setVector(vec3_t);
bool GMQCC_WARN setField(ir_value*);
#if 0
bool GMQCC_WARN setInt(int);
#endif
bool lives(size_t at);
void dumpLife(int (*oprintf)(const char*, ...)) const;
void setCodeAddress(int32_t gaddr);
int32_t codeAddress() const;
bool insertLife(size_t idx, ir_life_entry_t);
bool setAlive(size_t position);
bool mergeLife(const ir_value *other);
std::string m_name;
qc_type m_vtype;
@ -81,21 +103,11 @@ struct ir_value {
bool m_callparam;
std::vector<ir_life_entry_t> m_life; // For the temp allocator
};
/*
* ir_value can be a variable, or created by an operation
* if a result of an operation: the function should store
* it to remember to delete it / garbage collect it
*/
ir_value* ir_value_vector_member(ir_value*, unsigned int member);
bool GMQCC_WARN ir_value_set_float(ir_value*, float f);
bool GMQCC_WARN ir_value_set_func(ir_value*, int f);
bool GMQCC_WARN ir_value_set_string(ir_value*, const char *s);
bool GMQCC_WARN ir_value_set_vector(ir_value*, vec3_t v);
bool GMQCC_WARN ir_value_set_field(ir_value*, ir_value *fld);
bool ir_value_lives(ir_value*, size_t);
void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...));
size_t size() const;
void dump(int (*oprintf)(const char*, ...)) const;
};
/* PHI data */
struct ir_phi_entry_t {
@ -243,6 +255,18 @@ struct ir_builder {
ir_builder(const std::string& modulename);
~ir_builder();
ir_function *createFunction(const std::string &name, qc_type outtype);
ir_value *createGlobal(const std::string &name, qc_type vtype);
ir_value *createField(const std::string &name, qc_type vtype);
ir_value *get_va_count();
bool generate(const char *filename);
void dump(int (*oprintf)(const char*, ...)) const;
ir_value *generateExtparamProto();
void generateExtparam();
ir_value *literalFloat(float value, bool add_to_list);
std::string m_name;
std::vector<std::unique_ptr<ir_function>> m_functions;
std::vector<std::unique_ptr<ir_value>> m_globals;
@ -282,14 +306,14 @@ struct ir_builder {
/* code generator */
std::unique_ptr<code_t> m_code;
};
ir_function* ir_builder_create_function(ir_builder*, const std::string& name, qc_type outtype);
ir_value* ir_builder_create_global(ir_builder*, const std::string& name, qc_type vtype);
ir_value* ir_builder_create_field(ir_builder*, const std::string& name, qc_type vtype);
ir_value* ir_builder_get_va_count(ir_builder*);
bool ir_builder_generate(ir_builder *self, const char *filename);
void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));
private:
qcint_t filestring(const char *filename);
bool generateGlobal(ir_value*, bool is_local);
bool generateGlobalFunction(ir_value*);
bool generateGlobalFunctionCode(ir_value*);
bool generateFunctionLocals(ir_value*);
};
/*
* This code assumes 32 bit floats while generating binary

10
parser.cpp
View file

@ -6215,12 +6215,12 @@ bool parser_finish(parser_t *parser, const char *output)
ast_expression *subtype;
field->m_hasvalue = true;
subtype = field->m_next;
ifld = ir_builder_create_field(ir, field->m_name, subtype->m_vtype);
ifld = ir->createField(field->m_name, subtype->m_vtype);
if (subtype->m_vtype == TYPE_FIELD)
ifld->m_fieldtype = subtype->m_next->m_vtype;
else if (subtype->m_vtype == TYPE_FUNCTION)
ifld->m_outtype = subtype->m_next->m_vtype;
(void)!ir_value_set_field(field->m_ir_v, ifld);
(void)!field->m_ir_v->setField(ifld);
}
}
for (auto &it : parser->globals) {
@ -6316,7 +6316,7 @@ bool parser_finish(parser_t *parser, const char *output)
generate_checksum(parser, ir);
if (OPTS_OPTION_BOOL(OPTION_DUMP))
ir_builder_dump(ir, con_out);
ir->dump(con_out);
for (auto &it : parser->functions) {
if (!ir_function_finalize(it->m_ir_func)) {
con_out("failed to finalize function %s\n", it->m_name.c_str());
@ -6334,9 +6334,9 @@ bool parser_finish(parser_t *parser, const char *output)
if (retval) {
if (OPTS_OPTION_BOOL(OPTION_DUMPFIN))
ir_builder_dump(ir, con_out);
ir->dump(con_out);
if (!ir_builder_generate(ir, output)) {
if (!ir->generate(output)) {
con_out("*** failed to generate output file\n");
delete ir;
return false;