uint32_t code_genstring(code_t *code, const char *str) {
size_t hash;
code_hash_entry_t existing;
if (!str)
return 0;
if (!*str) {
if (!code->string_cached_empty) {
code->string_cached_empty = vec_size(code->chars);
vec_push(code->chars, 0);
}
return code->string_cached_empty;
}
if (OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS)) {
hash = ((unsigned char*)str)[strlen(str)-1];
CODE_HASH_ENTER(existing) = code_util_str_htgeth(code->string_cache, str, hash);
} else {
hash = util_hthash(code->string_cache, str);
CODE_HASH_ENTER(existing) = util_htgeth(code->string_cache, str, hash);
}
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);
util_htseth(code->string_cache, str, hash, CODE_HASH_ENTER(existing));
return CODE_HASH_LEAVE(existing);
}
qcint prog_tempstring(qc_program *prog, const char *_str)
{
/* we don't access it, but the macro-generated functions don't use
* const
*/
char *str = (char*)_str;
size_t len = strlen(str);
size_t at = prog->tempstring_at;
/* when we reach the end we start over */
if (at + len >= vec_size(prog->strings))
at = prog->tempstring_start;
/* when it doesn't fit, reallocate */
if (at + len >= vec_size(prog->strings))
{
(void)vec_add(prog->strings, len+1);
memcpy(prog->strings + at, str, len+1);
return at;
}
/* when it fits, just copy */
memcpy(prog->strings + at, str, len+1);
prog->tempstring_at += len+1;
return at;
}
Dim Dim::transpose_dim() const {
switch (type()) {
case SCALAR: return *this;
case ROW_VECTOR: return col_vec(vec_size());
case COL_VECTOR: return row_vec(vec_size());
case MATRIX: return matrix(dim3,dim2);
case MATRIX_ARRAY:
default: throw DimException("cannot transpose an array of matrices");
return *this;
}
}
folgen_vektor_p
folgen_vektor_faltung(folgen_vektor_p f, folgen_matrix_p Gamma) {
folgen_vektor_p back;
vec_p vec_1, n_1, n_2, grad_1, grad_2, r, s;
int k, j, a, b;
int size_1, size_2, dim;
folge_p temp, temp1, sum;
ASSERT( f->grad->dim == Gamma->grad1->dim );
dim = f->grad->dim;
vec_1 = vec_one(dim);
grad_2 = vec_min( f->grad, Gamma->grad2 );
n_2 = vec_add( grad_2, vec_1 );
size_2 = vec_size( n_2 );
grad_1 = vec_copy( Gamma->grad1 );
n_1 = vec_add( grad_1, vec_1 );
size_1 = vec_size( n_1 );
back = folgen_vektor_new( grad_1 );
for(k=0;k<size_1;k++) {
sum = folge_new( vec_new(dim), vec_new(dim) );
for(j=0;j<size_2;j++) {
r = entry_one2d( j, n_2 );
s = vec_add( f->grad, vec_1 );
a = entry_d2one( r, s );
vec_del( s );
s = vec_add( Gamma->grad2, vec_1 );
b = entry_d2one( r, s );
vec_del( s );
vec_del( r );
temp = folge_faltung( f->vektor[a], Gamma->matrix[k][b] );
temp1 = folge_add( sum, temp );
folge_del( temp );
folge_del( sum );
sum = temp1;
}
folge_del( back->vektor[k] );
back->vektor[k] = sum;
}
vec_del( n_1 );
vec_del( n_2 );
vec_del( grad_2 );
vec_del( vec_1 );
return back;
}
static qcint_t prog_enterfunction(qc_program_t *prog, prog_section_function_t *func) {
qc_exec_stack_t st;
size_t parampos;
int32_t p;
/* back up locals */
st.localsp = vec_size(prog->localstack);
st.stmt = prog->statement;
st.function = func;
if (prog->xflags & VMXF_TRACE) {
const char *str = prog_getstring(prog, func->name);
vec_push(prog->function_stack, str);
}
#ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
if (vec_size(prog->stack))
{
prog_section_function_t *cur;
cur = prog->stack[vec_size(prog->stack)-1].function;
if (cur)
{
qcint_t *globals = &prog->globals[0] + cur->firstlocal;
vec_append(prog->localstack, cur->locals, globals);
}
}
#else
{
qcint_t *globals = &prog->globals[0] + func->firstlocal;
vec_append(prog->localstack, func->locals, globals);
}
#endif
/* copy parameters */
parampos = func->firstlocal;
for (p = 0; p < func->nargs; ++p)
{
size_t s;
for (s = 0; s < func->argsize[p]; ++s) {
prog->globals[parampos] = prog->globals[OFS_PARM0 + 3*p + s];
++parampos;
}
}
vec_push(prog->stack, st);
return func->entry;
}
void fold_cleanup(fold_t *fold) {
size_t i;
for (i = 0; i < vec_size(fold->imm_float); ++i) ast_delete(fold->imm_float[i]);
for (i = 0; i < vec_size(fold->imm_vector); ++i) ast_delete(fold->imm_vector[i]);
for (i = 0; i < vec_size(fold->imm_string); ++i) ast_delete(fold->imm_string[i]);
vec_free(fold->imm_float);
vec_free(fold->imm_vector);
vec_free(fold->imm_string);
util_htdel(fold->imm_string_untranslate);
util_htdel(fold->imm_string_dotranslate);
mem_d(fold);
}
char *correct_str(correction_t *corr, correct_trie_t* table, const char *ident) {
char **e1 = NULL;
char **e2 = NULL;
char *e1ident = NULL;
char *e2ident = NULL;
size_t e1rows = 0;
size_t e2rows = 0;
size_t *bits = NULL;
/* needs to be allocated for free later */
if (correct_find(table, ident))
return correct_pool_claim(ident);
if ((e1rows = correct_size(ident))) {
if (vec_size(corr->edits) > 0)
e1 = corr->edits[0];
else {
e1 = correct_edit(ident, &bits);
vec_push(corr->edits, e1);
vec_push(corr->lens, bits);
}
if ((e1ident = correct_maximum(table, e1, e1rows)))
return correct_pool_claim(e1ident);
}
e2 = correct_known(corr, table, e1, e1rows, &e2rows);
if (e2rows && ((e2ident = correct_maximum(table, e2, e2rows))))
return correct_pool_claim(e2ident);
return util_strdup(ident);
}
static void task_template_destroy(task_template_t *tmpl) {
if (!tmpl)
return;
if (tmpl->description) mem_d(tmpl->description);
if (tmpl->proceduretype) mem_d(tmpl->proceduretype);
if (tmpl->compileflags) mem_d(tmpl->compileflags);
if (tmpl->executeflags) mem_d(tmpl->executeflags);
if (tmpl->sourcefile) mem_d(tmpl->sourcefile);
if (tmpl->rulesfile) mem_d(tmpl->rulesfile);
if (tmpl->testflags) mem_d(tmpl->testflags);
/*
* Delete all allocated string for task tmpl then destroy the
* main vector.
*/
{
size_t i = 0;
for (; i < vec_size(tmpl->comparematch); i++)
mem_d(tmpl->comparematch[i]);
vec_free(tmpl->comparematch);
}
/*
* Nullify all the template members otherwise NULL comparision
* checks will fail if tmpl pointer is reused.
*/
mem_d(tmpl->tempfilename);
mem_d(tmpl);
}
static void prog_main_setparams(qc_program_t *prog) {
size_t i;
qcany_t *arg;
for (i = 0; i < vec_size(main_params); ++i) {
arg = GetGlobal(OFS_PARM0 + 3*i);
arg->vector[0] = 0;
arg->vector[1] = 0;
arg->vector[2] = 0;
switch (main_params[i].vtype) {
case TYPE_VECTOR:
(void)util_sscanf(main_params[i].value, " %f %f %f ",
&arg->vector[0],
&arg->vector[1],
&arg->vector[2]);
break;
case TYPE_FLOAT:
arg->_float = atof(main_params[i].value);
break;
case TYPE_STRING:
arg->string = prog_tempstring(prog, main_params[i].value);
break;
default:
fprintf(stderr, "error: unhandled parameter type: %i\n", main_params[i].vtype);
break;
}
}
}
void
folge_print(folge_p f, int info) {
int k, dim, size;
dim = f->lang->dim;
printf("\n------------------------------------------------------------");
printf("\n#Ausgabe einer Folge der Dimension %d", dim);
printf("\n\t#:start");
for(k=0;k<dim;k++){
printf("\t %d",f->start->array[k]);
}
printf("\n\t#:lang");
for(k=0;k<dim;k++){
printf("\t %d",f->lang->array[k]);
}
size = vec_size( f->lang );
if(info == 1) {
printf("\n\t#:glied");
for(k=0;k<size;k++) {
printf("\t%.3lf",f->glied[k]);
}
}
printf("\n------------------------------------------------------------\n");
return;
}
folge_p
folge_build(int dim, int a, int n, int mod, bool_t random) {
vec_p start, lang;
int k, size;
fepc_real_t *glied;
folge_p back;
ASSERT(a>=0);
ASSERT(n>0);
start = vec_new(dim);
lang = vec_new(dim);
for(k=0;k<dim;k++) {
if( random == true ) {
start->array[k] = rand()%(2*a +1 ) - a;
lang->array[k] = rand()%(n) +1;
}
else {
start->array[k] = a;
lang->array[k] = n;
}
}
back = folge_new(start,lang);
size = vec_size( lang );
glied = back->glied;
for (k=0;k<size;k++) {
glied[k] = rand()%(2*mod+1) - mod;
}
return back;
}
folge_p
folge_new(vec_p start,vec_p lang) {
folge_p back;
fepc_real_t *glied;
int k,size;
/*Testen auf Konsistenz*/
ASSERT(start->dim == lang->dim);
for(k=0;k<lang->dim;k++) {
ASSERT( lang->array[k] >= 0 );
}
back = (folge_p) malloc(sizeof(folge_t));
ASSERT(back != NULL);
size = vec_size( lang );
glied = (fepc_real_t*) malloc(sizeof(fepc_real_t)*size);
ASSERT(glied != NULL);
for (k=0;k<size;k++) {
glied[k] = 0.0;
}
back->glied = glied;
back->lang = lang;
back->start = start;
return back;
}
qcany_t* prog_getedict(qc_program_t *prog, qcint_t e) {
if (e >= (qcint_t)vec_size(prog->entitypool)) {
prog->vmerror++;
fprintf(stderr, "Accessing out of bounds edict %i\n", (int)e);
e = 0;
}
return (qcany_t*)(prog->entitydata + (prog->entityfields * e));
}
static bool pak_close(pak_file_t *pak) {
size_t itr;
long tell;
if (!pak)
return false;
/*
* In insert mode we need to patch the header, and write
* our directory entries at the end of the file.
*/
if (pak->insert) {
if ((tell = fs_file_tell(pak->handle)) != 0)
goto err;
pak->header.dirlen = vec_size(pak->directories) * 64;
pak->header.diroff = tell;
/* patch header */
if (fs_file_seek (pak->handle, 0, SEEK_SET) != 0)
goto err;
fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
/* write directories */
if (fs_file_seek (pak->handle, pak->header.diroff, SEEK_SET) != 0)
goto err;
for (itr = 0; itr < vec_size(pak->directories); itr++) {
fs_file_write(&(pak->directories[itr]), sizeof(pak_directory_t), 1, pak->handle);
}
}
vec_free (pak->directories);
fs_file_close(pak->handle);
mem_d (pak);
return true;
err:
vec_free (pak->directories);
fs_file_close(pak->handle);
mem_d (pak);
return false;
}
prog_section_def* prog_entfield(qc_program *prog, qcint 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;
}
prog_section_def* prog_getdef(qc_program *prog, qcint 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;
}
static GMQCC_INLINE void correct_pool_delete(void) {
size_t i;
for (i = 0; i < vec_size(correct_pool_data); ++i)
mem_d(correct_pool_data[i]);
correct_pool_data = NULL;
correct_pool_this = NULL;
correct_pool_addr = 0;
}
bool fold_generate(fold_t *fold, ir_builder *ir) {
/* generate globals for immediate folded values */
size_t i;
ast_value *cur;
for (i = 0; i < vec_size(fold->imm_float); ++i)
if (!ast_global_codegen ((cur = fold->imm_float[i]), ir, false)) goto err;
for (i = 0; i < vec_size(fold->imm_vector); ++i)
if (!ast_global_codegen((cur = fold->imm_vector[i]), ir, false)) goto err;
for (i = 0; i < vec_size(fold->imm_string); ++i)
if (!ast_global_codegen((cur = fold->imm_string[i]), ir, false)) goto err;
return true;
err:
con_out("failed to generate global %s\n", cur->name);
ir_builder_delete(ir);
return false;
}
void
moto_freeTreeCells(MotoEnv *env) {
MotoTree *tree = env->tree;
Vector *cells = tree->cells;
int size = vec_size(cells);
int i;
for (i = 0; i < size; i++) {
moto_freeCell(env, vec_get(cells, i));
}
}
void correct_del(correct_trie_t* dictonary, size_t **data) {
size_t i;
const size_t vs = vec_size(data);
for (i = 0; i < vs; i++)
mem_d(data[i]);
vec_free(data);
correct_trie_del(dictonary);
}
bool code_write(code_t *code, const char *filename, const char *lnofile) {
prog_header_t code_header;
fs_file_t *fp = NULL;
code_create_header(code, &code_header, filename, lnofile);
if (lnofile) {
uint32_t version = 1;
fp = fs_file_open(lnofile, "wb");
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]));
if (fs_file_write("LNOF", 4, 1, fp) != 1 ||
fs_file_write(&version, sizeof(version), 1, fp) != 1 ||
fs_file_write(&code_header.defs.length, sizeof(code_header.defs.length), 1, fp) != 1 ||
fs_file_write(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
fs_file_write(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
fs_file_write(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
fs_file_write(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums) ||
fs_file_write(code->columnnums, sizeof(code->columnnums[0]), vec_size(code->columnnums), fp) != vec_size(code->columnnums))
{
con_err("failed to write lno file\n");
}
fs_file_close(fp);
fp = NULL;
}
fp = fs_file_open(filename, "wb");
if (!fp)
return false;
if (1 != fs_file_write(&code_header, sizeof(prog_header_t) , 1 , fp) ||
vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) ||
vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) ||
vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) ||
vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) ||
vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) ||
vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp))
{
fs_file_close(fp);
return false;
}
fs_file_close(fp);
code_stats(filename, lnofile, code, &code_header);
return true;
}
folge_p
folge_add(folge_p f, folge_p g) {
folge_p back;
int size, k, size_g, size_f;
fepc_real_t x, y;
vec_p temp1, temp2, max, lang, min, r;
size_f = vec_size( f->lang );
size_g = vec_size( g->lang );
if(size_f == 0) {
back = folge_copy( g );
return back;
}
if(size_g == 0) {
back = folge_copy( f );
return back;
}
if( (size_g!=0) && (size_f!=0) ) {
min = vec_min( f->start, g->start );
temp1 = vec_add( f->start, f->lang );
temp2 = vec_add( g->start, g->lang );
max = vec_max( temp1, temp2 );
vec_del( temp1 );
vec_del( temp2 );
lang = vec_op( 1, max, -1, min);
vec_del( max );
back = folge_new( min, lang );
size = vec_size( lang );
for(k=0;k<size;k++) {
temp1 = entry_one2d( k, lang );
r = vec_add( min, temp1 );
vec_del( temp1 );
x = folge_glied( r, f );
y = folge_glied( r, g );
vec_del( r );
back->glied[k] = x + y;
}
return back;
}
}
folgen_vektor_p
folgen_vektor_add(folgen_vektor_p f, folgen_vektor_p g) {
folgen_vektor_p back;
int k, d, size, dim, a, b, test_f, test_g;
vec_p max, vec_1, n, n_f, n_g, r;
ASSERT( f->grad->dim == g->grad->dim );
dim = f->grad->dim;
max = vec_max( f->grad, g->grad );
vec_1 = vec_one( dim );
n = vec_add( vec_1, max );
n_f = vec_add( vec_1, f->grad );
n_g = vec_add( vec_1, g->grad );
size = vec_size( n );
back = folgen_vektor_new( max );
for(k=0;k<size;k++) {
r = entry_one2d( k, n );
test_f = 0;
test_g = 0;
for(d=0;d<dim;d++) {
if( r->array[d] > f->grad->array[d] ) {
test_f = test_f + 1;
}
if( r->array[d] > g->grad->array[d] ) {
test_g = test_g + 1;
}
}
if( (test_f == 0) && (test_g == 0) ) {
a = entry_d2one( r, n_f );
b = entry_d2one( r, n_g );
folge_del( back->vektor[k] );
back->vektor[k] = folge_add( f->vektor[a], g->vektor[b] );
}
if( (test_f != 0) && (test_g == 0) ) {
b = entry_d2one( r, n_g );
folge_del( back->vektor[k] );
back->vektor[k] = folge_copy( g->vektor[b] );
}
if( (test_f == 0) && (test_g != 0) ) {
a = entry_d2one( r, n_f );
folge_del( back->vektor[k] );
back->vektor[k] = folge_copy( f->vektor[a] );
}
vec_del( r );
}
vec_del( n );
vec_del( n_f );
vec_del( n_g );
vec_del( vec_1 );
return back;
}
static qcint_t prog_leavefunction(qc_program_t *prog) {
prog_section_function_t *prev = nullptr;
size_t oldsp;
qc_exec_stack_t st = vec_last(prog->stack);
if (prog->xflags & VMXF_TRACE) {
if (vec_size(prog->function_stack))
vec_pop(prog->function_stack);
}
#ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
if (vec_size(prog->stack) > 1) {
prev = prog->stack[vec_size(prog->stack)-2].function;
oldsp = prog->stack[vec_size(prog->stack)-2].localsp;
}
#else
prev = prog->stack[vec_size(prog->stack)-1].function;
oldsp = prog->stack[vec_size(prog->stack)-1].localsp;
#endif
if (prev) {
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);
}
vec_pop(prog->stack);
return st.stmt - 1; /* offset the ++st */
}
static bool pak_extract_all(pak_file_t *pak, const char *dir) {
size_t itr;
if (!fs_dir_make(dir))
return false;
for (itr = 0; itr < vec_size(pak->directories); itr++) {
if (!pak_extract_one(pak, pak->directories[itr].name, dir))
return false;
}
return true;
}
char *mfn_symbolName(MFN *p) {
if (p->cname == NULL) {
int i;
int argc = vec_size(p->argv);
StringBuffer *buf = buf_create(32);
/* If the classname is not null then this is a method and the classname
should prefix the generated cname */
if (p->classn != NULL)
buf_printf(buf, "_%s",p->classn);
/* If the fname starts with '~' (i.e. this is a destructor) convert it
into an '_' */
if (p->fname[0] == '~')
buf_printf(buf,"__%s__", p->fname+1);
else
buf_printf(buf, "_%s__", p->fname);
for (i = 0; i < argc; i++) {
FNArg *arg = (FNArg *)vec_get(p->argv, i);
int l = strlen(arg->type);
/* Output one P for each dimension of an array argument */
while(arg->type[l-1] == ']'){ buf_putc(buf,'P'); l -= 2; }
/* For built in types output the first letter of the
type name for the argument */
if(l == 3 && !strncmp(arg->type,"int",l)) buf_putc(buf,'i');
else if(l == 5 && !strncmp(arg->type,"float",l)) buf_putc(buf,'f');
else if(l == 6 && !strncmp(arg->type,"double",l)) buf_putc(buf,'d');
else if(l == 4 && !strncmp(arg->type,"char",l)) buf_putc(buf,'c');
else if(l == 4 && !strncmp(arg->type,"long",l)) buf_putc(buf,'l');
else if(l == 7 && !strncmp(arg->type,"boolean",l)) buf_putc(buf,'b');
else if(l == 4 && !strncmp(arg->type,"byte",l)) buf_putc(buf,'y');
else if(l == 6 && !strncmp(arg->type,"String",l)) buf_putc(buf,'S');
else if(l == 6 && !strncmp(arg->type,"Object",l)) buf_putc(buf,'O');
else if(arg->type[l-1] == ')') buf_putc(buf,'F');
else { buf_puti(buf, l); buf_put(buf,arg->type,l); }
}
p->cname = buf_toString(buf);
buf_free(buf);
}
return p->cname;
}
void mfn_dump(MFN *p) {
Enumeration *e;
printf("MFN--------------------\n");
printf("rtype: %s\n", p->rtype);
printf("fname: %s\n", p->fname);
printf("argc: %d\n", vec_size(p->argv));
printf("argv: \n");
e = vec_elements(p->argv);
while(enum_hasNext(e)) {
FNArg *arg = (FNArg *)enum_next(e);
printf("\t%s %s\n", arg->type, arg->name);
}
enum_free(e);
printf("--------------------------------\n");
}
static qcint_t prog_spawn_entity(qc_program_t *prog) {
char *data;
qcint_t e;
for (e = 0; e < (qcint_t)vec_size(prog->entitypool); ++e) {
if (!prog->entitypool[e]) {
data = (char*)(prog->entitydata + (prog->entityfields * e));
memset(data, 0, prog->entityfields * sizeof(qcint_t));
return e;
}
}
vec_push(prog->entitypool, true);
prog->entities++;
data = (char*)vec_add(prog->entitydata, prog->entityfields);
memset(data, 0, prog->entityfields * sizeof(qcint_t));
return e;
}
folge_p
folge_copy( folge_p f) {
folge_p back;
int k, size;
vec_p start, lang;
start = vec_copy( f->start );
lang = vec_copy( f->lang );
size = vec_size( lang );
back = folge_new( start, lang );
for(k=0;k<size;k++) {
back->glied[k] = f->glied[k];
}
return back;
}
static void prog_free_entity(qc_program_t *prog, qcint_t e) {
if (!e) {
prog->vmerror++;
fprintf(stderr, "Trying to free world entity\n");
return;
}
if (e >= (qcint_t)vec_size(prog->entitypool)) {
prog->vmerror++;
fprintf(stderr, "Trying to free out of bounds entity\n");
return;
}
if (!prog->entitypool[e]) {
prog->vmerror++;
fprintf(stderr, "Double free on entity\n");
return;
}
prog->entitypool[e] = false;
}
