5 #define _MEM_VEC_FUN_APPEND(Tself, Twhat, mem) \
6 bool GMQCC_WARN Tself##_##mem##_append(Tself *s, Twhat *p, size_t c) \
9 if (s->mem##_count+c >= s->mem##_alloc) { \
10 if (!s->mem##_alloc) { \
11 s->mem##_alloc = c < 16 ? 16 : c; \
13 s->mem##_alloc *= 2; \
14 if (s->mem##_count+c >= s->mem##_alloc) { \
15 s->mem##_alloc = s->mem##_count+c; \
18 reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc); \
22 memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
26 memcpy(&s->mem[s->mem##_count], p, c*sizeof(*p)); \
27 s->mem##_count += c; \
31 #define _MEM_VEC_FUN_RESIZE(Tself, Twhat, mem) \
32 bool GMQCC_WARN Tself##_##mem##_resize(Tself *s, size_t c) \
35 reall = (Twhat*)mem_a(sizeof(Twhat) * c); \
36 if (c > s->mem##_count) { \
37 memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
39 memcpy(reall, s->mem, sizeof(Twhat) * c); \
46 /* darkplaces has (or will have) a 64 bit prog loader
47 * where the 32 bit qc program is autoconverted on load.
48 * Since we may want to support that as well, let's redefine
51 typedef float qcfloat;
52 typedef int32_t qcint;
54 typedef char qcfloat_size_is_correct [sizeof(qcfloat) == 4 ?1:-1];
55 typedef char qcint_size_is_correct [sizeof(int) == 4 ?1:-1];
67 prog_section statements;
70 prog_section functions;
76 typedef prog_section_both prog_def;
77 typedef prog_section_function prog_function;
78 typedef prog_section_statement prog_statement;
82 VMERR_TEMPSTRING_ALLOC,
90 MEM_VECTOR_MAKE(prog_statement, code);
91 MEM_VECTOR_MAKE(prog_def, defs);
92 MEM_VECTOR_MAKE(prog_def, fields);
93 MEM_VECTOR_MAKE(prog_function, functions);
94 MEM_VECTOR_MAKE(char, strings);
95 MEM_VECTOR_MAKE(qcint, globals);
96 MEM_VECTOR_MAKE(qcint, entitydata);
98 size_t tempstring_start;
103 MEM_VECTOR_MAKE(qcint, localstack);
104 MEM_VECTOR_MAKE(size_t, localsp);
106 MEM_VEC_FUNCTIONS(qc_program, prog_statement, code)
107 MEM_VEC_FUNCTIONS(qc_program, prog_def, defs)
108 MEM_VEC_FUNCTIONS(qc_program, prog_def, fields)
109 MEM_VEC_FUNCTIONS(qc_program, prog_function, functions)
110 MEM_VEC_FUNCTIONS(qc_program, char, strings)
111 _MEM_VEC_FUN_APPEND(qc_program, char, strings)
112 _MEM_VEC_FUN_RESIZE(qc_program, char, strings)
113 MEM_VEC_FUNCTIONS(qc_program, qcint, globals)
114 MEM_VEC_FUNCTIONS(qc_program, qcint, entitydata)
116 MEM_VEC_FUNCTIONS(qc_program, qcint, localstack)
117 _MEM_VEC_FUN_APPEND(qc_program, qcint, localstack)
118 _MEM_VEC_FUN_RESIZE(qc_program, qcint, localstack)
119 MEM_VEC_FUNCTIONS(qc_program, size_t, localsp)
121 qc_program* prog_load(const char *filename)
127 file = fopen(filename, "rb");
131 if (fread(&header, sizeof(header), 1, file) != 1) {
137 if (header.version != 6) {
138 printf("header says this is a version %i progs, we need version 6\n",
144 prog = (qc_program*)mem_a(sizeof(qc_program));
147 printf("failed to allocate program data\n");
150 memset(prog, 0, sizeof(*prog));
152 prog->filename = util_strdup(filename);
155 #define read_data(hdrvar, progvar, type) \
156 if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) { \
160 prog->progvar##_alloc = header.hdrvar.length; \
161 prog->progvar##_count = header.hdrvar.length; \
162 prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
163 if (!prog->progvar) \
165 if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
166 != header.hdrvar.length) { \
170 #define read_data1(x, y) read_data(x, x, y)
172 read_data (statements, code, prog_statement);
173 read_data1(defs, prog_def);
174 read_data1(fields, prog_def);
175 read_data1(functions, prog_function);
176 read_data1(strings, char);
177 read_data1(globals, qcint);
181 /* Add tempstring area */
182 prog->tempstring_start = prog->strings_count;
183 prog->tempstring_at = prog->strings_count;
184 if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
190 if (prog->filename) mem_d(prog->filename);
191 if (prog->code) mem_d(prog->code);
192 if (prog->defs) mem_d(prog->defs);
193 if (prog->fields) mem_d(prog->fields);
194 if (prog->functions) mem_d(prog->functions);
195 if (prog->strings) mem_d(prog->strings);
196 if (prog->globals) mem_d(prog->globals);
197 if (prog->entitydata) mem_d(prog->entitydata);
202 void prog_delete(qc_program *prog)
204 if (prog->filename) mem_d(prog->filename);
205 MEM_VECTOR_CLEAR(prog, code);
206 MEM_VECTOR_CLEAR(prog, defs);
207 MEM_VECTOR_CLEAR(prog, fields);
208 MEM_VECTOR_CLEAR(prog, functions);
209 MEM_VECTOR_CLEAR(prog, strings);
210 MEM_VECTOR_CLEAR(prog, globals);
211 MEM_VECTOR_CLEAR(prog, entitydata);
212 MEM_VECTOR_CLEAR(prog, localstack);
213 MEM_VECTOR_CLEAR(prog, localsp);
217 /***********************************************************************
221 char* prog_getstring(qc_program *prog, qcint str)
223 if (str < 0 || str >= prog->strings_count)
224 return prog->strings;
225 return prog->strings + str;
228 qcint prog_tempstring(qc_program *prog, const char *_str)
230 /* we don't access it, but the macro-generated functions don't use
233 char *str = (char*)_str;
235 size_t len = strlen(str);
236 size_t at = prog->tempstring_at;
238 /* when we reach the end we start over */
239 if (at + len >= prog->strings_count)
240 at = prog->tempstring_start;
242 /* when it doesn't fit, reallocate */
243 if (at + len >= prog->strings_count)
245 prog->strings_count = at;
246 if (!qc_program_strings_append(prog, str, len+1)) {
247 prog->vmerror = VMERR_TEMPSTRING_ALLOC;
253 /* when it fits, just copy */
254 memcpy(prog->strings + at, str, len+1);
255 prog->tempstring_at += len+1;
259 /***********************************************************************
260 * main for when building the standalone executor
263 #if defined(QCVM_EXECUTOR)
264 int main(int argc, char **argv)
270 printf("usage: %s file\n", argv[0]);
274 prog = prog_load(argv[1]);
276 printf("failed to load program '%s'\n", argv[1]);
280 for (i = 0; i < prog->functions_count; ++i) {