/*
* 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;
}
