OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
OBJECT * name = class_module_name( list_front( xname ) );
OBJECT * * pp;
module_t * class_module = 0;
module_t * outer_module = frame->module;
int found;
LISTITER iter, end;
if ( !classes )
classes = hashinit( sizeof( OBJECT * ), "classes" );
pp = (OBJECT * *)hash_insert( classes, list_front( xname ), &found );
if ( !found )
{
*pp = object_copy( list_front( xname ) );
}
else
{
printf( "Class %s already defined\n", object_str( list_front( xname ) ) );
abort();
}
check_defined( bases );
class_module = bindmodule( name );
var_set( class_module, constant_name, xname, VAR_SET );
var_set( class_module, constant_bases, bases, VAR_SET );
iter = list_begin( bases ), end = list_end( bases );
for ( ; iter != end; iter = list_next( iter ) )
import_base_rules( class_module, list_item( iter ) );
return name;
}
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);
}
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);
}
void var_expand_unit_test()
{
LOL lol[1];
LIST* l, *l2;
LIST *expected = list_new( list_new( L0, newstr( "axb" ) ), newstr( "ayb" ) );
LIST *e2;
char axyb[] = "a$(xy)b";
char azb[] = "a$($(z))b";
lol_init(lol);
var_set("xy", list_new( list_new( L0, newstr( "x" ) ), newstr( "y" ) ), VAR_SET );
var_set("z", list_new( L0, newstr( "xy" ) ), VAR_SET );
l = var_expand( 0, axyb, axyb + sizeof(axyb) - 1, lol, 0 );
for ( l2 = l, e2 = expected; l2 && e2; l2 = list_next(l2), e2 = list_next(e2) )
assert( !strcmp( e2->string, l2->string ) );
list_free(l);
l = var_expand( 0, azb, azb + sizeof(azb) - 1, lol, 0 );
for ( l2 = l, e2 = expected; l2 && e2; l2 = list_next(l2), e2 = list_next(e2) )
assert( !strcmp( e2->string, l2->string ) );
list_free(l);
list_free(expected);
lol_free(lol);
}
int LS_jam_setvar(ls_lua_State *L)
{
int numParams = ls_lua_gettop(L);
if (numParams < 2 || numParams > 3)
return 0;
if (!ls_lua_isstring(L, 1))
return 0;
if (numParams == 2)
{
var_set(ls_lua_tostring(L, 1), luahelper_addtolist(L, L0, 2), VAR_SET);
}
else
{
TARGET *t;
if (!ls_lua_isstring(L, 2))
return 0;
t = bindtarget(ls_lua_tostring(L, 1));
pushsettings(t->settings);
var_set(ls_lua_tostring(L, 2), luahelper_addtolist(L, L0, 3), VAR_SET);
popsettings(t->settings);
}
return 0;
}
STATIC void
cmd_esw_dma_set_count_size(uint32 count, uint32 size)
{
var_unset(CMD_ESW_DMA_BYTES, TRUE, FALSE, FALSE);
var_unset(CMD_ESW_DMA_SHORTS, TRUE, FALSE, FALSE);
var_unset(CMD_ESW_DMA_WORDS, TRUE, FALSE, FALSE);
switch (size) {
case 1:
var_set(CMD_ESW_DMA_SIZE, "b", TRUE, FALSE);
var_set_integer(CMD_ESW_DMA_BYTES, count, TRUE, FALSE);
break;
case 2:
var_set(CMD_ESW_DMA_SIZE, "h", TRUE, FALSE);
var_set_integer(CMD_ESW_DMA_SHORTS, count, TRUE, FALSE);
break;
case 4:
var_set(CMD_ESW_DMA_SIZE, "w", TRUE, FALSE);
var_set_integer(CMD_ESW_DMA_WORDS, count, TRUE, FALSE);
break;
default:
var_set(CMD_ESW_DMA_SIZE, "?", TRUE, FALSE);
break;
}
}
int
cmd_setattr(int argc,
char **argv)
{
int ret;
char opt;
char *path = NULL;
dpl_dict_t *metadata = NULL;
var_set("status", "1", VAR_CMD_SET, NULL);
optind = 0;
while ((opt = getopt(argc, argv, usage_getoptstr(setattr_usage))) != -1)
switch (opt)
{
case 'm':
metadata = dpl_parse_metadata(optarg);
if (NULL == metadata)
{
fprintf(stderr, "error parsing metadata\n");
return SHELL_CONT;
}
break ;
case '?':
default:
usage_help(&setattr_cmd);
return SHELL_CONT;
}
argc -= optind;
argv += optind;
if (1 != argc)
{
usage_help(&setattr_cmd);
return SHELL_CONT;
}
path = argv[0];
ret = dpl_setattr(ctx, path, metadata);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "status: %s (%d)\n", dpl_status_str(ret), ret);
goto end;
}
var_set("status", "0", VAR_CMD_SET, NULL);
end:
if (NULL != metadata)
dpl_dict_free(metadata);
return SHELL_CONT;
}
static gboolean c_connect_set_hubaddr(char *addr) {
// Validate and parse
GRegex *reg = g_regex_new(
// 1 - proto 2 - host 3 - port 4 - kp
"^(?:(dchub|nmdcs?|adcs?)://)?([^ :/<>\\(\\)]+)(?::([0-9]+))?(?:/|/\\?kp=SHA256\\/([a-zA-Z2-7]{52}))?$",
0, 0, NULL);
g_assert(reg);
GMatchInfo *nfo;
if(!g_regex_match(reg, addr, 0, &nfo)) {
ui_m(NULL, 0, "Invalid URL format."); // not very specific
g_regex_unref(reg);
return FALSE;
}
g_regex_unref(reg);
char *proto = g_match_info_fetch(nfo, 1);
char *kp = g_match_info_fetch(nfo, 4);
if(kp && *kp && strcmp(proto, "adcs") != 0 && strcmp(proto, "nmdcs") != 0) {
ui_m(NULL, 0, "Keyprint is only valid for adcs:// or nmdcs:// URLs.");
g_match_info_free(nfo);
g_free(proto);
g_free(kp);
return FALSE;
}
char *host = g_match_info_fetch(nfo, 2);
char *port = g_match_info_fetch(nfo, 3);
g_match_info_free(nfo);
struct ui_tab *tab = ui_tab_cur->data;
char *old = g_strdup(var_get(tab->hub->id, VAR_hubaddr));
// Reconstruct (without the kp) and save
GString *a = g_string_new("");
g_string_printf(a, "%s://%s:%s/", !proto || !*proto ? "dchub" : proto, host, !port || !*port ? "411" : port);
var_set(tab->hub->id, VAR_hubaddr, a->str, NULL);
// Save kp if specified, or throw it away if the URL changed
if(kp && *kp)
var_set(tab->hub->id, VAR_hubkp, kp, NULL);
else if(old && strcmp(old, a->str) != 0)
var_set(tab->hub->id, VAR_hubkp, NULL, NULL);
g_string_free(a, TRUE);
g_free(old);
g_free(proto);
g_free(kp);
g_free(host);
g_free(port);
return TRUE;
}
STATIC void
cmd_esw_dma_set_dv(dv_t *dv, int dcb_size)
{
char buf[20];
sal_sprintf(buf, "%p", (void *)dv);
var_set(CMD_ESW_DMA_DV, buf, TRUE, FALSE);
sal_sprintf(buf, "%p", dv->dv_dcb);
var_set(CMD_ESW_DMA_DCB, buf, TRUE, FALSE);
var_set_integer(CMD_ESW_DMA_DCB_COUNT, dv->dv_cnt, TRUE, FALSE);
var_set_integer(CMD_ESW_DMA_DCB_SIZE, dcb_size, TRUE, FALSE);
}
OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
OBJECT * name = class_module_name( list_front( xname ) );
OBJECT * * pp;
module_t * class_module = 0;
module_t * outer_module = frame->module;
int found;
if ( !classes )
classes = hashinit( sizeof( OBJECT * ), "classes" );
pp = (OBJECT * *)hash_insert( classes, list_front( xname ), &found );
if ( !found )
{
*pp = object_copy( list_front( xname ) );
}
else
{
out_printf( "Class %s already defined\n", object_str( list_front( xname ) )
);
abort();
}
check_defined( bases );
class_module = bindmodule( name );
{
/*
Initialize variables that Boost.Build inserts in every object.
We want to avoid creating the object's hash if it isn't needed.
*/
int num = class_module->num_fixed_variables;
module_add_fixed_var( class_module, constant_name, &num );
module_add_fixed_var( class_module, constant_class, &num );
module_set_fixed_variables( class_module, num );
}
var_set( class_module, constant_name, xname, VAR_SET );
var_set( class_module, constant_bases, bases, VAR_SET );
{
LISTITER iter = list_begin( bases );
LISTITER const end = list_end( bases );
for ( ; iter != end; iter = list_next( iter ) )
import_base_rules( class_module, list_item( iter ) );
}
return name;
}
void var_expand_unit_test()
{
LOL lol[1];
LIST* l, *l2;
LIST *expected = list_new( list_new( L0, newstr( "axb" ) ), newstr( "ayb" ) );
LIST *e2;
char axyb[] = "a$(xy)b";
char azb[] = "a$($(z))b";
char path[] = "$(p:W)";
# ifdef OS_CYGWIN
char cygpath[256];
cygwin_conv_to_posix_path("c:\\foo\\bar", cygpath);
# else
char cygpath[] = "/cygdrive/c/foo/bar";
# endif
lol_init(lol);
var_set("xy", list_new( list_new( L0, newstr( "x" ) ), newstr( "y" ) ), VAR_SET );
var_set("z", list_new( L0, newstr( "xy" ) ), VAR_SET );
var_set("p", list_new( L0, newstr( cygpath ) ), VAR_SET );
l = var_expand( 0, axyb, axyb + sizeof(axyb) - 1, lol, 0 );
for ( l2 = l, e2 = expected; l2 && e2; l2 = list_next(l2), e2 = list_next(e2) )
assert( !strcmp( e2->string, l2->string ) );
assert(l2 == 0 && e2 == 0);
list_free(l);
l = var_expand( 0, azb, azb + sizeof(azb) - 1, lol, 0 );
for ( l2 = l, e2 = expected; l2 && e2; l2 = list_next(l2), e2 = list_next(e2) )
assert( !strcmp( e2->string, l2->string ) );
assert(l2 == 0 && e2 == 0);
list_free(l);
l = var_expand( 0, path, path + sizeof(path) - 1, lol, 0 );
assert(l != 0);
assert(list_next(l) == 0);
# ifdef OS_CYGWIN
assert( !strcmp( l->string, "c:\\foo\\bar" ) );
# else
assert( !strcmp( l->string, cygpath ) );
# endif
list_free(l);
list_free(expected);
lol_free(lol);
}
LIST * compile_foreach( PARSE * parse, FRAME * frame )
{
LIST * nv = parse_evaluate( parse->left, frame );
LIST * l;
SETTINGS * s = 0;
if ( parse->num )
{
s = addsettings( s, VAR_SET, parse->string, L0 );
pushsettings( s );
}
/* Call var_set to reset $(parse->string) for each val. */
for ( l = nv; l; l = list_next( l ) )
{
LIST * val = list_new( L0, copystr( l->string ) );
var_set( parse->string, val, VAR_SET );
list_free( parse_evaluate( parse->right, frame ) );
}
if ( parse->num )
{
popsettings( s );
freesettings( s );
}
list_free( nv );
return L0;
}
LIST *
compile_set(
PARSE *parse,
LOL *args,
int *jmp )
{
LIST *nt = (*parse->left->func)( parse->left, args, jmp );
LIST *ns = (*parse->right->func)( parse->right, args, jmp );
LISTITEM *l;
if( DEBUG_COMPILE )
{
debug_compile( 0, "set" );
list_print( nt );
printf( " %s ", set_names[ parse->num ] );
list_print( ns );
printf( "\n" );
}
/* Call var_set to set variable */
/* var_set keeps ns, so need to copy it */
for( l = list_first(nt); l; l = list_next( l ) )
var_set( list_value(l), list_copy( L0, ns ), parse->num );
list_free( nt );
return ns;
}
/*
* wiki_handle_get - show a wiki page in normal interactive form
*/
static void
wiki_handle_page()
{
char* name;
if (!user_is_authenticated()) {
html_login_page();
return;
}
if (var_get_val(server->variables, "logoff") != NULL) {
user_logoff(server);
html_login_page();
return;
}
name = wiki_get_pagename("/Wiki/");
if (is_wikiword(name)) {
var_set(&server->variables, "page", name);
out_write_page(name, MODE_NORMAL);
} else {
name = "StartPage";
out_write_page(name, MODE_NORMAL);
svr_set_response(server, "404"); /* not found */
}
wiki->calls++;
}
/* Use quite klugy approach: when we add order dependency from 'a' to 'b',
just append 'b' to of value of variable 'a'.
*/
LIST *add_pair( PARSE *parse, FRAME *frame )
{
LIST* arg = lol_get( frame->args, 0 );
var_set(arg->string, list_copy(0, arg->next), VAR_APPEND);
return L0;
}
STATIC void
cmd_esw_dma_set_paddr(uint32 paddr)
{
char buf[20];
sal_sprintf(buf, "0x%08x", paddr);
var_set(CMD_ESW_DMA_PADDR, buf, TRUE, FALSE);
}
/* Use quite klugy approach: when we add order dependency from 'a' to 'b',
just append 'b' to of value of variable 'a'.
*/
LIST *add_pair( FRAME *frame, int flags )
{
LIST* arg = lol_get( frame->args, 0 );
var_set(arg->value, list_copy(0, arg->next), VAR_APPEND);
return L0;
}
int trap_Set(lua_State *s)
{
const char *varname, *value;
trap_args(s, "Set", "ss", &varname, &value);
var_set(varname, value);
return 0;
}
STATIC void
cmd_esw_dma_set_laddr(void *laddr)
{
char buf[20];
sal_sprintf(buf, "%p", laddr);
var_set(CMD_ESW_DMA_LADDR, buf, TRUE, FALSE);
}
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;
}
/* Use quite klugy approach: when we add order dependency from 'a' to 'b', just
* append 'b' to of value of variable 'a'.
*/
LIST * add_pair( FRAME * frame, int flags )
{
LIST * arg = lol_get( frame->args, 0 );
LISTITER iter = list_begin( arg );
LISTITER const end = list_end( arg );
var_set( frame->module, list_item( iter ), list_copy_range( arg, list_next(
iter ), end ), VAR_APPEND );
return L0;
}
OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
OBJECT * name = class_module_name( xname->value );
OBJECT * * pp = &xname->value;
module_t * class_module = 0;
module_t * outer_module = frame->module;
OBJECT * name_ = object_new( "__name__" );
OBJECT * bases_ = object_new( "__bases__" );
if ( !classes )
classes = hashinit( sizeof( OBJECT * ), "classes" );
if ( hashenter( classes, (HASHDATA * *)&pp ) )
{
*pp = object_copy( xname->value );
}
else
{
printf( "Class %s already defined\n", object_str( xname->value ) );
abort();
}
check_defined( bases );
class_module = bindmodule( name );
exit_module( outer_module );
enter_module( class_module );
var_set( name_, xname, VAR_SET );
var_set( bases_, bases, VAR_SET );
exit_module( class_module );
enter_module( outer_module );
for ( ; bases; bases = bases->next )
import_base_rules( class_module, bases->value );
object_free( bases_ );
object_free( name_ );
return name;
}
void init_storage()
{
assert(ST_FIRST==0);
assert(sizeof(char)==sizeof(uchar));
#ifdef HAVE_MMAP
size_t storage_size = offsetof(storage_t, mmap_addr);
#else
size_t storage_size = sizeof(storage_t);
#endif
mt_storage = MM_REGTYPE("storage", storage_size,
clear_storage, mark_storage, 0);
/* set up storage_classes */
abstract_storage_class = new_builtin_class(NIL);
class_define("storage", abstract_storage_class);
Generic_storage_class_init(ST_BOOL, Bool);
Generic_storage_class_init(ST_AT, Atom);
Generic_storage_class_init(ST_FLOAT, Float);
Generic_storage_class_init(ST_DOUBLE, Double);
Generic_storage_class_init(ST_INT, Int);
Generic_storage_class_init(ST_SHORT, Short);
Generic_storage_class_init(ST_CHAR, Char);
Generic_storage_class_init(ST_UCHAR, UChar);
Generic_storage_class_init(ST_GPTR, Gptr);
Generic_storage_class_init(ST_MPTR, Mptr);
at *p = var_define("storage-classes");
at *l = NIL;
for (storage_type_t st=ST_FIRST; st<ST_LAST; st++)
l = new_cons(storage_class[st]->backptr, l);
var_set(p, reverse(l));
var_lock(p);
dx_define("new-storage", xnew_storage);
dx_define("new-storage/managed", xnew_storage_managed);
dx_define("new-storage/foreign", xnew_storage_foreign);
#ifdef HAVE_MMAP
dx_define("new-storage/mmap",xnew_storage_mmap);
#endif
dx_define("storage-alloc",xstorage_alloc);
dx_define("storage-realloc",xstorage_realloc);
dx_define("storage-clear",xstorage_clear);
dx_define("storagep",xstoragep);
dx_define("storage-readonlyp",xstorage_readonlyp);
dx_define("storage-set-readonly", xstorage_set_readonly);
dx_define("storage-load",xstorage_load);
dx_define("storage-save",xstorage_save);
dx_define("storage-nelems",xstorage_nelems);
dx_define("storage-nbytes",xstorage_nbytes);
}
int
mark_as_automatic_installed(const char *pkg, int value)
{
char *filename;
int retval;
assert(pkg[0] != '/');
filename = pkgdb_pkg_file(pkg, INSTALLED_INFO_FNAME);
retval = var_set(filename, AUTOMATIC_VARNAME, value ? "yes" : NULL);
free(filename);
return retval;
}
static int
set_installed_info_var(const char *name, void *cookie)
{
struct set_installed_info_arg *arg = cookie;
char *filename;
int retval;
filename = pkgdb_pkg_file(name, INSTALLED_INFO_FNAME);
retval = var_set(filename, arg->variable, arg->value);
free(filename);
arg->got_match = 1;
return retval;
}
LIST * property_set_create( FRAME * frame, int flags )
{
LIST * properties = lol_get( frame->args, 0 );
LIST * sorted = list_sort( properties );
LIST * unique = list_unique( sorted );
struct ps_map_entry * pos = ps_map_insert( &all_property_sets, unique );
list_free( sorted );
if ( pos->value )
{
list_free( unique );
return list_new( object_copy( pos->value ) );
}
else
{
OBJECT * rulename = object_new( "new" );
OBJECT * varname = object_new( "self.raw" );
LIST * val = call_rule( rulename, frame,
list_new( object_new( "property-set" ) ), 0 );
LISTITER iter, end;
object_free( rulename );
pos->value = list_front( val );
var_set( bindmodule( pos->value ), varname, unique, VAR_SET );
object_free( varname );
for ( iter = list_begin( unique ), end = list_end( unique ); iter != end; ++iter )
{
const char * str = object_str( list_item( iter ) );
if ( str[ 0 ] != '<' || ! strchr( str, '>' ) )
{
string message[ 1 ];
string_new( message );
string_append( message, "Invalid property: '" );
string_append( message, str );
string_append( message, "'" );
rulename = object_new( "errors.error" );
call_rule( rulename, frame,
list_new( object_new( message->value ) ), 0 );
/* unreachable */
string_free( message );
object_free( rulename );
}
}
return val;
}
}
static void c_accept(char *args) {
struct ui_tab *tab = ui_tab_cur->data;
if(args[0])
ui_m(NULL, 0, "This command does not accept any arguments.");
else if(tab->type != UIT_HUB)
ui_m(NULL, 0, "This command can only be used on hub tabs.");
#if TLS_SUPPORT
else if(!tab->hub->kp)
ui_m(NULL, 0, "Nothing to accept.");
else {
char enc[53] = {};
base32_encode_dat(tab->hub->kp, enc, 32);
var_set(tab->hub->id, VAR_hubkp, enc, NULL);
g_slice_free1(32, tab->hub->kp);
tab->hub->kp = NULL;
hub_connect(tab->hub);
}
#else
else
LIST *
compile_foreach(
PARSE *p,
LOL *args,
int *jmp )
{
LIST *nv = (*p->left->func)( p->left, args, jmp );
LIST *result = 0;
LISTITEM *l;
/* TODO: Efficiency: nv could be split apart and reused during the traversal */
/* for each value for var */
for( l = list_first(nv); l && *jmp == JMP_NONE; l = list_next( l ) )
{
/* Reset $(p->string) for each val. */
var_set( p->string, list_append( L0, list_value(l), 1 ), VAR_SET );
/* Keep only last result. */
list_free( result );
result = (*p->right->func)( p->right, args, jmp );
/* continue loop? */
if( *jmp == JMP_CONTINUE )
*jmp = JMP_NONE;
}
/* Here by break/continue? */
if( *jmp == JMP_BREAK || *jmp == JMP_CONTINUE )
*jmp = JMP_NONE;
list_free( nv );
/* Returns result of last loop */
return result;
}
int
p_assign(const char *name, struct value *v, int flag)
{
(void) s_gettok();
if (p_expr(v, flag) < 0) {
p_synerror();
return -1;
}
switch (v->v_type) {
case V_STR:
case V_NUM:
if (name && flag && var_set(name, v) == 0) {
p_memerror();
val_free(*v);
return -1;
}
break;
}
return 0;
}
LIST *
compile_foreach(
PARSE *p,
LOL *args,
int *jmp )
{
LIST *nv = (*p->left->func)( p->left, args, jmp );
LIST *result = 0;
LIST *l;
/* for each value for var */
for( l = nv; l && *jmp == JMP_NONE; l = list_next( l ) )
{
/* Reset $(p->string) for each val. */
var_set( p->string, list_new( L0, l->string, 1 ), VAR_SET );
/* Keep only last result. */
list_free( result );
result = (*p->right->func)( p->right, args, jmp );
/* continue loop? */
if( *jmp == JMP_CONTINUE )
*jmp = JMP_NONE;
}
/* Here by break/continue? */
if( *jmp == JMP_BREAK || *jmp == JMP_CONTINUE )
*jmp = JMP_NONE;
list_free( nv );
/* Returns result of last loop */
return result;
}