}
}
- vec_push(code->statements, stmt);
- vec_push(code->linenums, (int)ctx.line);
- vec_push(code->columnnums, (int)ctx.column);
+ code->statements.push_back(stmt);
+ code->linenums.push_back(ctx.line);
+ code->columnnums.push_back(ctx.column);
}
void code_pop_statement(code_t *code)
{
- vec_pop(code->statements);
- vec_pop(code->linenums);
- vec_pop(code->columnnums);
+ code->statements.pop_back();
+ code->linenums.pop_back();
+ code->columnnums.pop_back();
}
code_t *code_init() {
* some null (empty) statements, functions, and 28 globals
*/
for(; i < 28; i++)
- vec_push(code->globals, 0);
+ code->globals.push_back(0);
- vec_push(code->chars, '\0');
- vec_push(code->functions, empty_function);
+ code->chars.push_back('\0');
+ code->functions.push_back(empty_function);
code_push_statement(code, &empty_statement, empty_ctx);
- vec_push(code->defs, empty_def);
- vec_push(code->fields, empty_def);
+ code->defs.push_back(empty_def);
+ code->fields.push_back(empty_def);
return code;
}
if (!*str) {
if (!code->string_cached_empty) {
- code->string_cached_empty = vec_size(code->chars);
- vec_push(code->chars, 0);
+ code->string_cached_empty = code->chars.size();
+ code->chars.push_back(0);
}
return code->string_cached_empty;
}
if (CODE_HASH_ENTER(existing))
return CODE_HASH_LEAVE(existing);
- CODE_HASH_LEAVE(existing) = vec_size(code->chars);
- vec_append(code->chars, strlen(str)+1, str);
+ CODE_HASH_LEAVE(existing) = code->chars.size();
+ code->chars.insert(code->chars.end(), str, str + strlen(str) + 1);
+ //vec_append(code->chars, strlen(str)+1, str);
util_htseth(code->string_cache, str, hash, CODE_HASH_ENTER(existing));
return CODE_HASH_LEAVE(existing);
size += sizeof(code_header->globals.length);
size += sizeof(code_header->fields.length);
size += sizeof(code_header->statements.length);
- size += sizeof(code->linenums[0]) * vec_size(code->linenums);
- size += sizeof(code->columnnums[0]) * vec_size(code->columnnums);
+ size += sizeof(code->linenums[0]) * code->linenums.size();
+ size += sizeof(code->columnnums[0]) * code->columnnums.size();
} else {
size += sizeof(prog_header_t);
- size += sizeof(prog_section_statement_t) * vec_size(code->statements);
- size += sizeof(prog_section_def_t) * vec_size(code->defs);
- size += sizeof(prog_section_field_t) * vec_size(code->fields);
- size += sizeof(prog_section_function_t) * vec_size(code->functions);
- size += sizeof(int32_t) * vec_size(code->globals);
- size += 1 * vec_size(code->chars);
+ size += sizeof(prog_section_statement_t) * code->statements.size();
+ size += sizeof(prog_section_def_t) * code->defs.size();
+ size += sizeof(prog_section_field_t) * code->fields.size();
+ size += sizeof(prog_section_function_t) * code->functions.size();
+ size += sizeof(int32_t) * code->globals.size();
+ size += 1 * code->chars.size();
}
return size;
}
size_t i;
code_header->statements.offset = sizeof(prog_header_t);
- code_header->statements.length = vec_size(code->statements);
- code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement_t) * vec_size(code->statements));
- code_header->defs.length = vec_size(code->defs);
- code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def_t) * vec_size(code->defs));
- code_header->fields.length = vec_size(code->fields);
- code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field_t) * vec_size(code->fields));
- code_header->functions.length = vec_size(code->functions);
- code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function_t) * vec_size(code->functions));
- code_header->globals.length = vec_size(code->globals);
- code_header->strings.offset = code_header->globals.offset + (sizeof(int32_t) * vec_size(code->globals));
- code_header->strings.length = vec_size(code->chars);
+ code_header->statements.length = code->statements.size();
+ code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement_t) * code->statements.size());
+ code_header->defs.length = code->defs.size();
+ code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def_t) * code->defs.size());
+ code_header->fields.length = code->fields.size();
+ code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field_t) * code->fields.size());
+ code_header->functions.length = code->functions.size();
+ code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function_t) * code->functions.size());
+ code_header->globals.length = code->globals.size();
+ code_header->strings.offset = code_header->globals.offset + (sizeof(int32_t) * code->globals.size());
+ code_header->strings.length = code->chars.size();
code_header->version = 6;
code_header->skip = 0;
if (OPTS_FLAG(DARKPLACES_STRING_TABLE_BUG)) {
/* >= + P */
- vec_push(code->chars, '\0'); /* > */
- vec_push(code->chars, '\0'); /* = */
- vec_push(code->chars, '\0'); /* P */
+ code->chars.push_back('\0'); /* > */
+ code->chars.push_back('\0'); /* = */
+ code->chars.push_back('\0'); /* P */
}
/* ensure all data is in LE format */
- util_swap_header(code_header);
-
- /*
- * These are not part of the header but we ensure LE format here to save on duplicated
- * code.
- */
-
- util_swap_statements (code->statements);
+ util_swap_header(*code_header);
+ util_swap_statements(code->statements);
util_swap_defs_fields(code->defs);
util_swap_defs_fields(code->fields);
- util_swap_functions (code->functions);
- util_swap_globals (code->globals);
+ util_swap_functions(code->functions);
+ util_swap_globals(code->globals);
if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
if (lnofile)
}
bool code_write(code_t *code, const char *filename, const char *lnofile) {
- prog_header_t code_header;
- FILE *fp = NULL;
+ prog_header_t code_header;
+ FILE *fp = NULL;
code_create_header(code, &code_header, filename, lnofile);
if (!fp)
return false;
- util_endianswap(&version, 1, sizeof(version));
- util_endianswap(code->linenums, vec_size(code->linenums), sizeof(code->linenums[0]));
- util_endianswap(code->columnnums, vec_size(code->columnnums), sizeof(code->columnnums[0]));
+ util_endianswap(&version, 1, sizeof(version));
+ util_endianswap(&code->linenums[0], code->linenums.size(), sizeof(code->linenums[0]));
+ util_endianswap(&code->columnnums[0], code->columnnums.size(), sizeof(code->columnnums[0]));
if (fwrite("LNOF", 4, 1, fp) != 1 ||
fwrite(&version, sizeof(version), 1, fp) != 1 ||
fwrite(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
fwrite(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
fwrite(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
- fwrite(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums) ||
- fwrite(code->columnnums, sizeof(code->columnnums[0]), vec_size(code->columnnums), fp) != vec_size(code->columnnums))
+ fwrite(&code->linenums[0], sizeof(code->linenums[0]), code->linenums.size(), fp) != code->linenums.size() ||
+ fwrite(&code->columnnums[0], sizeof(code->columnnums[0]), code->columnnums.size(), fp) != code->columnnums.size())
{
con_err("failed to write lno file\n");
}
if (!fp)
return false;
- if (1 != fwrite(&code_header, sizeof(prog_header_t) , 1 , fp) ||
- vec_size(code->statements) != fwrite(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) ||
- vec_size(code->defs) != fwrite(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) ||
- vec_size(code->fields) != fwrite(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) ||
- vec_size(code->functions) != fwrite(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) ||
- vec_size(code->globals) != fwrite(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) ||
- vec_size(code->chars) != fwrite(code->chars, 1 , vec_size(code->chars) , fp))
+ if (1 != fwrite(&code_header, sizeof(prog_header_t) , 1 , fp) ||
+ code->statements.size() != fwrite(&code->statements[0], sizeof(prog_section_statement_t), code->statements.size(), fp) ||
+ code->defs.size() != fwrite(&code->defs[0], sizeof(prog_section_def_t) , code->defs.size() , fp) ||
+ code->fields.size() != fwrite(&code->fields[0], sizeof(prog_section_field_t) , code->fields.size() , fp) ||
+ code->functions.size() != fwrite(&code->functions[0], sizeof(prog_section_function_t) , code->functions.size() , fp) ||
+ code->globals.size() != fwrite(&code->globals[0], sizeof(int32_t) , code->globals.size() , fp) ||
+ code->chars.size() != fwrite(&code->chars[0], 1 , code->chars.size() , fp))
{
fclose(fp);
return false;
}
void code_cleanup(code_t *code) {
- vec_free(code->statements);
- vec_free(code->linenums);
- vec_free(code->columnnums);
- vec_free(code->defs);
- vec_free(code->fields);
- vec_free(code->functions);
- vec_free(code->globals);
- vec_free(code->chars);
-
util_htdel(code->string_cache);
-
mem_d(code);
}
qc_program_t* prog_load(const char *filename, bool skipversion)
{
- prog_header_t header;
- qc_program_t *prog;
- size_t i;
- FILE *file = fopen(filename, "rb");
+ prog_header_t header;
+ qc_program_t *prog;
+ FILE *file = fopen(filename, "rb");
/* we need all those in order to support INSTR_STATE: */
bool has_self = false,
return NULL;
}
- util_swap_header(&header);
+ util_swap_header(header);
if (!skipversion && header.version != 6) {
loaderror("header says this is a version %i progs, we need version 6\n", header.version);
loaderror("seek failed"); \
goto error; \
} \
+ prog->progvar.resize(header.hdrvar.length + reserved); \
if (fread( \
- vec_add(prog->progvar, header.hdrvar.length + reserved), \
- sizeof(*prog->progvar), \
+ &prog->progvar[0], \
+ sizeof(prog->progvar[0]), \
header.hdrvar.length, \
file \
)!= header.hdrvar.length \
read_data1(strings);
read_data2(globals, 2); /* reserve more in case a RETURN using with the global at "the end" exists */
- util_swap_statements (prog->code);
+ util_swap_statements(prog->code);
util_swap_defs_fields(prog->defs);
util_swap_defs_fields(prog->fields);
- util_swap_functions (prog->functions);
- util_swap_globals (prog->globals);
+ util_swap_functions(prog->functions);
+ util_swap_globals(prog->globals);
fclose(file);
/* profile counters */
- memset(vec_add(prog->profile, vec_size(prog->code)), 0, sizeof(prog->profile[0]) * vec_size(prog->code));
+ memset(vec_add(prog->profile, prog->code.size()), 0, sizeof(prog->profile[0]) * prog->code.size());
/* Add tempstring area */
- prog->tempstring_start = vec_size(prog->strings);
- prog->tempstring_at = vec_size(prog->strings);
- memset(vec_add(prog->strings, 16*1024), 0, 16*1024);
+ prog->tempstring_start = prog->strings.size();
+ prog->tempstring_at = prog->strings.size();
+
+ prog->strings.resize(prog->strings.size() + 16*1024, '\0');
/* spawn the world entity */
vec_push(prog->entitypool, true);
prog->entities = 1;
/* cache some globals and fields from names */
- for (i = 0; i < vec_size(prog->defs); ++i) {
- const char *name = prog_getstring(prog, prog->defs[i].name);
- if (!strcmp(name, "self")) {
- prog->cached_globals.self = prog->defs[i].offset;
+ for (auto &it : prog->defs) {
+ const char *name = prog_getstring(prog, it.name);
+ if (!strcmp(name, "self")) {
+ prog->cached_globals.self = it.offset;
has_self = true;
}
else if (!strcmp(name, "time")) {
- prog->cached_globals.time = prog->defs[i].offset;
+ prog->cached_globals.time = it.offset;
has_time = true;
}
}
- for (i = 0; i < vec_size(prog->fields); ++i) {
- const char *name = prog_getstring(prog, prog->fields[i].name);
- if (!strcmp(name, "think")) {
- prog->cached_fields.think = prog->fields[i].offset;
+ for (auto &it : prog->fields) {
+ const char *name = prog_getstring(prog, it.name);
+ if (!strcmp(name, "think")) {
+ prog->cached_fields.think = it.offset;
has_think = true;
}
else if (!strcmp(name, "nextthink")) {
- prog->cached_fields.nextthink = prog->fields[i].offset;
+ prog->cached_fields.nextthink = it.offset;
has_nextthink = true;
}
else if (!strcmp(name, "frame")) {
- prog->cached_fields.frame = prog->fields[i].offset;
+ prog->cached_fields.frame = it.offset;
has_frame = true;
}
}
error:
if (prog->filename)
mem_d(prog->filename);
- vec_free(prog->code);
- vec_free(prog->defs);
- vec_free(prog->fields);
- vec_free(prog->functions);
- vec_free(prog->strings);
- vec_free(prog->globals);
vec_free(prog->entitydata);
vec_free(prog->entitypool);
mem_d(prog);
void prog_delete(qc_program_t *prog)
{
if (prog->filename) mem_d(prog->filename);
- vec_free(prog->code);
- vec_free(prog->defs);
- vec_free(prog->fields);
- vec_free(prog->functions);
- vec_free(prog->strings);
- vec_free(prog->globals);
vec_free(prog->entitydata);
vec_free(prog->entitypool);
vec_free(prog->localstack);
const char* prog_getstring(qc_program_t *prog, qcint_t str) {
/* cast for return required for C++ */
- if (str < 0 || str >= (qcint_t)vec_size(prog->strings))
+ if (str < 0 || str >= (qcint_t)prog->strings.size())
return "<<<invalid string>>>";
- return prog->strings + str;
+ return &prog->strings[0] + str;
}
prog_section_def_t* prog_entfield(qc_program_t *prog, qcint_t off) {
- size_t i;
- for (i = 0; i < vec_size(prog->fields); ++i) {
- if (prog->fields[i].offset == off)
- return (prog->fields + i);
- }
- return NULL;
+ for (auto &it : prog->fields)
+ if (it.offset == off)
+ return ⁢
+ return nullptr;
}
prog_section_def_t* prog_getdef(qc_program_t *prog, qcint_t off)
{
- size_t i;
- for (i = 0; i < vec_size(prog->defs); ++i) {
- if (prog->defs[i].offset == off)
- return (prog->defs + i);
- }
- return NULL;
+ for (auto &it : prog->defs)
+ if (it.offset == off)
+ return ⁢
+ return nullptr;
}
qcany_t* prog_getedict(qc_program_t *prog, qcint_t e) {
size_t at = prog->tempstring_at;
/* when we reach the end we start over */
- if (at + len >= vec_size(prog->strings))
+ if (at + len >= prog->strings.size())
at = prog->tempstring_start;
/* when it doesn't fit, reallocate */
- if (at + len >= vec_size(prog->strings))
+ if (at + len >= prog->strings.size())
{
- (void)vec_add(prog->strings, len+1);
- memcpy(prog->strings + at, str, len+1);
+ prog->strings.resize(prog->strings.size() + len+1);
+ memcpy(&prog->strings[0] + at, str, len+1);
return at;
}
/* when it fits, just copy */
- memcpy(prog->strings + at, str, len+1);
+ memcpy(&prog->strings[0] + at, str, len+1);
prog->tempstring_at += len+1;
return at;
}
cur = prog->stack[vec_size(prog->stack)-1].function;
if (cur)
{
- qcint_t *globals = prog->globals + cur->firstlocal;
+ qcint_t *globals = &prog->globals[0] + cur->firstlocal;
vec_append(prog->localstack, cur->locals, globals);
}
}
#else
{
- qcint_t *globals = prog->globals + func->firstlocal;
+ qcint_t *globals = &prog->globals[0] + func->firstlocal;
vec_append(prog->localstack, func->locals, globals);
}
#endif
oldsp = prog->stack[vec_size(prog->stack)-1].localsp;
#endif
if (prev) {
- qcint_t *globals = prog->globals + prev->firstlocal;
+ qcint_t *globals = &prog->globals[0] + prev->firstlocal;
memcpy(globals, prog->localstack + oldsp, prev->locals * sizeof(prog->localstack[0]));
/* vec_remove(prog->localstack, oldsp, vec_size(prog->localstack)-oldsp); */
vec_shrinkto(prog->localstack, oldsp);
prog->vmerror = 0;
prog->xflags = flags;
- st = prog->code + prog_enterfunction(prog, func);
+ st = &prog->code[0] + prog_enterfunction(prog, func);
--st;
switch (flags)
{
} \
} while (0)
-#define GetGlobal(idx) ((qcany_t*)(prog->globals + (idx)))
+#define GetGlobal(idx) ((qcany_t*)(&prog->globals[0] + (idx)))
#define GetArg(num) GetGlobal(OFS_PARM0 + 3*(num))
#define Return(any) *(GetGlobal(OFS_RETURN)) = (any)
size_t i;
const char *laststr = NULL;
for (i = 0; i < (size_t)prog->argc; ++i) {
- qcany_t *str = (qcany_t*)(prog->globals + OFS_PARM0 + 3*i);
+ qcany_t *str = (qcany_t*)(&prog->globals[0] + OFS_PARM0 + 3*i);
laststr = prog_getstring(prog, str->string);
printf("%s", laststr);
}
if (opts_info) {
printf("Program's system-checksum = 0x%04x\n", (unsigned int)prog->crc16);
printf("Entity field space: %u\n", (unsigned int)prog->entityfields);
- printf("Globals: %u\n", (unsigned int)vec_size(prog->globals));
+ printf("Globals: %zu\n", prog->globals.size());
printf("Counts:\n"
- " code: %lu\n"
- " defs: %lu\n"
- " fields: %lu\n"
- " functions: %lu\n"
- " strings: %lu\n",
- (unsigned long)vec_size(prog->code),
- (unsigned long)vec_size(prog->defs),
- (unsigned long)vec_size(prog->fields),
- (unsigned long)vec_size(prog->functions),
- (unsigned long)vec_size(prog->strings));
+ " code: %zu\n"
+ " defs: %zu\n"
+ " fields: %zu\n"
+ " functions: %zu\n"
+ " strings: %zu\n",
+ prog->code.size(),
+ prog->defs.size(),
+ prog->fields.size(),
+ prog->functions.size(),
+ prog->strings.size());
}
if (opts_info) {
for (i = 0; i < vec_size(dis_list); ++i) {
size_t k;
printf("Looking for `%s`\n", dis_list[i]);
- for (k = 1; k < vec_size(prog->functions); ++k) {
+ for (k = 1; k < prog->functions.size(); ++k) {
const char *name = prog_getstring(prog, prog->functions[k].name);
if (!strcmp(name, dis_list[i])) {
prog_disasm_function(prog, k);
}
}
if (opts_disasm) {
- for (i = 1; i < vec_size(prog->functions); ++i)
+ for (i = 1; i < prog->functions.size(); ++i)
prog_disasm_function(prog, i);
return 0;
}
if (opts_printdefs) {
const char *getstring = NULL;
- for (i = 0; i < vec_size(prog->defs); ++i) {
+ for (auto &it : prog->defs) {
printf("Global: %8s %-16s at %u%s",
- type_name[prog->defs[i].type & DEF_TYPEMASK],
- prog_getstring(prog, prog->defs[i].name),
- (unsigned int)prog->defs[i].offset,
- ((prog->defs[i].type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
+ type_name[it.type & DEF_TYPEMASK],
+ prog_getstring(prog, it.name),
+ (unsigned int)it.offset,
+ ((it.type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
if (opts_v) {
- switch (prog->defs[i].type & DEF_TYPEMASK) {
+ switch (it.type & DEF_TYPEMASK) {
case TYPE_FLOAT:
- printf(" [init: %g]", ((qcany_t*)(prog->globals + prog->defs[i].offset))->_float);
+ printf(" [init: %g]", ((qcany_t*)(&prog->globals[0] + it.offset))->_float);
break;
case TYPE_INTEGER:
- printf(" [init: %i]", (int)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int ));
+ printf(" [init: %i]", (int)( ((qcany_t*)(&prog->globals[0] + it.offset))->_int ));
break;
case TYPE_ENTITY:
case TYPE_FUNCTION:
case TYPE_FIELD:
case TYPE_POINTER:
- printf(" [init: %u]", (unsigned)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int ));
+ printf(" [init: %u]", (unsigned)( ((qcany_t*)(&prog->globals[0] + it.offset))->_int ));
break;
case TYPE_STRING:
- getstring = prog_getstring(prog, ((qcany_t*)(prog->globals + prog->defs[i].offset))->string);
+ getstring = prog_getstring(prog, ((qcany_t*)(&prog->globals[0] + it.offset))->string);
printf(" [init: `");
print_escaped_string(getstring, strlen(getstring));
printf("`]\n");
}
}
if (opts_printfields) {
- for (i = 0; i < vec_size(prog->fields); ++i) {
- printf("Field: %8s %-16s at %u%s\n",
- type_name[prog->fields[i].type],
- prog_getstring(prog, prog->fields[i].name),
- (unsigned int)prog->fields[i].offset,
- ((prog->fields[i].type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
+ for (auto &it : prog->fields) {
+ printf("Field: %8s %-16s at %d%s\n",
+ type_name[it.type],
+ prog_getstring(prog, it.name),
+ it.offset,
+ ((it.type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
}
}
if (opts_printfuns) {
- for (i = 0; i < vec_size(prog->functions); ++i) {
+ for (auto &it : prog->functions) {
int32_t a;
printf("Function: %-16s taking %u parameters:(",
- prog_getstring(prog, prog->functions[i].name),
- (unsigned int)prog->functions[i].nargs);
- for (a = 0; a < prog->functions[i].nargs; ++a) {
- printf(" %i", prog->functions[i].argsize[a]);
+ prog_getstring(prog, it.name),
+ (unsigned int)it.nargs);
+ for (a = 0; a < it.nargs; ++a) {
+ printf(" %i", it.argsize[a]);
}
if (opts_v > 1) {
- int32_t start = prog->functions[i].entry;
+ int32_t start = it.entry;
if (start < 0)
printf(") builtin %i\n", (int)-start);
else {
size_t funsize = 0;
- prog_section_statement_t *st = prog->code + start;
+ prog_section_statement_t *st = &prog->code[0] + start;
for (;st->opcode != INSTR_DONE; ++st)
++funsize;
- printf(") - %lu instructions", (unsigned long)funsize);
+ printf(") - %zu instructions", funsize);
if (opts_v > 2) {
printf(" - locals: %i + %i\n",
- prog->functions[i].firstlocal,
- prog->functions[i].locals);
+ it.firstlocal,
+ it.locals);
}
else
printf("\n");
}
else if (opts_v) {
printf(") locals: %i + %i\n",
- prog->functions[i].firstlocal,
- prog->functions[i].locals);
+ it.firstlocal,
+ it.locals);
}
else
printf(")\n");
}
}
if (!noexec) {
- for (i = 1; i < vec_size(prog->functions); ++i) {
+ for (i = 1; i < prog->functions.size(); ++i) {
const char *name = prog_getstring(prog, prog->functions[i].name);
if (!strcmp(name, "main"))
fnmain = (qcint_t)i;
}
static void prog_disasm_function(qc_program_t *prog, size_t id) {
- prog_section_function_t *fdef = prog->functions + id;
+ prog_section_function_t *fdef = &prog->functions[0] + id;
prog_section_statement_t *st;
if (fdef->entry < 0) {
else
printf("FUNCTION \"%s\"\n", prog_getstring(prog, fdef->name));
- st = prog->code + fdef->entry;
+ st = &prog->code[0] + fdef->entry;
while (st->opcode != INSTR_DONE) {
prog_print_statement(prog, st);
++st;
* sort of isn't, which makes it nicer looking.
*/
-#define OPA ( (qcany_t*) (prog->globals + st->o1.u1) )
-#define OPB ( (qcany_t*) (prog->globals + st->o2.u1) )
-#define OPC ( (qcany_t*) (prog->globals + st->o3.u1) )
+#define OPA ( (qcany_t*) (&prog->globals[0] + st->o1.u1) )
+#define OPB ( (qcany_t*) (&prog->globals[0] + st->o2.u1) )
+#define OPC ( (qcany_t*) (&prog->globals[0] + st->o3.u1) )
-#define GLOBAL(x) ( (qcany_t*) (prog->globals + (x)) )
+#define GLOBAL(x) ( (qcany_t*) (&prog->globals[0] + (x)) )
/* to be consistent with current darkplaces behaviour */
#if !defined(FLOAT_IS_TRUE_FOR_INT)
++st;
#if QCVM_PROFILE
- prog->profile[st - prog->code]++;
+ prog->profile[st - &prog->code[0]]++;
#endif
#if QCVM_TRACE
GLOBAL(OFS_RETURN)->ivector[1] = OPA->ivector[1];
GLOBAL(OFS_RETURN)->ivector[2] = OPA->ivector[2];
- st = prog->code + prog_leavefunction(prog);
+ st = &prog->code[0] + prog_leavefunction(prog);
if (!vec_size(prog->stack))
goto cleanup;
if (!OPA->function)
qcvmerror(prog, "NULL function in `%s`", prog->filename);
- if(!OPA->function || OPA->function >= (qcint_t)vec_size(prog->functions))
+ if(!OPA->function || OPA->function >= (qcint_t)prog->functions.size())
{
qcvmerror(prog, "CALL outside the program in `%s`", prog->filename);
goto cleanup;
newf = &prog->functions[OPA->function];
newf->profile++;
- prog->statement = (st - prog->code) + 1;
+ prog->statement = (st - &prog->code[0]) + 1;
if (newf->entry < 0)
{
builtinnumber, prog->filename);
}
else
- st = prog->code + prog_enterfunction(prog, newf) - 1; /* offset st++ */
+ st = &prog->code[0] + prog_enterfunction(prog, newf) - 1; /* offset st++ */
if (prog->vmerror)
goto cleanup;
break;
frame = (qcfloat_t*)&((qcint_t*)ed)[prog->cached_fields.frame];
*frame = OPA->_float;
nextthink = (qcfloat_t*)&((qcint_t*)ed)[prog->cached_fields.nextthink];
- time = (qcfloat_t*)(prog->globals + prog->cached_globals.time);
+ time = (qcfloat_t*)(&prog->globals[0] + prog->cached_globals.time);
*nextthink = *time + 0.1;
break;
}
#ifndef GMQCC_HDR
#define GMQCC_HDR
+#include <vector>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
/* TODO: elide */
extern const char *util_instr_str[VINSTR_END];
-void util_swap_header (prog_header_t *code_header);
-void util_swap_statements (prog_section_statement_t *statements);
-void util_swap_defs_fields(prog_section_both_t *section);
-void util_swap_functions (prog_section_function_t *functions);
-void util_swap_globals (int32_t *globals);
+void util_swap_header(prog_header_t &code_header);
+void util_swap_statements(std::vector<prog_section_statement_t> &statements);
+void util_swap_defs_fields(std::vector<prog_section_both_t> §ion);
+void util_swap_functions(std::vector<prog_section_function_t> &functions);
+void util_swap_globals(std::vector<int32_t> &globals);
-typedef float qcfloat_t;
-typedef int32_t qcint_t;
+typedef float qcfloat_t;
+typedef int32_t qcint_t;
typedef uint32_t qcuint_t;
struct code_t {
- prog_section_statement_t *statements;
- int *linenums;
- int *columnnums;
- prog_section_def_t *defs;
- prog_section_field_t *fields;
- prog_section_function_t *functions;
- int *globals;
- char *chars;
- uint16_t crc;
- uint32_t entfields;
- ht string_cache;
- qcint_t string_cached_empty;
+ std::vector<prog_section_statement_t> statements;
+ std::vector<int> linenums;
+ std::vector<int> columnnums;
+ std::vector<prog_section_def_t> defs;
+ std::vector<prog_section_field_t> fields;
+ std::vector<prog_section_function_t> functions;
+ std::vector<int> globals;
+ std::vector<char> chars;
+ uint16_t crc;
+ uint32_t entfields;
+ ht string_cache;
+ qcint_t string_cached_empty;
};
/*
*/
struct lex_ctx_t {
const char *file;
- size_t line;
- size_t column;
+ size_t line;
+ size_t column;
};
/*
};
struct qc_program_t {
- char *filename;
- prog_section_statement_t *code;
- prog_section_def_t *defs;
- prog_section_def_t *fields;
- prog_section_function_t *functions;
- char *strings;
- qcint_t *globals;
- qcint_t *entitydata;
- bool *entitypool;
-
- const char* *function_stack;
+ char *filename;
+ std::vector<prog_section_statement_t> code;
+ std::vector<prog_section_def_t> defs;
+ std::vector<prog_section_def_t> fields;
+ std::vector<prog_section_function_t> functions;
+ std::vector<char> strings;
+ std::vector<qcint_t> globals;
+ qcint_t *entitydata;
+ bool *entitypool;
+
+ const char* *function_stack;
uint16_t crc16;
}
/* copy the field's value */
- ir_value_code_setaddr(global, vec_size(code->globals));
- vec_push(code->globals, fld->code.fieldaddr);
+ ir_value_code_setaddr(global, code->globals.size());
+ code->globals.push_back(fld->code.fieldaddr);
if (global->fieldtype == TYPE_VECTOR) {
- vec_push(code->globals, fld->code.fieldaddr+1);
- vec_push(code->globals, fld->code.fieldaddr+2);
+ code->globals.push_back(fld->code.fieldaddr+1);
+ code->globals.push_back(fld->code.fieldaddr+2);
}
}
else
{
- ir_value_code_setaddr(global, vec_size(code->globals));
- vec_push(code->globals, 0);
+ ir_value_code_setaddr(global, code->globals.size());
+ code->globals.push_back(0);
if (global->fieldtype == TYPE_VECTOR) {
- vec_push(code->globals, 0);
- vec_push(code->globals, 0);
+ code->globals.push_back(0);
+ code->globals.push_back(0);
}
}
if (global->code.globaladdr < 0)
return false;
}
- ir_value_code_setaddr(global, vec_size(code->globals));
- vec_push(code->globals, target->code.globaladdr);
+ ir_value_code_setaddr(global, code->globals.size());
+ code->globals.push_back(target->code.globaladdr);
}
else
{
- ir_value_code_setaddr(global, vec_size(code->globals));
- vec_push(code->globals, 0);
+ ir_value_code_setaddr(global, code->globals.size());
+ code->globals.push_back(0);
}
if (global->code.globaladdr < 0)
return false;
int j;
block->generated = true;
- block->code_start = vec_size(code->statements);
+ block->code_start = code->statements.size();
for (i = 0; i < vec_size(block->instr); ++i)
{
instr = block->instr[i];
/* otherwise we generate a jump instruction */
stmt.opcode = INSTR_GOTO;
- stmt.o1.s1 = (target->code_start) - vec_size(code->statements);
+ stmt.o1.s1 = target->code_start - code->statements.size();
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
if (ontrue->generated) {
stmt.opcode = INSTR_IF;
- stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
+ stmt.o2.s1 = ontrue->code_start - code->statements.size();
if (stmt.o2.s1 != 1)
code_push_statement(code, &stmt, instr->context);
}
if (onfalse->generated) {
stmt.opcode = INSTR_IFNOT;
- stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
+ stmt.o2.s1 = onfalse->code_start - code->statements.size();
if (stmt.o2.s1 != 1)
code_push_statement(code, &stmt, instr->context);
}
onfalse = ontrue;
ontrue = tmp;
}
- stidx = vec_size(code->statements);
+ stidx = code->statements.size();
code_push_statement(code, &stmt, instr->context);
/* on false we jump, so add ontrue-path */
if (!gen_blocks_recursive(code, func, ontrue))
return false;
/* fixup the jump address */
- code->statements[stidx].o2.s1 = vec_size(code->statements) - stidx;
+ code->statements[stidx].o2.s1 = code->statements.size() - stidx;
/* generate onfalse path */
if (onfalse->generated) {
/* fixup the jump address */
- code->statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
- if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
+ code->statements[stidx].o2.s1 = onfalse->code_start - stidx;
+ if (stidx+2 == code->statements.size() && code->statements[stidx].o2.s1 == 1) {
code->statements[stidx] = code->statements[stidx+1];
if (code->statements[stidx].o1.s1 < 0)
code->statements[stidx].o1.s1++;
code_pop_statement(code);
}
- stmt.opcode = vec_last(code->statements).opcode;
+ stmt.opcode = code->statements.back().opcode;
if (stmt.opcode == INSTR_GOTO ||
stmt.opcode == INSTR_IF ||
stmt.opcode == INSTR_IFNOT ||
}
/* may have been generated in the previous recursive call */
stmt.opcode = INSTR_GOTO;
- stmt.o1.s1 = (onfalse->code_start) - vec_size(code->statements);
+ stmt.o1.s1 = onfalse->code_start - code->statements.size();
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
code_push_statement(code, &stmt, instr->context);
return true;
}
- else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
+ else if (stidx+2 == code->statements.size() && code->statements[stidx].o2.s1 == 1) {
code->statements[stidx] = code->statements[stidx+1];
if (code->statements[stidx].o1.s1 < 0)
code->statements[stidx].o1.s1++;
}
/* code_write and qcvm -disasm need to know that the function ends here */
- retst = &vec_last(code->statements);
+ retst = &code->statements.back();
if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
self->outtype == TYPE_VOID &&
retst->opcode == INSTR_RETURN &&
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
- last.line = vec_last(code->linenums);
- last.column = vec_last(code->columnnums);
+ last.line = code->linenums.back();
+ last.column = code->columnnums.back();
code_push_statement(code, &stmt, last);
}
size_t i;
- if (!global->hasvalue || (!global->constval.vfunc))
- {
+ if (!global->hasvalue || (!global->constval.vfunc)) {
irerror(global->context, "Invalid state of function-global: not constant: %s", global->name);
return false;
}
irfun = global->constval.vfunc;
-
- fun.name = global->code.name;
- fun.file = ir_builder_filestring(ir, global->context.file);
+ fun.name = global->code.name;
+ fun.file = ir_builder_filestring(ir, global->context.file);
fun.profile = 0; /* always 0 */
- fun.nargs = vec_size(irfun->params);
+ fun.nargs = vec_size(irfun->params);
if (fun.nargs > 8)
fun.nargs = 8;
- for (i = 0;i < 8; ++i) {
+ for (i = 0; i < 8; ++i) {
if ((int32_t)i >= fun.nargs)
fun.argsize[i] = 0;
else
}
fun.firstlocal = 0;
- fun.locals = irfun->allocated_locals;
+ fun.locals = irfun->allocated_locals;
if (irfun->builtin)
fun.entry = irfun->builtin+1;
else {
- irfun->code_function_def = vec_size(ir->code->functions);
- fun.entry = vec_size(ir->code->statements);
+ irfun->code_function_def = ir->code->functions.size();
+ fun.entry = ir->code->statements.size();
}
- vec_push(ir->code->functions, fun);
+ ir->code->functions.push_back(fun);
return true;
}
else
global = ir->extparam_protos[vec_size(ir->extparams)];
- def.name = code_genstring(ir->code, global->name);
- def.type = TYPE_VECTOR;
- def.offset = vec_size(ir->code->globals);
+ def.name = code_genstring(ir->code, global->name);
+ def.type = TYPE_VECTOR;
+ def.offset = ir->code->globals.size();
- vec_push(ir->code->defs, def);
+ ir->code->defs.push_back(def);
ir_value_code_setaddr(global, def.offset);
- vec_push(ir->code->globals, 0);
- vec_push(ir->code->globals, 0);
- vec_push(ir->code->globals, 0);
+ ir->code->globals.push_back(0);
+ ir->code->globals.push_back(0);
+ ir->code->globals.push_back(0);
vec_push(ir->extparams, global);
}
uint32_t firstlocal, firstglobal;
irfun = global->constval.vfunc;
- def = ir->code->functions + irfun->code_function_def;
+ def = &ir->code->functions[0] + irfun->code_function_def;
if (OPTS_OPTION_BOOL(OPTION_G) ||
!OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) ||
(irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
{
- firstlocal = def->firstlocal = vec_size(ir->code->globals);
+ firstlocal = def->firstlocal = ir->code->globals.size();
} else {
firstlocal = def->firstlocal = ir->first_common_local;
++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
- for (i = vec_size(ir->code->globals); i < firstlocal + irfun->allocated_locals; ++i)
- vec_push(ir->code->globals, 0);
+ for (i = ir->code->globals.size(); i < firstlocal + irfun->allocated_locals; ++i)
+ ir->code->globals.push_back(0);
for (i = 0; i < vec_size(irfun->locals); ++i) {
ir_value *v = irfun->locals[i];
if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
}
fundef = &ir->code->functions[irfun->code_function_def];
- fundef->entry = vec_size(ir->code->statements);
+ fundef->entry = ir->code->statements.size();
if (!gen_function_locals(ir, global)) {
irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
return false;
for (i = 0; i < 3; ++i) {
def.name = code_genstring(code, component);
- vec_push(code->defs, def);
+ code->defs.push_back(def);
def.offset++;
component[len-1]++;
}
for (i = 0; i < 3; ++i) {
fld.name = code_genstring(code, component);
- vec_push(code->fields, fld);
+ code->fields.push_back(fld);
fld.offset++;
component[len-1]++;
}
if (global->vtype == TYPE_VECTOR && (global->flags & IR_FLAG_SPLIT_VECTOR))
return true;
- def.type = global->vtype;
- def.offset = vec_size(self->code->globals);
- def.name = 0;
+ def.type = global->vtype;
+ def.offset = self->code->globals.size();
+ def.name = 0;
if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{
pushdef = true;
def.name = 0;
if (islocal) {
def.offset = ir_value_code_addr(global);
- vec_push(self->code->defs, def);
+ self->code->defs.push_back(def);
if (global->vtype == TYPE_VECTOR)
gen_vector_defs(self->code, def, global->name);
else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
* Maybe this could be an -foption
* fteqcc creates data for end_sys_* - of size 1, so let's do the same
*/
- ir_value_code_setaddr(global, vec_size(self->code->globals));
- vec_push(self->code->globals, 0);
+ ir_value_code_setaddr(global, self->code->globals.size());
+ self->code->globals.push_back(0);
/* Add the def */
- if (pushdef) vec_push(self->code->defs, def);
+ if (pushdef) self->code->defs.push_back(def);
return true;
case TYPE_POINTER:
- if (pushdef) vec_push(self->code->defs, def);
+ if (pushdef) self->code->defs.push_back(def);
return gen_global_pointer(self->code, global);
case TYPE_FIELD:
if (pushdef) {
- vec_push(self->code->defs, def);
+ self->code->defs.push_back(def);
if (global->fieldtype == TYPE_VECTOR)
gen_vector_defs(self->code, def, global->name);
}
/* fall through */
case TYPE_FLOAT:
{
- ir_value_code_setaddr(global, vec_size(self->code->globals));
+ ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
- vec_push(self->code->globals, *iptr);
+ self->code->globals.push_back(*iptr);
} else {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(self->code->defs, def);
+ if (pushdef) self->code->defs.push_back(def);
return global->code.globaladdr >= 0;
}
case TYPE_STRING:
{
- ir_value_code_setaddr(global, vec_size(self->code->globals));
+ ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
uint32_t load = code_genstring(self->code, global->constval.vstring);
- vec_push(self->code->globals, load);
+ self->code->globals.push_back(load);
} else {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(self->code->defs, def);
+ if (pushdef) self->code->defs.push_back(def);
return global->code.globaladdr >= 0;
}
case TYPE_VECTOR:
{
size_t d;
- ir_value_code_setaddr(global, vec_size(self->code->globals));
+ ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
- vec_push(self->code->globals, iptr[0]);
+ self->code->globals.push_back(iptr[0]);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
- vec_push(self->code->globals, iptr[d]);
+ self->code->globals.push_back(iptr[d]);
}
} else {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
}
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) {
- vec_push(self->code->defs, def);
+ self->code->defs.push_back(def);
def.type &= ~DEF_SAVEGLOBAL;
gen_vector_defs(self->code, def, global->name);
}
return global->code.globaladdr >= 0;
}
case TYPE_FUNCTION:
- ir_value_code_setaddr(global, vec_size(self->code->globals));
+ ir_value_code_setaddr(global, self->code->globals.size());
if (!global->hasvalue) {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
if (global->code.globaladdr < 0)
return false;
} else {
- vec_push(self->code->globals, vec_size(self->code->functions));
+ self->code->globals.push_back(self->code->functions.size());
if (!gen_global_function(self, global))
return false;
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(self->code->defs, def);
+ if (pushdef) self->code->defs.push_back(def);
return true;
case TYPE_VARIANT:
/* assume biggest type */
- ir_value_code_setaddr(global, vec_size(self->code->globals));
- vec_push(self->code->globals, 0);
+ ir_value_code_setaddr(global, self->code->globals.size());
+ self->code->globals.push_back(0);
for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
return true;
default:
/* refuse to create 'void' type or any other fancy business. */
(void)self;
def.type = (uint16_t)field->vtype;
- def.offset = (uint16_t)vec_size(self->code->globals);
+ def.offset = (uint16_t)self->code->globals.size();
/* create a global named the same as the field */
if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
field->code.name = def.name;
- vec_push(self->code->defs, def);
+ self->code->defs.push_back(def);
fld.type = field->fieldtype;
fld.offset = field->code.fieldaddr;
- vec_push(self->code->fields, fld);
+ self->code->fields.push_back(fld);
- ir_value_code_setaddr(field, vec_size(self->code->globals));
- vec_push(self->code->globals, fld.offset);
+ ir_value_code_setaddr(field, self->code->globals.size());
+ self->code->globals.push_back(fld.offset);
if (fld.type == TYPE_VECTOR) {
- vec_push(self->code->globals, fld.offset+1);
- vec_push(self->code->globals, fld.offset+2);
+ self->code->globals.push_back(fld.offset+1);
+ self->code->globals.push_back(fld.offset+2);
}
if (field->fieldtype == TYPE_VECTOR) {
}
/* generate nil */
- ir_value_code_setaddr(self->nil, vec_size(self->code->globals));
- vec_push(self->code->globals, 0);
- vec_push(self->code->globals, 0);
- vec_push(self->code->globals, 0);
+ ir_value_code_setaddr(self->nil, self->code->globals.size());
+ self->code->globals.push_back(0);
+ self->code->globals.push_back(0);
+ self->code->globals.push_back(0);
/* generate virtual-instruction temps */
for (i = 0; i < IR_MAX_VINSTR_TEMPS; ++i) {
- ir_value_code_setaddr(self->vinstr_temp[i], vec_size(self->code->globals));
- vec_push(self->code->globals, 0);
- vec_push(self->code->globals, 0);
- vec_push(self->code->globals, 0);
+ ir_value_code_setaddr(self->vinstr_temp[i], self->code->globals.size());
+ self->code->globals.push_back(0);
+ self->code->globals.push_back(0);
+ self->code->globals.push_back(0);
}
/* generate global temps */
- self->first_common_globaltemp = vec_size(self->code->globals);
+ self->first_common_globaltemp = self->code->globals.size();
for (i = 0; i < self->max_globaltemps; ++i) {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
}
/* generate common locals */
- self->first_common_local = vec_size(self->code->globals);
+ self->first_common_local = self->code->globals.size();
for (i = 0; i < self->max_locals; ++i) {
- vec_push(self->code->globals, 0);
+ self->code->globals.push_back(0);
}
/* generate function code */
}
}
- if (vec_size(self->code->globals) >= 65536) {
- irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle (%u). Bailing out.", (unsigned int)vec_size(self->code->globals));
+ if (self->code->globals.size() >= 65536) {
+ irerror(vec_last(self->globals)->context,
+ "This progs file would require more globals than the metadata can handle (%zu). Bailing out.",
+ self->code->globals.size());
return false;
}
/* DP errors if the last instruction is not an INSTR_DONE. */
- if (vec_last(self->code->statements).opcode != INSTR_DONE)
+ if (self->code->statements.back().opcode != INSTR_DONE)
{
lex_ctx_t last;
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
- last.line = vec_last(self->code->linenums);
- last.column = vec_last(self->code->columnnums);
+ last.line = self->code->linenums.back();
+ last.column = self->code->columnnums.back();
code_push_statement(self->code, &stmt, last);
}
if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
return true;
- if (vec_size(self->code->statements) != vec_size(self->code->linenums)) {
+ if (self->code->statements.size() != self->code->linenums.size()) {
con_err("Linecounter wrong: %lu != %lu\n",
- (unsigned long)vec_size(self->code->statements),
- (unsigned long)vec_size(self->code->linenums));
+ self->code->statements.size(),
+ self->code->linenums.size());
} else if (OPTS_FLAG(LNO)) {
char *dot;
size_t filelen = strlen(filename);
#endif
}
-void util_swap_header(prog_header_t *code_header) {
- util_endianswap(&code_header->version, 1, sizeof(code_header->version));
- util_endianswap(&code_header->crc16, 1, sizeof(code_header->crc16));
- util_endianswap(&code_header->statements.offset, 1, sizeof(code_header->statements.offset));
- util_endianswap(&code_header->statements.length, 1, sizeof(code_header->statements.length));
- util_endianswap(&code_header->defs.offset, 1, sizeof(code_header->defs.offset));
- util_endianswap(&code_header->defs.length, 1, sizeof(code_header->defs.length));
- util_endianswap(&code_header->fields.offset, 1, sizeof(code_header->fields.offset));
- util_endianswap(&code_header->fields.length, 1, sizeof(code_header->fields.length));
- util_endianswap(&code_header->functions.offset, 1, sizeof(code_header->functions.offset));
- util_endianswap(&code_header->functions.length, 1, sizeof(code_header->functions.length));
- util_endianswap(&code_header->strings.offset, 1, sizeof(code_header->strings.offset));
- util_endianswap(&code_header->strings.length, 1, sizeof(code_header->strings.length));
- util_endianswap(&code_header->globals.offset, 1, sizeof(code_header->globals.offset));
- util_endianswap(&code_header->globals.length, 1, sizeof(code_header->globals.length));
- util_endianswap(&code_header->entfield, 1, sizeof(code_header->entfield));
+void util_swap_header(prog_header_t &code_header) {
+ util_endianswap(&code_header.version, 1, sizeof(code_header.version));
+ util_endianswap(&code_header.crc16, 1, sizeof(code_header.crc16));
+ util_endianswap(&code_header.statements.offset, 1, sizeof(code_header.statements.offset));
+ util_endianswap(&code_header.statements.length, 1, sizeof(code_header.statements.length));
+ util_endianswap(&code_header.defs.offset, 1, sizeof(code_header.defs.offset));
+ util_endianswap(&code_header.defs.length, 1, sizeof(code_header.defs.length));
+ util_endianswap(&code_header.fields.offset, 1, sizeof(code_header.fields.offset));
+ util_endianswap(&code_header.fields.length, 1, sizeof(code_header.fields.length));
+ util_endianswap(&code_header.functions.offset, 1, sizeof(code_header.functions.offset));
+ util_endianswap(&code_header.functions.length, 1, sizeof(code_header.functions.length));
+ util_endianswap(&code_header.strings.offset, 1, sizeof(code_header.strings.offset));
+ util_endianswap(&code_header.strings.length, 1, sizeof(code_header.strings.length));
+ util_endianswap(&code_header.globals.offset, 1, sizeof(code_header.globals.offset));
+ util_endianswap(&code_header.globals.length, 1, sizeof(code_header.globals.length));
+ util_endianswap(&code_header.entfield, 1, sizeof(code_header.entfield));
}
-void util_swap_statements(prog_section_statement_t *statements) {
- size_t i;
-
- for (i = 0; i < vec_size(statements); ++i) {
- util_endianswap(&statements[i].opcode, 1, sizeof(statements[i].opcode));
- util_endianswap(&statements[i].o1, 1, sizeof(statements[i].o1));
- util_endianswap(&statements[i].o2, 1, sizeof(statements[i].o2));
- util_endianswap(&statements[i].o3, 1, sizeof(statements[i].o3));
+void util_swap_statements(std::vector<prog_section_statement_t> &statements) {
+ for (auto &it : statements) {
+ util_endianswap(&it.opcode, 1, sizeof(it.opcode));
+ util_endianswap(&it.o1, 1, sizeof(it.o1));
+ util_endianswap(&it.o2, 1, sizeof(it.o2));
+ util_endianswap(&it.o3, 1, sizeof(it.o3));
}
}
-void util_swap_defs_fields(prog_section_both_t *section) {
- size_t i;
-
- for (i = 0; i < vec_size(section); ++i) {
- util_endianswap(§ion[i].type, 1, sizeof(section[i].type));
- util_endianswap(§ion[i].offset, 1, sizeof(section[i].offset));
- util_endianswap(§ion[i].name, 1, sizeof(section[i].name));
+void util_swap_defs_fields(std::vector<prog_section_both_t> §ion) {
+ for (auto &it : section) {
+ util_endianswap(&it.type, 1, sizeof(it.type));
+ util_endianswap(&it.offset, 1, sizeof(it.offset));
+ util_endianswap(&it.name, 1, sizeof(it.name));
}
}
-void util_swap_functions(prog_section_function_t *functions) {
- size_t i;
-
- for (i = 0; i < vec_size(functions); ++i) {
- util_endianswap(&functions[i].entry, 1, sizeof(functions[i].entry));
- util_endianswap(&functions[i].firstlocal, 1, sizeof(functions[i].firstlocal));
- util_endianswap(&functions[i].locals, 1, sizeof(functions[i].locals));
- util_endianswap(&functions[i].profile, 1, sizeof(functions[i].profile));
- util_endianswap(&functions[i].name, 1, sizeof(functions[i].name));
- util_endianswap(&functions[i].file, 1, sizeof(functions[i].file));
- util_endianswap(&functions[i].nargs, 1, sizeof(functions[i].nargs));
+void util_swap_functions(std::vector<prog_section_function_t> &functions) {
+ for (auto &it : functions) {
+ util_endianswap(&it.entry, 1, sizeof(it.entry));
+ util_endianswap(&it.firstlocal, 1, sizeof(it.firstlocal));
+ util_endianswap(&it.locals, 1, sizeof(it.locals));
+ util_endianswap(&it.profile, 1, sizeof(it.profile));
+ util_endianswap(&it.name, 1, sizeof(it.name));
+ util_endianswap(&it.file, 1, sizeof(it.file));
+ util_endianswap(&it.nargs, 1, sizeof(it.nargs));
/* Don't swap argsize[] - it's just a byte array, which Quake uses only as such. */
}
}
-void util_swap_globals(int32_t *globals) {
- util_endianswap(globals, vec_size(globals), sizeof(int32_t));
+void util_swap_globals(std::vector<int32_t> &globals) {
+ util_endianswap(&globals[0], globals.size(), sizeof(int32_t));
}
/*
projects / xonotic / gmqcc.git / commitdiff