pvmfunc STDCALL load_commonfunc( pubyte* input, pubyte* out, pubyte* end, puint size )
{
pvmfunc pfunc;
pubyte ptr = *input;
uint i;
// Проверка на повторный вызов
ptr = load_common( ptr, out, *size );
*end = *input + _vm.isize;
pfunc = ( pvmfunc )_vm.pmng->top;
pfunc->vmo.flag |= GHRT_MAYCALL;
pfunc->ret = load_var( &ptr, out, 1, size, 1 );
pfunc->dwret = ( ubyte )(( povmtype )PCMD( pfunc->ret->type ))->stsize;
pfunc->parcount = ( ubyte )load_bwd( &ptr );
if ((uint)*out & 3 ) // Alignment
*out += 4 - ( (uint)*out & 3 );
// print("ret=%i %s %i\n", pfunc->ret->type,pfunc->vmo.name, pfunc->parcount );
pfunc->params = load_var( &ptr, out, pfunc->parcount, size, 1 );
for ( i = 0; i < pfunc->parcount; i++ )
{
pfunc->parsize += ( ubyte )((povmtype)PCMD( pfunc->params[i].type ))->stsize;//( ubyte )( *size >> 2 );
}
// print("%s ret = %i parsize = %i count = %i\n",
// pfunc->vmo.name, pfunc->ret->type, pfunc->parsize, pfunc->parcount );
*input = ptr;
return pfunc;
}
LoadVariableExpression* NodeBuilder::load_var(LString vname)
{
VariableSymbol* var = lookup_var(vname);
if (var == 0)
SUIF_THROW(SuifDevException(__FILE__, __LINE__,
String("Cannot find variable <") + vname +
">"));
return load_var(var);
}
/**
* Swap out variables of the form "$varname" with their value
*/
char *swap_vars(char *line, size_t size) {
char temp, *dest;
size_t readi = 0, writei = 0, dest_size = size;
/* New line with expanded variables */
dest = malloc(dest_size);
if(dest == NULL) {
printf("malloc failed: %s\n", strerror(errno));
exit(1);
}
while(readi < size && line[readi] != '\0') {
if(line[readi] == '$') {
char c = line[readi + 1];
char *var_name = line + readi + 1;
if(isalnum(c) || c == '?' || c == '$' || c == '_') {
readi += 2;
if(isalpha(c) || c == '_') {
while (isalnum(line[readi]) || line[readi] == '_') {
readi++;
}
}
/* Null terminate var_name */
temp = line[readi];
line[readi] = '\0';
/* Lookup var_name */
dest = dynamic_strcat(dest, &dest_size, &writei, load_var(var_name));
/*restore previous character at current readi */
line[readi] = temp;
continue;
}
/* Just drop to below write the '$' */
}
dest[writei++] = line[readi++];
if(writei + 1 >= dest_size) {
/* Realloc more space */
dest_size += PAGE_SIZE;
dest = realloc(dest, dest_size);
if(dest == NULL) {
printf("realloc failed: %s\n", strerror(errno));
exit(1);
}
}
}
dest[writei] = '\0';
free(line);
return dest;
}
pvmobj STDCALL load_bytecode( pubyte* input, uint mode )
{
povmbcode pbcode;
pvmobj ret;
pubyte out, end;
puint bcout;
pubyte ptr = *input;
uint size = sizeof( ovmbcode );
uint i, off, cmd, k;
// uint nobcode = 0; // 1 if there is not bytecode
_vm.loadmode = mode;
pbcode = ( povmbcode )load_commonfunc( &ptr, &out, &end, &size );
// print( "OK %s\n", pbcode->vmf.vmo.name );
pbcode->setcount = ( ubyte )load_bwd( &ptr );
if ( pbcode->setcount )
{
pbcode->sets = ( pvarset )out;
out += sizeof( varset ) * pbcode->setcount;
off = 0;
for ( i = 0; i < pbcode->setcount; i++ )
{
pbcode->sets[i].count = ( ushort )load_bwd( &ptr );
pbcode->sets[i].first = ( ushort )off;
off += pbcode->sets[i].count;
}
pbcode->vars = load_var( &ptr, &out, off, &size, 1 );
pbcode->varsize = size >> 2;
off = 0;
// Sets summary size of block local variables in uints
for ( i = 0; i < ( uint )( pbcode->setcount - 1 ); i++ )
{
pbcode->sets[i].off = off;
pbcode->sets[i].size =
pbcode->vars[ pbcode->sets[ i + 1 ].first ].off - off;
off += pbcode->sets[i].size;
}
pbcode->sets[ i ].size = pbcode->varsize - off;
pbcode->sets[ i ].off = off;
}
Expression* NodeBuilder::cstr_const(const char* value,
ProcedureDefinition* proc)
{
VariableSymbol* var = get_cstr_const_var(String(value), proc);
return load_var(var);
}
pvmobj STDCALL load_type( pubyte* input )
{
povmtype ptype;
pubyte out;
pubyte ptr = *input;
ptr = load_common( ptr, &out, sizeof( ovmtype ) );
ptype = ( povmtype )_vm.pmng->top;
ptype->size = 4;
ptype->stsize = 1;
ptype->index.type = 0;//TUint;
if ( ptype->vmo.flag & GHTY_INHERIT )
{
povmtype inherit;
ptype->inherit = load_convert( &ptr );
inherit = ( povmtype )PCMD( ptype->inherit );
// Наследуем index type от родителя
ptype->index.type = inherit->index.type;
ptype->index.oftype = inherit->index.oftype;
ptype->ftype[ FTYPE_OFTYPE ] = inherit->ftype[ FTYPE_OFTYPE ];
}
if ( ptype->vmo.flag & GHTY_INDEX )
{
ptype->index.type = load_convert( &ptr );
ptype->index.oftype = load_convert( &ptr );
}
if ( ptype->vmo.flag & GHTY_INITDEL )
{
ptype->ftype[ FTYPE_INIT ] = load_convert( &ptr );
ptype->ftype[ FTYPE_DELETE ] = load_convert( &ptr );
}
if ( ptype->vmo.flag & GHTY_EXTFUNC )
{
ptype->ftype[ FTYPE_OFTYPE ] = load_convert( &ptr );
ptype->ftype[ FTYPE_COLLECTION ] = load_convert( &ptr );
}
if ( ptype->vmo.flag & GHTY_ARRAY )
{
uint i, dim = load_convert( &ptr );
if ( dim <= MAX_MSR )
{
for ( i = 0; i < dim; i++ )
ptype->ftype[ FTYPE_ARRAY + i ] = load_convert( &ptr );
}
else
ptype->ftype[ FTYPE_ARRAY ] = dim;
}
ptype->count = load_bwd( &ptr );
if ( ptype->vmo.flag & GHTY_STACK )
{
ptype->size = ptype->count;
ptype->stsize = ptype->size > sizeof( uint ) ? 2 : 1;
ptype->count = 0;
}
else
if ( ptype->count )
{
ptype->children = load_var( &ptr, &out, ptype->count, &ptype->size, 0 );
}
load_addobj( 0 );
vmmng_end( out );
// print("id= %i name= %s s=%i/%i ind = %i\n", ptype->vmo.id, ptype->vmo.name, ptype->size,
// ptype->stsize, ptype->index.type );
*input += _vm.isize;
return ( pvmobj )ptype;
}
