/* * Get a filename in cache for given md5sum. */ const char *filecache_getpath(TARGET *t) { char buffer[1024]; LIST *filecache; const char *cachedir = NULL; LIST *cachevar; pushsettings( t->settings ); filecache = var_get( "FILECACHE" ); if ( !filecache ) { popsettings( t->settings ); return NULL; } /* get directory where objcache should reside */ strcpy( buffer, filecache->string ); strcat( buffer, ".PATH" ); cachevar = var_get( buffer ); if( cachevar ) { TARGET *t = bindtarget( cachevar->string ); t->boundname = search( t->name, &t->time ); cachedir = copystr( t->boundname ); } popsettings( t->settings ); return cachedir; }
void headers( TARGET *t ) { LIST *hdrscan; LIST *hdrrule; LIST *hdrcache; LOL lol; if( !( hdrscan = var_get( "HDRSCAN" ) ) || !( hdrrule = var_get( "HDRRULE" ) ) ) return; /* Doctor up call to HDRRULE rule */ /* Call headers1() to get LIST of included files. */ if( DEBUG_HEADER ) printf( "header scan %s\n", t->name ); lol_init( &lol ); lol_add( &lol, list_new( L0, t->name, 1 ) ); lol_add( &lol, headers1( t->boundname, hdrscan ) ); if( lol_get( &lol, 1 ) ) list_free( evaluate_rule( 0, hdrrule->string, &lol, L0 ) ); /* Clean up */ lol_free( &lol ); }
LIST *filecache_fillvalues(TARGET *t) { LIST *filecache; if ( !( t->flags & T_FLAG_USEFILECACHE ) ) return 0; filecache = var_get( "FILECACHE" ); if ( filecache ) { LIST *l; BUFFER buff; buffer_init(&buff); buffer_addstring(&buff, filecache->string, strlen(filecache->string)); buffer_addstring(&buff, ".USE", 4); buffer_addchar(&buff, 0); l = var_get( buffer_ptr( &buff ) ); if ( l && atoi( l->string ) != 0) { t->filecache_use = 1; } buffer_free(&buff); buffer_init(&buff); buffer_addstring(&buff, filecache->string, strlen(filecache->string)); buffer_addstring(&buff, ".GENERATE", 9); buffer_addchar(&buff, 0); l = var_get( buffer_ptr( &buff ) ); if ( l && atoi( l->string ) != 0) { t->filecache_generate = 1; } buffer_free(&buff); } return filecache; }
/******************************************************************** * FUNCTION do_show_var (sub-mode of local RPC) * * show full info for one user var * * INPUTS: * server_cb == server control block to use * name == variable name to find * isglobal == TRUE if global var, FALSE if local var * isany == TRUE if don't care (global or local) * == FALSE to force local or global with 'isglobal' * mode == help mode requested * * RETURNS: * status *********************************************************************/ static status_t do_show_var (server_cb_t *server_cb, const xmlChar *name, var_type_t vartype, boolean isany, help_mode_t mode) { val_value_t *val; logfn_t logfn; boolean imode; imode = interactive_mode(); if (imode) { logfn = log_stdout; } else { logfn = log_write; } if (isany) { /* skipping VAR_TYP_SESSION for now */ val = var_get_local(server_cb->runstack_context, name); if (val) { vartype = VAR_TYP_LOCAL; } else { val = var_get(server_cb->runstack_context, name, VAR_TYP_GLOBAL); if (val) { vartype = VAR_TYP_GLOBAL; } else { val = var_get(server_cb->runstack_context, name, VAR_TYP_CONFIG); if (val) { vartype = VAR_TYP_CONFIG; } else { val = var_get(server_cb->runstack_context, name, VAR_TYP_SYSTEM); if (val) { vartype = VAR_TYP_SYSTEM; } } } } } else { val = var_get(server_cb->runstack_context, name, vartype); } if (val) { show_user_var(server_cb, name, vartype, val, mode); (*logfn)("\n"); } else { (*logfn)("\nVariable '%s' not found", name); return ERR_NCX_DEF_NOT_FOUND; } return NO_ERR; } /* do_show_var */
void headers( TARGET * t ) { LIST * hdrscan; LIST * hdrrule; #ifndef OPT_HEADER_CACHE_EXT LIST * headlist = L0; #endif regexp * re[ MAXINC ]; int rec = 0; LISTITER iter, end; hdrscan = var_get( root_module(), constant_HDRSCAN ); if ( list_empty( hdrscan ) ) return; hdrrule = var_get( root_module(), constant_HDRRULE ); if ( list_empty( hdrrule ) ) return; if ( DEBUG_HEADER ) printf( "header scan %s\n", object_str( t->name ) ); /* Compile all regular expressions in HDRSCAN */ iter = list_begin( hdrscan ), end = list_end( hdrscan ); for ( ; ( rec < MAXINC ) && iter != end; iter = list_next( iter ) ) { re[ rec++ ] = regex_compile( list_item( iter ) ); } /* Doctor up call to HDRRULE rule */ /* Call headers1() to get LIST of included files. */ { FRAME frame[1]; frame_init( frame ); lol_add( frame->args, list_new( object_copy( t->name ) ) ); #ifdef OPT_HEADER_CACHE_EXT lol_add( frame->args, hcache( t, rec, re, hdrscan ) ); #else lol_add( frame->args, headers1( headlist, t->boundname, rec, re ) ); #endif if ( lol_get( frame->args, 1 ) ) { /* The third argument to HDRRULE is the bound name of * $(<) */ lol_add( frame->args, list_new( object_copy( t->boundname ) ) ); list_free( evaluate_rule( list_front( hdrrule ), frame ) ); } /* Clean up. */ frame_free( frame ); } }
LIST * headers1( const char *file, LIST *hdrscan ) { FILE *f; LIST *result = 0; LIST *hdrpipe; LIST *hdrpipefile; if ( list_first(hdrpipe = var_get( "HDRPIPE" )) ) { LOL args; BUFFER buff; lol_init( &args ); lol_add( &args, list_append( L0, file, 0 ) ); buffer_init( &buff ); if ( var_string( list_value(list_first(hdrpipe)), &buff, 0, &args, ' ') < 0 ) { printf( "Cannot expand HDRPIPE '%s' !\n", list_value(list_first(hdrpipe)) ); exit( EXITBAD ); } buffer_addchar( &buff, 0 ); if ( !( f = file_popen( (const char*)buffer_ptr( &buff ), "r" ) ) ) { buffer_free( &buff ); return result; } buffer_free( &buff ); lol_free( &args ); } else { if( !( f = fopen( file, "r" ) ) ) return result; } result = headers1helper( f, hdrscan ); if ( list_first(hdrpipe) ) file_pclose( f ); else fclose( f ); if ( list_first(hdrpipefile = var_get( "HDRPIPEFILE" )) ) { if( !( f = fopen( list_value(list_first(hdrpipefile)), "r" ) ) ) return result; result = headers1helper( f, hdrscan ); fclose( f ); } return result; }
void headers( TARGET *t ) { LIST *hdrscan; LIST *hdrrule; LIST *headlist = 0; regexp *re[ MAXINC ]; int rec = 0; if( !( hdrscan = var_get( "HDRSCAN" ) ) || !( hdrrule = var_get( "HDRRULE" ) ) ) return; if( DEBUG_HEADER ) printf( "header scan %s\n", t->name ); /* Compile all regular expressions in HDRSCAN */ while( rec < MAXINC && hdrscan ) { re[rec++] = regex_compile( hdrscan->string ); hdrscan = list_next( hdrscan ); } /* Doctor up call to HDRRULE rule */ /* Call headers1() to get LIST of included files. */ { FRAME frame[1]; frame_init( frame ); lol_add( frame->args, list_new( L0, t->name ) ); #ifdef OPT_HEADER_CACHE_EXT lol_add( frame->args, hcache( t, rec, re, hdrscan ) ); #else lol_add( frame->args, headers1( headlist, t->boundname, rec, re ) ); #endif if( lol_get( frame->args, 1 ) ) { /* The third argument to HDRRULE is the bound name of * $(<) */ lol_add( frame->args, list_new( L0, t->boundname ) ); list_free( evaluate_rule( hdrrule->string, frame ) ); } /* Clean up */ frame_free( frame ); } }
int get_lf(char str[], vararray* funcs, int shift, int step) { DBGPRINT("NAME: \"%s\", shift of call/jump: %d\n", str, shift); for (int i = 0; i < (funcs->nmax); i++) { DBGPRINT("NAME: %s; SHIFT: %d\n", ((func_t*)var_get(funcs, i))->name, (((func_t*)var_get(funcs, i))->shift-shift)); if (!strcmp(str, ((func_t*)var_get(funcs, i))->name)) { return (((func_t*)var_get(funcs, i))->shift-shift);//QUESTION:why shift relates to another shift? } } if (step > 1) USERERR("No function/label found for %s\n", str); }
void call_bind_rule( OBJECT * target_, OBJECT * boundname_ ) { LIST * const bind_rule = var_get( root_module(), constant_BINDRULE ); if ( !list_empty( bind_rule ) ) { OBJECT * target = object_copy( target_ ); OBJECT * boundname = object_copy( boundname_ ); if ( boundname && target ) { /* Prepare the argument list. */ FRAME frame[ 1 ]; frame_init( frame ); /* First argument is the target name. */ lol_add( frame->args, list_new( target ) ); lol_add( frame->args, list_new( boundname ) ); if ( lol_get( frame->args, 1 ) ) { OBJECT * rulename = list_front( bind_rule ); list_free( evaluate_rule( bindrule( rulename, root_module() ), rulename, frame ) ); } /* Clean up */ frame_free( frame ); } else { if ( boundname ) object_free( boundname ); if ( target ) object_free( target ); } } }
void undump(char *s) { at *atf = OPEN_READ(s,0); FILE *f = Gptr(atf); int magic = readmagic32(f); int version = read32(f); if ( magic != DUMPMAGIC ) error(NIL, "incorrect dump file format", NIL); if ( version > DUMPVERSION ) error(NIL, "dump file format version not supported", NIL); /* The macro character map */ size_t sr = fread(char_map,1,256,f); if (sr < 256 || feof(f) || ferror(f)) error(NIL, "corrupted dump file (1)",NIL); /* The unified list */ at *val, *sym, *p = bread(f, NIL); while (CONSP(p)) { if (CONSP(Car(p))) { sym = Caar(p); val = Cdar(p); ifn (SYMBOLP(sym)) error(NIL, "corrupted dump file (4)", NIL); var_SET(sym, val); } else if (SYMBOLP(Car(p))) var_lock(Car(p)); val = p; p = Cdr(p); Cdr(val) = NIL; } /* define special symbols */ at_NULL = var_get(named("NULL")); }
static const char * cache_name( void ) { static OBJECT * name = 0; if ( !name ) { LIST * hcachevar = var_get( root_module(), constant_HCACHEFILE ); if ( !list_empty( hcachevar ) ) { TARGET * t = bindtarget( list_front( hcachevar ) ); pushsettings( root_module(), t->settings ); /* Do not expect the cache file to be generated, so pass 0 as the * third argument to search. Expect the location to be specified via * LOCATE, so pass 0 as the fourth arugment. */ object_free( t->boundname ); t->boundname = search( t->name, &t->time, 0, 0 ); popsettings( root_module(), t->settings ); name = object_copy( t->boundname ); } } return name ? object_str( name ) : 0; }
static const char * cache_name( void ) { static OBJECT * name = 0; if ( !name ) { OBJECT * hcachename = object_new( "HCACHEFILE" ); LIST * hcachevar = var_get( hcachename ); object_free( hcachename ); if ( hcachevar ) { TARGET * t = bindtarget( hcachevar->value ); pushsettings( t->settings ); /* Do not expect the cache file to be generated, so pass 0 as the * third argument to search. Expect the location to be specified via * LOCATE, so pass 0 as the fourth arugment. */ object_free( t->boundname ); t->boundname = search( t->name, &t->time, 0, 0 ); popsettings( t->settings ); if ( hcachevar ) name = object_copy( t->boundname ); } } return name ? object_str( name ) : 0; }
void load_file(FILE* source, vararray* lines) { char str[200]; line_t* cur_line = (line_t*)calloc(1, sizeof(line_t)); vararray* func_code = var_ctor(sizeof(line_t), 128); DBGPRINT("Lines: %d\n", (int)(lines->nmax)); while (fgets(str, 200, source)) { memset(cur_line, 0, sizeof(line_t)); if (!get_line(cur_line, str)) continue; if (!strcmp(cur_line->words[is_lable(cur_line->words[0])], "proc")) { var_push(func_code, cur_line); if(!load_function(source, func_code)) USERERR("No ret from function found."); } else { var_push(lines, cur_line); } DBGPRINT("Lines: %d\n", (int)(lines->nmax)); DBGPRINT("String: %s\nKeyword: \"%s\"\n", str, cur_line->words[0]); } for (int i = 0; i < func_code->nmax; i++) var_push(lines, var_get(func_code, i)); var_dtor(func_code); }
void filecache_disable(TARGET *t) { BUFFER buff; LIST *filecache; char const* filecacheStr; pushsettings( t->settings ); filecache = var_get( "FILECACHE" ); if ( !list_first(filecache) ) { popsettings( t->settings ); return; } filecacheStr = list_value(list_first(filecache)); buffer_init(&buff); buffer_addstring(&buff, filecacheStr, strlen(filecacheStr)); buffer_addstring(&buff, ".USE", 4); buffer_addchar(&buff, 0); var_set(buffer_ptr(&buff), list_append(L0, "0", 0), VAR_SET); buffer_free(&buff); buffer_init(&buff); buffer_addstring(&buff, filecacheStr, strlen(filecacheStr)); buffer_addstring(&buff, ".GENERATE", 9); buffer_addchar(&buff, 0); var_set(buffer_ptr(&buff), list_append(L0, "0", 0), VAR_SET); buffer_free(&buff); }
static SETTINGS * make1settings( LIST *vars ) { SETTINGS *settings = 0; for( ; vars; vars = list_next( vars ) ) { LIST *l = var_get( vars->string ); LIST *nl = 0; for( ; l; l = list_next( l ) ) { TARGET *t = bindtarget( l->string ); /* Make sure the target is bound, warning if it is not in the */ /* dependency graph. */ if( t->binding == T_BIND_UNBOUND ) make1bind( t, 1 ); /* Build new list */ nl = list_new( nl, t->boundname, 1 ); } /* Add to settings chain */ settings = addsettings( settings, 0, vars->string, nl ); } return settings; }
/* Look up the __TIMING_RULE__ variable on the given target, and if * non-empty, invoke the rule it names, passing the given * timing_info */ static void call_timing_rule(TARGET* target, timing_info* time) { LIST* timing_rule; pushsettings(target->settings); timing_rule = var_get( "__TIMING_RULE__" ); popsettings(target->settings); if (timing_rule) { /* We'll prepend $(__TIMING_RULE__[2-]) to the first argument */ LIST* initial_args = list_copy( L0, timing_rule->next ); /* Prepare the argument list */ FRAME frame[1]; frame_init( frame ); /* First argument is the name of the timed target */ lol_add( frame->args, list_new( initial_args, target->name ) ); append_double_string(frame->args, time->user); append_double_string(frame->args, time->system); if( lol_get( frame->args, 2 ) ) evaluate_rule( timing_rule->string, frame ); /* Clean up */ frame_free( frame ); } }
static SETTINGS * make1settings( LIST *vars ) { SETTINGS *settings = 0; for( ; vars; vars = list_next( vars ) ) { LIST *l = var_get( vars->string ); LIST *nl = 0; for( ; l; l = list_next( l ) ) { TARGET *t = bindtarget( l->string ); /* Make sure the target is bound */ if( t->binding == T_BIND_UNBOUND ) make1bind( t ); /* Build new list */ nl = list_new( nl, copystr( t->boundname ) ); } /* Add to settings chain */ settings = addsettings( settings, 0, vars->string, nl ); } return settings; }
static SETTINGS * make1settings( struct module_t * module, LIST * vars ) { SETTINGS * settings = 0; LISTITER vars_iter = list_begin( vars ); LISTITER const vars_end = list_end( vars ); for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter ) ) { LIST * const l = var_get( module, list_item( vars_iter ) ); LIST * nl = L0; LISTITER iter = list_begin( l ); LISTITER const end = list_end( l ); for ( ; iter != end; iter = list_next( iter ) ) { TARGET * const t = bindtarget( list_item( iter ) ); /* Make sure the target is bound. */ if ( t->binding == T_BIND_UNBOUND ) make1bind( t ); /* Build a new list. */ nl = list_push_back( nl, object_copy( t->boundname ) ); } /* Add to settings chain. */ settings = addsettings( settings, VAR_SET, list_item( vars_iter ), nl ); } return settings; }
STATIC cmd_result_t cmd_esw_dma_get_size(int unit, args_t *a, int *size) { char *sz; if (size == NULL) { return CMD_FAIL; } if ((sz = ARG_GET(a)) != NULL) { switch (sz[0]) { case 'b': case 'B': *size = 1; return CMD_OK; case 'h': case 'H': *size = 2; return CMD_OK; case 'w': case 'W': *size = 4; return CMD_OK; default: ARG_PREV(a); } } if ((sz = var_get(CMD_ESW_DMA_SIZE)) == NULL) { *size = 1; /* Default are bytes */ return CMD_OK; } else { switch (sz[0]) { case 'b': case 'B': *size = 1; return CMD_OK; case 'h': case 'H': *size = 2; return CMD_OK; case 'w': case 'W': *size = 4; return CMD_OK; default: printk("Incorrect size specification <%s>\n", sz); return CMD_FAIL; } } return CMD_FAIL; }
void filecache_disable(TARGET *t) { BUFFER buff; LIST *filecache; pushsettings( t->settings ); filecache = var_get( "FILECACHE" ); if ( !filecache ) { popsettings( t->settings ); return; } buffer_init(&buff); buffer_addstring(&buff, filecache->string, strlen(filecache->string)); buffer_addstring(&buff, ".USE", 4); buffer_addchar(&buff, 0); var_set(buffer_ptr(&buff), list_new(L0, "0", 0), VAR_SET); buffer_free(&buff); buffer_init(&buff); buffer_addstring(&buff, filecache->string, strlen(filecache->string)); buffer_addstring(&buff, ".GENERATE", 9); buffer_addchar(&buff, 0); var_set(buffer_ptr(&buff), list_new(L0, "0", 0), VAR_SET); buffer_free(&buff); }
static void call_action_rule ( TARGET * target, int status, timing_info const * time, char const * executed_command, char const * command_output ) { LIST * action_rule; pushsettings( root_module(), target->settings ); action_rule = var_get( root_module(), constant_ACTION_RULE ); popsettings( root_module(), target->settings ); if ( !list_empty( action_rule ) ) { /* rule action-rule ( args * : target : command status start end user system : output ? ) */ /* Prepare the argument list. */ FRAME frame[ 1 ]; OBJECT * rulename = list_front( action_rule ); frame_init( frame ); /* args * :: $(__ACTION_RULE__[2-]) */ lol_add( frame->args, list_copy_range( action_rule, list_next( list_begin( action_rule ) ), list_end( action_rule ) ) ); /* target :: the name of the target */ lol_add( frame->args, list_new( object_copy( target->name ) ) ); /* command status start end user system :: info about the action command */ lol_add( frame->args, list_push_back( list_push_back( list_push_back( list_push_back( list_push_back( list_new( object_new( executed_command ) ), outf_int( status ) ), outf_time( &time->start ) ), outf_time( &time->end ) ), outf_double( time->user ) ), outf_double( time->system ) ) ); /* output ? :: the output of the action command */ if ( command_output ) lol_add( frame->args, list_new( object_new( command_output ) ) ); else lol_add( frame->args, L0 ); /* Call the rule. */ evaluate_rule( bindrule( rulename, root_module() ), rulename, frame ); /* Clean up. */ frame_free( frame ); } }
LIST * order( FRAME * frame, int flags ) { LIST * arg = lol_get( frame->args, 0 ); LIST * result = L0; int src; LISTITER iter = list_begin( arg ); LISTITER const end = list_end( arg ); /* We need to create a graph of order dependencies between the passed * objects. We assume there are no duplicates passed to 'add_pair'. */ int length = list_length( arg ); int * * graph = ( int * * )BJAM_CALLOC( length, sizeof( int * ) ); int * order = ( int * )BJAM_MALLOC( ( length + 1 ) * sizeof( int ) ); for ( src = 0; iter != end; iter = list_next( iter ), ++src ) { /* For all objects this one depends upon, add elements to 'graph'. */ LIST * dependencies = var_get( frame->module, list_item( iter ) ); int index = 0; LISTITER dep_iter = list_begin( dependencies ); LISTITER const dep_end = list_end( dependencies ); graph[ src ] = ( int * )BJAM_CALLOC( list_length( dependencies ) + 1, sizeof( int ) ); for ( ; dep_iter != dep_end; dep_iter = list_next( dep_iter ) ) { int const dst = list_index( arg, list_item( dep_iter ) ); if ( dst != -1 ) graph[ src ][ index++ ] = dst; } graph[ src ][ index ] = -1; } topological_sort( graph, length, order ); { int index = length - 1; for ( ; index >= 0; --index ) { int i; LISTITER iter = list_begin( arg ); LISTITER const end = list_end( arg ); for ( i = 0; i < order[ index ]; ++i, iter = list_next( iter ) ); result = list_push_back( result, object_copy( list_item( iter ) ) ); } } /* Clean up */ { int i; for ( i = 0; i < length; ++i ) BJAM_FREE( graph[ i ] ); BJAM_FREE( graph ); BJAM_FREE( order ); } return result; }
// Calls getraw() on the specified var. If h != 0 and no value is found for // that hub, then another getraw() will be called with h = 0. If that fails, // the default value is returned instead. char *var_get(guint64 h, int n) { char *r = NULL; if(vars[n].getraw) r = vars[n].getraw(h, vars[n].name); else r = db_vars_get(h, vars[n].name); return r ? r : h ? var_get(0, n) : vars[n].def; }
LIST *property_set_create( PARSE *parse, FRAME *frame ) { LIST* properties = lol_get( frame->args, 0 ); LIST* sorted = 0; LIST* order_sensitive = 0; LIST* unique; LIST* tmp; LIST* val; string var[1]; #if 0 /* Sort all properties which are not order sensitive */ for(tmp = properties; tmp; tmp = tmp->next) { LIST* g = get_grist(tmp->string); LIST* att = call_rule("feature.attributes", frame, g, 0); if (list_in(att, "order-sensitive")) { order_sensitive = list_new( order_sensitive, tmp->string); } else { sorted = list_new( sorted, tmp->string); } list_free(att); } sorted = list_sort(sorted); sorted = list_append(sorted, order_sensitive); unique = list_unique(sorted); #endif sorted = list_sort(properties); unique = list_unique(sorted); string_new(var); string_append(var, ".ps."); for(tmp = unique; tmp; tmp = tmp->next) { string_append(var, tmp->string); string_push_back(var, '-'); } val = var_get(var->value); if (val == 0) { val = call_rule("new", frame, list_append(list_new(0, "property-set"), unique), 0); var_set(newstr(var->value), list_copy(0, val), VAR_SET); } else { val = list_copy(0, val); } string_free(var); /* The 'unique' variable is freed in 'call_rule'. */ list_free(sorted); return val; }
/*! \fn World::var_get_temp(REAL value) */ Value* World::var_get_temp(REAL value) { char name[20]; sprintf(name, "{#%d}", temp_count); temp_count++; *(var_get(name)) =value; return NULL; }
LIST *order( PARSE *parse, FRAME *frame ) { LIST* arg = lol_get( frame->args, 0 ); LIST* tmp; LIST* result = 0; int src, dst; /* We need to create a graph of order dependencies between the passed objects. We assume that there are no duplicates passed to 'add_pair'. */ int length = list_length(arg); int** graph = (int**)calloc(length, sizeof(int*)); int* order = (int*)malloc((length+1)*sizeof(int)); if ( DEBUG_PROFILE ) profile_memory( length*sizeof(int*) + (length+1)*sizeof(int) ); for(tmp = arg, src = 0; tmp; tmp = tmp->next, ++src) { /* For all object this one depend upon, add elements to 'graph' */ LIST* dependencies = var_get(tmp->string); int index = 0; graph[src] = (int*)calloc(list_length(dependencies)+1, sizeof(int)); if ( DEBUG_PROFILE ) profile_memory( (list_length(dependencies)+1)*sizeof(int) ); for(; dependencies; dependencies = dependencies->next) { int dst = list_index(arg, dependencies->string); if (dst != -1) graph[src][index++] = dst; } graph[src][index] = -1; } topological_sort(graph, length, order); { int index = length-1; for(; index >= 0; --index) { int i; tmp = arg; for (i = 0; i < order[index]; ++i, tmp = tmp->next); result = list_new(result, tmp->string); } } /* Clean up */ { int i; for(i = 0; i < length; ++i) free(graph[i]); free(graph); free(order); } return result; }
void cg_grad_adaptor(double *g, double *x, int n) { static at *call = NIL; static int nx = -1; static storage_t *stx = NULL; static storage_t *stg = NULL; static at *(*listeval)(at *, at *) = NULL; if (n == -1) { /* initialize */ at *x0 = var_get(named("x0")); at *vargs = var_get(named("vargs")); at *g = var_get(named("g")); ifn (x0) error(NIL, "x0 not found", NIL); ifn (INDEXP(x0) && IND_STTYPE((index_t *)Mptr(x0))) error(NIL, "x0 not a double index", x0); ifn (g) error(NIL, "g not found", NIL); listeval = Class(g)->listeval; index_t *ind = Mptr(x0); nx = storage_nelems(IND_ST(ind)); stx = new_storage(ST_DOUBLE); stx->flags = STS_FOREIGN; stx->size = nx; stx->data = (char *)-1; stg = new_storage(ST_DOUBLE); stg->flags = STS_FOREIGN; stg->size = nx; stg->data = (char *)-1; call = new_cons(g, new_cons(NEW_INDEX(stg, IND_SHAPE(ind)), new_cons(NEW_INDEX(stx, IND_SHAPE(ind)), vargs))); } else { if (n != nx) error(NIL, "vector of different size expected", NEW_NUMBER(n)); stx->data = x; stg->data = g; listeval(Car(call), call); } }
int LS_jam_getvar(ls_lua_State *L) { LIST *list; LISTITEM* item; int index; int numParams = ls_lua_gettop(L); if (numParams < 1 || numParams > 2) return 0; if (!ls_lua_isstring(L, 1)) return 0; if (numParams == 1) { list = var_get(ls_lua_tostring(L, 1)); } else { TARGET *t; if (!ls_lua_isstring(L, 2)) return 0; t = bindtarget(ls_lua_tostring(L, 1)); pushsettings(t->settings); list = var_get(ls_lua_tostring(L, 2)); popsettings(t->settings); } ls_lua_newtable(L); index = 1; for (item = list_first(list); item; item = list_next(item), ++index) { ls_lua_pushnumber(L, index); ls_lua_pushstring(L, list_value(item)); ls_lua_settable(L, -3); } return 1; }
static int cache_maxage( void ) { int age = 100; LIST * var = var_get( root_module(), constant_HCACHEMAXAGE ); if ( !list_empty( var ) ) { age = atoi( object_str( list_front( var ) ) ); if ( age < 0 ) age = 0; } return age; }
LIST *order( FRAME *frame, int flags ) { LIST* arg = lol_get( frame->args, 0 ); LIST* tmp; LIST* result = 0; int src; /* We need to create a graph of order dependencies between the passed objects. We assume that there are no duplicates passed to 'add_pair'. */ int length = list_length(arg); int** graph = (int**)BJAM_CALLOC(length, sizeof(int*)); int* order = (int*)BJAM_MALLOC((length+1)*sizeof(int)); for(tmp = arg, src = 0; tmp; tmp = tmp->next, ++src) { /* For all object this one depend upon, add elements to 'graph' */ LIST* dependencies = var_get(tmp->value); int index = 0; graph[src] = (int*)BJAM_CALLOC(list_length(dependencies)+1, sizeof(int)); for(; dependencies; dependencies = dependencies->next) { int dst = list_index(arg, dependencies->value); if (dst != -1) graph[src][index++] = dst; } graph[src][index] = -1; } topological_sort(graph, length, order); { int index = length-1; for(; index >= 0; --index) { int i; tmp = arg; for (i = 0; i < order[index]; ++i, tmp = tmp->next); result = list_new(result, object_copy(tmp->value)); } } /* Clean up */ { int i; for(i = 0; i < length; ++i) BJAM_FREE(graph[i]); BJAM_FREE(graph); BJAM_FREE(order); } return result; }