PARSE * parse_make(
int type,
PARSE * left,
PARSE * right,
PARSE * third,
OBJECT * string,
OBJECT * string1,
int num )
{
PARSE * p = (PARSE *)BJAM_MALLOC( sizeof( PARSE ) );
p->type = type;
p->left = left;
p->right = right;
p->third = third;
p->string = string;
p->string1 = string1;
p->num = num;
p->refs = 1;
p->rulename = 0;
if ( left )
{
p->file = object_copy( left->file );
p->line = left->line;
}
else
{
yyinput_last_read_token( &p->file, &p->line );
p->file = object_copy( p->file );
}
return p;
}
void path_add_key( OBJECT * path )
{
struct path_key_entry * result;
int found;
if ( ! path_key_cache )
path_key_cache = hashinit( sizeof( struct path_key_entry ), "path to key" );
result = (struct path_key_entry *)hash_insert( path_key_cache, path, &found );
if ( !found )
{
string buf[1];
OBJECT * normalized;
struct path_key_entry * nresult;
result->path = path;
string_copy( buf, object_str( path ) );
normalize_path( buf );
normalized = object_new( buf->value );
string_free( buf );
nresult = (struct path_key_entry *)hash_insert( path_key_cache, normalized, &found );
if ( !found || nresult == result )
{
nresult->path = object_copy( normalized );
nresult->key = object_copy( path );
}
object_free( normalized );
if ( nresult != result )
{
result->path = object_copy( path );
result->key = object_copy( nresult->key );
}
}
}
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 );
}
}
}
} END_TEST
START_TEST (test_2) {
object *obj = object_list();
fail_unless(object_list_length(obj) == 0, NULL);
object *val;
val = object_int(1);
object_list_insert_at(obj, 0, val);
object_free(val);
fail_unless(object_list_length(obj) == 1, NULL);
val = object_int(3);
object_list_insert_at(obj, 1, val);
object_free(val);
fail_unless(object_list_length(obj) == 2, NULL);
val = object_int(2);
object_list_insert_at(obj, 1, val);
object_free(val);
fail_unless(object_list_length(obj) == 3, NULL);
object *next = object_copy(obj);
fail_unless(object_list_length(next) == 3, NULL);
object_list_remove(obj, 0);
fail_unless(object_list_length(obj) == 2, NULL);
object_list_remove(obj, 0);
fail_unless(object_list_length(obj) == 1, NULL);
object_list_remove(obj, 0);
fail_unless(object_list_length(obj) == 0, NULL);
object_free(obj);
obj = next;
next = object_copy(next);
object_list_remove(obj, 1);
fail_unless(object_list_length(obj) == 2, NULL);
object_free(obj);
obj = next;
object_list_remove(obj, 2);
fail_unless(object_list_length(obj) == 2, NULL);
object_free(obj);
object_free(obj);
} END_TEST
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 );
}
}
TARGET * copytarget( const TARGET * ot )
{
TARGET * t = (TARGET *)BJAM_MALLOC( sizeof( *t ) );
memset( (char *)t, '\0', sizeof( *t ) );
t->name = object_copy( ot->name );
t->boundname = object_copy( t->name );
t->flags |= T_FLAG_NOTFILE | T_FLAG_INTERNAL;
return t;
}
LIST * var_get( struct module_t * module, OBJECT * symbol )
{
LIST * result = L0;
#ifdef OPT_AT_FILES
/* Some "fixed" variables... */
if ( object_equal( symbol, constant_TMPDIR ) )
{
list_free( saved_var );
result = saved_var = list_new( object_new( path_tmpdir()->value ) );
}
else if ( object_equal( symbol, constant_TMPNAME ) )
{
list_free( saved_var );
result = saved_var = list_new( path_tmpnam() );
}
else if ( object_equal( symbol, constant_TMPFILE ) )
{
list_free( saved_var );
result = saved_var = list_new( path_tmpfile() );
}
else if ( object_equal( symbol, constant_STDOUT ) )
{
list_free( saved_var );
result = saved_var = list_new( object_copy( constant_STDOUT ) );
}
else if ( object_equal( symbol, constant_STDERR ) )
{
list_free( saved_var );
result = saved_var = list_new( object_copy( constant_STDERR ) );
}
else
#endif
{
VARIABLE * v;
int n;
if ( ( n = module_get_fixed_var( module, symbol ) ) != -1 )
{
if ( DEBUG_VARGET )
var_dump( symbol, module->fixed_variables[ n ], "get" );
result = module->fixed_variables[ n ];
}
else if ( module->variables && ( v = (VARIABLE *)hash_find(
module->variables, symbol ) ) )
{
if ( DEBUG_VARGET )
var_dump( v->symbol, v->value, "get" );
result = v->value;
}
}
return result;
}
static path_key_entry * path_key( OBJECT * const path,
int const known_to_be_canonic )
{
path_key_entry * result;
int found;
if ( !path_key_cache )
path_key_cache = hashinit( sizeof( path_key_entry ), "path to key" );
result = (path_key_entry *)hash_insert( path_key_cache, path, &found );
if ( !found )
{
OBJECT * normalized;
int normalized_size;
path_key_entry * nresult;
result->path = path;
{
string buf[ 1 ];
string_copy( buf, object_str( path ) );
normalize_path( buf );
normalized = object_new( buf->value );
normalized_size = buf->size;
string_free( buf );
}
nresult = (path_key_entry *)hash_insert( path_key_cache, normalized,
&found );
if ( !found || nresult == result )
{
nresult->path = normalized;
if ( known_to_be_canonic )
nresult->key = object_copy( path );
else
{
string canonic_path[ 1 ];
string_new( canonic_path );
canonicWindowsPath( object_str( normalized ), normalized_size,
canonic_path );
nresult->key = object_new( canonic_path->value );
string_free( canonic_path );
}
}
else
object_free( normalized );
if ( nresult != result )
{
result->path = object_copy( path );
result->key = object_copy( nresult->key );
}
}
return result;
}
OBJECT * path_as_key( OBJECT * path )
{
struct path_key_entry e, *result = &e;
if ( ! path_key_cache )
path_key_cache = hashinit( sizeof( struct path_key_entry ), "path to key" );
result->path = path;
if ( hashenter( path_key_cache, (HASHDATA * *)&result ) )
{
string buf[1];
char * s;
string_copy( buf, object_str( path ) );
for ( s = buf->value; s < buf->value + buf->size; ++s )
{
if ( *s == '/' )
*s = '\\';
else
*s = tolower( *s );
}
result->path = object_copy( path );
result->key = object_new( buf->value );
string_free( buf );
}
return result->key;
}
file_info_t * file_info( OBJECT * filename )
{
file_info_t *finfo = &filecache_finfo;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
filename = path_as_key( filename );
finfo->name = filename;
finfo->is_file = 0;
finfo->is_dir = 0;
finfo->size = 0;
finfo->time = 0;
finfo->files = 0;
if ( hashenter( filecache_hash, (HASHDATA**)&finfo ) )
{
/* printf( "file_info: %s\n", filename ); */
finfo->name = object_copy( finfo->name );
}
object_free( filename );
return finfo;
}
void equip_shuffle(cptr tag)
{
int i;
for (i = INVEN_PACK - 1; i >= 0; i--)
{
object_type *o_ptr = &inventory[i];
cptr inscription;
int slot;
if (!o_ptr->k_idx) continue;
if (!o_ptr->inscription) continue;
inscription = quark_str(o_ptr->inscription);
if (!strstr(inscription, tag)) continue;
slot = equip_first_empty_slot(o_ptr);
if (slot && o_ptr->number == 1)
{
object_type copy;
object_copy(©, o_ptr);
copy.number = 1;
inven_item_increase(i, -1);
inven_item_optimize(i);
equip_wield_aux(©, slot);
}
}
}
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;
}
LIST *sequence_select_highest_ranked( FRAME *frame, int flags )
{
/* Returns all of 'elements' for which corresponding element in parallel */
/* list 'rank' is equal to the maximum value in 'rank'. */
LIST* elements = lol_get( frame->args, 0 );
LIST* rank = lol_get( frame->args, 1 );
LISTITER iter, end, elements_iter, elements_end;
LIST* result = L0;
LIST* tmp;
int highest_rank = -1;
iter = list_begin(rank), end = list_end(rank);
for (; iter != end; iter = list_next(iter))
highest_rank = max(highest_rank, atoi(object_str(list_item(iter))));
iter = list_begin(rank), end = list_end(rank);
elements_iter = list_begin(elements), elements_end = list_end(elements);
for (; iter != end; iter = list_next(iter), elements_iter = list_next(elements_iter))
if (atoi(object_str(list_item(iter))) == highest_rank)
result = list_push_back(result, object_copy(list_item(elements_iter)));
return result;
}
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;
}
/**
* Provide information on an ego-item type
*/
textblock *object_info_ego(struct ego_item *ego)
{
struct object_kind *kind = NULL;
struct object obj = OBJECT_NULL, known_obj = OBJECT_NULL;
size_t i;
for (i = 0; i < z_info->k_max; i++) {
kind = &k_info[i];
if (!kind->name)
continue;
if (i == ego->poss_items->kidx)
break;
}
obj.kind = kind;
obj.tval = kind->tval;
obj.sval = kind->sval;
obj.ego = ego;
ego_apply_magic(&obj, 0);
object_copy(&known_obj, &obj);
obj.known = &known_obj;
return object_info_out(&obj, OINFO_NONE | OINFO_EGO);
}
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;
}
LIST*
pwd(void)
{
if (!pwd_result)
{
int buffer_size = PATH_MAX;
char * result_buffer = 0;
do
{
char * buffer = BJAM_MALLOC_RAW(buffer_size);
result_buffer = getcwd(buffer,buffer_size);
if (result_buffer)
{
#ifdef NT
OBJECT * result = object_new(result_buffer);
pwd_result = short_path_to_long_path(result);
object_free( result );
#else
pwd_result = object_new(result_buffer);
#endif
}
buffer_size *= 2;
BJAM_FREE_RAW(buffer);
}
while (!pwd_result && errno == ERANGE);
if (!pwd_result)
{
perror("can not get current directory");
return L0;
}
}
return list_new(L0, object_copy( pwd_result ) );
}
static void time_enter( void * closure, OBJECT * target, int const found,
timestamp const * const time )
{
int item_found;
BINDING * b;
struct hash * const bindhash = (struct hash *)closure;
target = path_as_key( target );
b = (BINDING *)hash_insert( bindhash, target, &item_found );
if ( !item_found )
{
b->name = object_copy( target );
b->flags = 0;
}
timestamp_copy( &b->time, time );
b->progress = found ? BIND_FOUND : BIND_SPOTTED;
if ( DEBUG_BINDSCAN )
out_printf( "time ( %s ) : %s\n", object_str( target ), time_progress[
b->progress ] );
object_free( target );
}
void kamaenaoshi(int item)
{
object_type *o_ptr, *new_o_ptr;
char o_name[MAX_NLEN];
if (item == INVEN_RARM)
{
if (buki_motteruka(INVEN_LARM))
{
o_ptr = &inventory[INVEN_LARM];
object_desc(o_name, o_ptr, 0);
if (!object_is_cursed(o_ptr))
{
new_o_ptr = &inventory[INVEN_RARM];
object_copy(new_o_ptr, o_ptr);
p_ptr->total_weight += o_ptr->weight;
inven_item_increase(INVEN_LARM, -((int)o_ptr->number));
inven_item_optimize(INVEN_LARM);
if (object_allow_two_hands_wielding(o_ptr) && CAN_TWO_HANDS_WIELDING())
#ifdef JP
msg_format("%sを両手で構えた。", o_name);
#else
msg_format("You are wielding %s with both hands.", o_name);
#endif
else
#ifdef JP
msg_format("%sを%sで構えた。", o_name, (left_hander ? "左手" : "右手"));
#else
msg_format("You are wielding %s in your %s hand.", o_name, (left_hander ? "left":"right"));
#endif
}
else
{
if (object_allow_two_hands_wielding(o_ptr) && CAN_TWO_HANDS_WIELDING())
void
polyconn_copy(PolyConn *from, PolyConn *to)
{
int i;
Object *toobj, *fromobj;
toobj = &to->object;
fromobj = &from->object;
object_copy(fromobj, toobj);
to->numpoints = from->numpoints;
to->points = g_malloc((to->numpoints)*sizeof(Point));
for (i=0;i<to->numpoints;i++) {
to->points[i] = from->points[i];
}
to->object.handles[0] = g_new(Handle,1);
*to->object.handles[0] = *from->object.handles[0];
for (i=1;i<to->numpoints-1;i++) {
to->object.handles[i] = g_malloc(sizeof(Handle));
setup_corner_handle(to->object.handles[i]);
}
to->object.handles[to->numpoints-1] = g_new(Handle,1);
*to->object.handles[to->numpoints-1] = *from->object.handles[to->numpoints-1];
polyconn_update_data(to);
}
file_info_t * file_info( OBJECT * filename )
{
file_info_t *finfo = &filecache_finfo;
int found;
if ( !filecache_hash )
filecache_hash = hashinit( sizeof( file_info_t ), "file_info" );
filename = path_as_key( filename );
finfo = (file_info_t *)hash_insert( filecache_hash, filename, &found );
if ( !found )
{
/* printf( "file_info: %s\n", filename ); */
finfo->name = object_copy( filename );
finfo->is_file = 0;
finfo->is_dir = 0;
finfo->size = 0;
finfo->time = 0;
finfo->files = L0;
}
object_free( filename );
return finfo;
}
module_t * bindmodule( OBJECT * name )
{
if ( !name )
{
return &root;
}
else
{
PROFILE_ENTER( BINDMODULE );
module_t m_;
module_t * m = &m_;
if ( !module_hash )
module_hash = hashinit( sizeof( module_t ), "modules" );
m->name = name;
if ( hashenter( module_hash, (HASHDATA * *)&m ) )
{
m->name = object_copy( name );
m->variables = 0;
m->rules = 0;
m->imported_modules = 0;
m->class_module = 0;
m->native_rules = 0;
m->user_module = 0;
}
PROFILE_EXIT( BINDMODULE );
return m;
}
}
static void add_module_name( void * r_, void * result_ )
{
OBJECT * * r = (OBJECT * *)r_;
LIST * * result = (LIST * *)result_;
*result = list_new( *result, object_copy( *r ) );
}
void
polyconn_copy(PolyConn *from, PolyConn *to)
{
int i;
DiaObject *toobj, *fromobj;
toobj = &to->object;
fromobj = &from->object;
object_copy(fromobj, toobj);
to->object.handles[0] = g_new(Handle,1);
*to->object.handles[0] = *from->object.handles[0];
for (i=1;i<toobj->num_handles-1;i++) {
to->object.handles[i] = g_malloc(sizeof(Handle));
setup_handle(to->object.handles[i], PC_HANDLE_CORNER);
}
to->object.handles[toobj->num_handles-1] = g_new(Handle,1);
*to->object.handles[toobj->num_handles-1] =
*from->object.handles[toobj->num_handles-1];
polyconn_set_points(to, from->numpoints, from->points);
memcpy(&to->extra_spacing,&from->extra_spacing,sizeof(to->extra_spacing));
polyconn_update_data(to);
}
/**
* Prepare an object `dst` representing `amt` objects, based on an existing
* object `src` representing at least `amt` objects.
*
* Takes care of the charge redistribution concerns of stacked items.
*/
void object_copy_amt(struct object *dest, struct object *src, int amt)
{
int charge_time = randcalc(src->time, 0, AVERAGE), max_time;
/* Get a copy of the object */
object_copy(dest, src);
/* Modify quantity */
dest->number = amt;
dest->note = src->note;
/*
* If the item has charges/timeouts, set them to the correct level
* too. We split off the same amount as distribute_charges.
*/
if (tval_can_have_charges(src))
dest->pval = src->pval * amt / src->number;
if (tval_can_have_timeout(src)) {
max_time = charge_time * amt;
if (src->timeout > max_time)
dest->timeout = max_time;
else
dest->timeout = src->timeout;
}
}
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;
}
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 = object_copy( 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;
}
}
/*
* Read a store
*/
static errr rd_store(int n)
{
store_type *st_ptr = &store[n];
int j;
byte own, num;
/* Read the basic info */
rd_s32b(&st_ptr->store_open);
rd_s16b(&st_ptr->insult_cur);
rd_byte(&own);
rd_byte(&num);
rd_s16b(&st_ptr->good_buy);
rd_s16b(&st_ptr->bad_buy);
/* Paranoia */
if (own >= z_info->b_max)
{
note("Illegal store owner!");
return (-1);
}
st_ptr->owner = own;
/* Read the items */
for (j = 0; j < num; j++)
{
object_type *i_ptr;
object_type object_type_body;
/* Get local object */
i_ptr = &object_type_body;
/* Wipe the object */
object_wipe(i_ptr);
/* Read the item */
if (rd_item(i_ptr))
{
note("Error reading item");
return (-1);
}
/* Accept any valid items */
if (st_ptr->stock_num < STORE_INVEN_MAX)
{
int k = st_ptr->stock_num++;
/* Accept the item */
object_copy(&st_ptr->stock[k], i_ptr);
}
}
/* Success */
return (0);
}