/**
* Handle a "-d<dir>=<path>" option.
*
* Sets any of angband's special directories to <path>.
*
* The "<path>" can be any legal path for the given system, and should
* not end in any special path separator (i.e. "/tmp" or "~/.ang-info").
*/
static void change_path(const char *info)
{
char *info_copy = NULL;
char *path = NULL;
char *dir = NULL;
unsigned int i = 0;
char dirpath[512];
if (!info || !info[0])
quit_fmt("Try '-d<dir>=<path>'.", info);
info_copy = string_make(info);
path = strtok(info_copy, "=");
dir = strtok(NULL, "=");
for (i = 0; i < N_ELEMENTS(change_path_values); i++) {
if (my_stricmp(path, change_path_values[i].name) == 0) {
#ifdef SETGID
if (!change_path_values[i].setgid_ok)
quit_fmt("Can't redefine path to %s dir on multiuser setup",
path);
#endif
string_free(*change_path_values[i].path);
*change_path_values[i].path = string_make(dir);
/* the directory may not exist and may need to be created. */
path_build(dirpath, sizeof(dirpath), dir, "");
if (!dir_create(dirpath)) quit_fmt("Cannot create '%s'", dirpath);
return;
}
}
quit_fmt("Unrecognised -d paramater %s", path);
}
static errr parse_specs(struct parser_hook *h, char *fmt) {
char *name ;
char *stype = NULL;
int type;
struct parser_spec *s;
assert(h);
assert(fmt);
name = strtok(fmt, " ");
if (!name)
return -EINVAL;
h->dir = string_make(name);
h->fhead = NULL;
h->ftail = NULL;
while (name) {
/* Lack of a type is legal; that means we're at the end of the line. */
stype = strtok(NULL, " ");
if (!stype)
break;
/* Lack of a name, on the other hand... */
name = strtok(NULL, " ");
if (!name) {
clean_specs(h);
return -EINVAL;
}
/* Grab a type, check to see if we have a mandatory type
* following an optional type. */
type = parse_type(stype);
if (type == PARSE_T_NONE) {
clean_specs(h);
return -EINVAL;
}
if (!(type & PARSE_T_OPT) && h->ftail &&
(h->ftail->type & PARSE_T_OPT)) {
clean_specs(h);
return -EINVAL;
}
if (h->ftail && ((h->ftail->type & ~PARSE_T_OPT) == PARSE_T_STR)) {
clean_specs(h);
return -EINVAL;
}
/* Save this spec. */
s = mem_alloc(sizeof *s);
s->type = type;
s->name = string_make(name);
s->next = NULL;
if (h->fhead)
h->ftail->next = s;
else
h->fhead = s;
h->ftail = s;
}
return 0;
}
lvalue files_read(lvalue v_) {
char *s = (char *)v_;
char *buffer;
lvalue *ptr;
long size;
FILE *fh = fopen(s, "rb");
if (fh != NULL) {
fseek(fh, 0L, SEEK_END);
size = ftell(fh);
rewind(fh);
buffer = malloc(size + sizeof(lvalue) + 1);
ptr = (lvalue*)buffer;
*ptr = (lvalue) size;
buffer = (char *) (ptr+1);
long rsize = fread(buffer, 1, size, fh);
fclose(fh);
fh = NULL;
if (rsize == size) {
*(buffer + size) = 0;
return (lvalue) buffer;
}
}
return string_make((lvalue) "");
}
/*
* Initialize sound
*/
static bool init_sound(void)
{
/* Initialize once */
if (!can_use_sound)
{
int i;
char wav[128];
char buf[1024];
/* Prepare the sounds */
for (i = 1; i < SOUND_MAX; i++)
{
/* Extract name of sound file */
sprintf(wav, "%s.wav", angband_sound_name[i]);
/* Access the sound */
path_build(buf, sizeof(buf), ANGBAND_DIR_XTRA_SOUND, wav);
/* Save the sound filename, if it exists */
if (check_file(buf)) sound_file[i] = string_make(buf);
}
/* Sound available */
can_use_sound = TRUE;
}
/* Result */
return (can_use_sound);
}
static enum parser_error parse_r_s(struct parser *p) {
struct monster_race *r = parser_priv(p);
char *flags;
char *s;
int pct;
int ret = PARSE_ERROR_NONE;
if (!r)
return PARSE_ERROR_MISSING_RECORD_HEADER;
flags = string_make(parser_getstr(p, "spells"));
s = strtok(flags, " |");
while (s) {
if (1 == sscanf(s, "1_IN_%d", &pct)) {
if (pct < 1 || pct > 100) {
ret = PARSE_ERROR_INVALID_SPELL_FREQ;
break;
}
r->freq_spell = 100 / pct;
r->freq_innate = r->freq_spell;
} else {
if (grab_flag(r->spell_flags, RSF_SIZE, r_info_spell_flags, s)) {
ret = PARSE_ERROR_INVALID_FLAG;
break;
}
}
s = strtok(NULL, " |");
}
/* Add the "base monster" flags to the monster */
if (r->base)
rsf_union(r->spell_flags, r->base->spell_flags);
mem_free(flags);
return ret;
}
void menu_dynamic_add(menu_type *m, const char *text, int value)
{
struct menu_entry *head = menu_priv(m);
/*struct menu_entry *new = mem_zalloc(sizeof *new);*/
struct menu_entry *newm = ZNEW(struct menu_entry);
assert(m->row_funcs == &dynamic_iter);
newm->text = (char*)string_make(text);
newm->value = value;
if (head) {
struct menu_entry *tail = head;
while (1) {
if (tail->next)
tail = tail->next;
else
break;
}
//tail->next = new;
tail->next = newm;
menu_setpriv(m, m->count + 1, head);
} else {
//menu_setpriv(m, m->count + 1, new);
menu_setpriv(m, m->count + 1, newm);
}
}
/*
* Open file 'fname', in mode 'mode', with filetype 'ftype'.
* Returns file handle or NULL.
*/
ang_file *file_open(const char *fname, file_mode mode, file_type ftype)
{
ang_file *f = ZNEW(ang_file);
char buf[1024];
(void)ftype;
/* Get the system-specific path */
path_parse(buf, sizeof(buf), fname);
switch (mode)
{
case MODE_WRITE: f->fh = fopen(buf, "wb"); break;
case MODE_READ: f->fh = fopen(buf, "rb"); break;
case MODE_APPEND: f->fh = fopen(buf, "a+"); break;
default: f->fh = fopen(buf, "__");
}
if (f->fh == NULL)
{
FREE(f);
return NULL;
}
f->fname = string_make(buf);
f->mode = mode;
if (mode != MODE_READ && file_open_hook)
file_open_hook(buf, ftype);
return f;
}
errr parser_reg(struct parser *p, const char *fmt,
enum parser_error (*func)(struct parser *p)) {
errr r;
char *cfmt;
struct parser_hook *h;
assert(p);
assert(fmt);
assert(func);
h = mem_alloc(sizeof *h);
cfmt = string_make(fmt);
h->next = p->hooks;
h->func = func;
r = parse_specs(h, cfmt);
if (r)
{
mem_free(h);
mem_free(cfmt);
return r;
}
p->hooks = h;
mem_free(cfmt);
return 0;
}
static void
setup_argv(struct Parrot_Interp *interpreter, int argc, char ** argv)
{
INTVAL i;
PMC *userargv;
if (Interp_flags_TEST(interpreter, PARROT_DEBUG_FLAG)) {
PIO_eprintf(interpreter,
"*** Parrot VM: Setting up ARGV array in P5. Current argc: %d ***\n",
argc);
}
userargv = pmc_new_noinit(interpreter, enum_class_SArray);
/* immediately anchor pmc to root set */
interpreter->pmc_reg.registers[5] = userargv;
VTABLE_set_pmc_keyed_int(interpreter, interpreter->iglobals,
(INTVAL)IGLOBALS_ARGV_LIST, userargv);
VTABLE_init(interpreter, userargv);
VTABLE_set_integer_native(interpreter, userargv, argc);
for (i = 0; i < argc; i++) {
/* Run through argv, adding everything to @ARGS. */
STRING *arg = string_make(interpreter, argv[i], strlen(argv[i]),
0, PObj_external_FLAG, 0);
if (Interp_flags_TEST(interpreter, PARROT_DEBUG_FLAG)) {
PIO_eprintf(interpreter, "\t%vd: %s\n", i, argv[i]);
}
VTABLE_push_string(interpreter, userargv, arg);
}
}
/*
* Handle a "-d<what>=<path>" option
*
* The "<what>" can be any string starting with the same letter as the
* name of a subdirectory of the "lib" folder (i.e. "i" or "info").
*
* The "<path>" can be any legal path for the given system, and should
* not end in any special path separator (i.e. "/tmp" or "~/.ang-info").
*/
static void change_path(const char *info)
{
if (!info || !info[0])
quit_fmt("Try '-d<path>'.", info);
string_free(ANGBAND_DIR_USER);
ANGBAND_DIR_USER = string_make(info);
}
static enum parser_error parse_vault_type(struct parser *p) {
struct vault *v = parser_priv(p);
if (!v)
return PARSE_ERROR_MISSING_RECORD_HEADER;
v->typ = string_make(parser_getstr(p, "type"));
return PARSE_ERROR_NONE;
}
/*
* Handle a "-d<what>=<path>" option
*
* The "<what>" can be any string starting with the same letter as the
* name of a subdirectory of the "lib" folder (i.e. "i" or "info").
*
* The "<path>" can be any legal path for the given system, and should
* not end in any special path separator (i.e. "/tmp" or "~/.ang-info").
*/
static void change_path(cptr info)
{
if (!info || !info[0])
quit_fmt("Try '-d<path>'.", info);
string_free(reposband_DIR_USER);
reposband_DIR_USER = string_make(info);
}
static enum parser_error parse_rb_n(struct parser *p) {
struct monster_base *h = parser_priv(p);
struct monster_base *rb = mem_zalloc(sizeof *rb);
rb->next = h;
rb->name = string_make(parser_getstr(p, "name"));
parser_setpriv(p, rb);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_prefs_gf(struct parser *p)
{
bool types[GF_MAX] = { 0 };
const char *direction;
int motion;
char *s, *t;
size_t i;
struct prefs_data *d = parser_priv(p);
assert(d != NULL);
if (d->bypass)
return PARSE_ERROR_NONE;
/* Parse the type, which is a | seperated list of GF_ constants */
s = string_make(parser_getsym(p, "type"));
t = strtok(s, "| ");
while (t) {
if (streq(t, "*")) {
memset(types, TRUE, sizeof types);
} else {
int idx = gf_name_to_idx(t);
if (idx == -1)
return PARSE_ERROR_INVALID_VALUE;
types[idx] = TRUE;
}
t = strtok(NULL, "| ");
}
string_free(s);
direction = parser_getsym(p, "direction");
if (streq(direction, "static"))
motion = BOLT_NO_MOTION;
else if (streq(direction, "0"))
motion = BOLT_0;
else if (streq(direction, "45"))
motion = BOLT_45;
else if (streq(direction, "90"))
motion = BOLT_90;
else if (streq(direction, "135"))
motion = BOLT_135;
else
return PARSE_ERROR_INVALID_VALUE;
for (i = 0; i < GF_MAX; i++) {
if (!types[i])
continue;
gf_to_attr[i][motion] = (byte) parser_getuint(p, "attr");
gf_to_char[i][motion] = (wchar_t) parser_getuint(p, "char");
}
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for vault.txt
*/
static enum parser_error parse_vault_name(struct parser *p) {
struct vault *h = parser_priv(p);
struct vault *v = mem_zalloc(sizeof *v);
v->name = string_make(parser_getstr(p, "name"));
v->next = h;
parser_setpriv(p, v);
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for room_template.txt
*/
static enum parser_error parse_room_name(struct parser *p) {
struct room_template *h = parser_priv(p);
struct room_template *t = mem_zalloc(sizeof *t);
t->name = string_make(parser_getstr(p, "name"));
t->next = h;
parser_setpriv(p, t);
return PARSE_ERROR_NONE;
}
static enum parser_error parse_summon_name(struct parser *p) {
struct summon *h = parser_priv(p);
struct summon *s = mem_zalloc(sizeof *s);
s->next = h;
parser_setpriv(p, s);
s->name = string_make(parser_getstr(p, "name"));
return PARSE_ERROR_NONE;
}
/* Parsing functions for monster.txt */
static enum parser_error parse_r_n(struct parser *p) {
struct monster_race *h = parser_priv(p);
struct monster_race *r = mem_zalloc(sizeof *r);
r->next = h;
r->ridx = parser_getuint(p, "index");
r->name = string_make(parser_getstr(p, "name"));
parser_setpriv(p, r);
return PARSE_ERROR_NONE;
}
void
Parrot_initialize_header_pool_names(struct Parrot_Interp *interpreter)
{
interpreter->arena_base->string_header_pool->name
= string_make(interpreter, "String Pool", strlen("String Pool"),
0, PObj_constant_FLAG, 0);
interpreter->arena_base->pmc_pool->name
= string_make(interpreter, "PMC Pool", strlen("PMC Pool"),
0, PObj_constant_FLAG, 0);
/* Set up names for each header pool, * now that we have a constant string
*
* * pool available to us */
interpreter->arena_base->constant_string_header_pool->name
=
string_make(interpreter, "Constant String Pool",
strlen("Constant String Pool"), 0, PObj_constant_FLAG, 0);
interpreter->arena_base->buffer_header_pool->name =
string_make(interpreter, "Generic Header Pool",
strlen("Generic Header Pool"), 0, PObj_constant_FLAG, 0);
}
/**
* Parsing functions for quest.txt
*/
static enum parser_error parse_quest_name(struct parser *p) {
const char *name = parser_getstr(p, "name");
struct quest *h = parser_priv(p);
struct quest *q = mem_zalloc(sizeof(*q));
q->next = h;
parser_setpriv(p, q);
q->name = string_make(name);
return PARSE_ERROR_NONE;
}
/**
* Small hack to allow both spellings of armer
*/
char *de_armour(const char *name)
{
char newname[40];
char *armour;
my_strcpy(newname, name, sizeof(newname));
armour = strstr(newname, "armour");
if (armour)
my_strcpy(armour + 4, "r", 2);
return string_make(newname);
}
/*
* Open file 'fname', in mode 'mode', with filetype 'ftype'.
* Returns file handle or NULL.
*/
ang_file *file_open(const char *fname, file_mode mode, file_type ftype)
{
ang_file *f = ZNEW(ang_file);
char buf[1024];
(void)ftype;
/* Get the system-specific path */
path_parse(buf, sizeof(buf), fname);
switch (mode) {
case MODE_WRITE: {
if (ftype == FTYPE_SAVE) {
/* open only if the file does not exist */
int fd;
fd = open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, S_IRUSR | S_IWUSR);
if (fd < 0) {
/* there was some error */
f->fh = NULL;
} else {
f->fh = fdopen(fd, "wb");
}
} else {
f->fh = fopen(buf, "wb");
}
break;
}
case MODE_READ:
f->fh = fopen(buf, "rb");
break;
case MODE_APPEND:
f->fh = fopen(buf, "a+");
break;
default:
assert(0);
}
if (f->fh == NULL)
{
FREE(f);
return NULL;
}
f->fname = string_make(buf);
f->mode = mode;
if (mode != MODE_READ && file_open_hook)
file_open_hook(buf, ftype);
return f;
}
static void module_reset_dir_aux(cptr *dir, cptr new_path)
{
char buf[1024];
/* Build the new path */
strnfmt(buf, sizeof (buf), "%s%s%s", dir, PATH_SEP, new_path);
string_free(*dir);
*dir = string_make(buf);
/* Make it if needed */
if (!private_check_user_directory(*dir))
quit(format("Unable to create module dir %s\n", *dir));
}
static enum parser_error parse_store(struct parser *p) {
struct store *h = parser_priv(p);
struct store *s;
unsigned int idx = parser_getuint(p, "index") - 1;
if (idx >= MAX_STORES)
return PARSE_ERROR_OUT_OF_BOUNDS;
s = store_new(parser_getuint(p, "index") - 1);
s->name = string_make(parser_getstr(p, "name"));
s->next = h;
parser_setpriv(p, s);
return PARSE_ERROR_NONE;
}
/*
* Open file 'fname', in mode 'mode', with filetype 'ftype'.
* Returns file handle or NULL.
*/
ang_file *file_open(const char *fname, file_mode mode, file_type ftype)
{
ang_file *f = ZNEW(ang_file);
char buf[1024];
(void)ftype;
/* Get the system-specific path */
path_parse(buf, sizeof(buf), fname);
switch (mode)
{
case MODE_WRITE: f->fh = fopen(buf, "wb"); break;
case MODE_READ: f->fh = fopen(buf, "rb"); break;
case MODE_APPEND: f->fh = fopen(buf, "a+"); break;
default: f->fh = fopen(buf, "__");
}
if (f->fh == NULL)
{
FREE(f);
return NULL;
}
f->fname = string_make(buf);
f->mode = mode;
#ifdef MACH_O_CARBON
extern void fsetfileinfo(cptr path, u32b fcreator, u32b ftype);
/* OS X uses its own kind of filetypes */
if (mode != MODE_READ)
{
u32b mac_type = 'TEXT';
if (ftype == FTYPE_RAW) mac_type = 'DATA';
else if (ftype == FTYPE_SAVE) mac_type = 'SAVE';
fsetfileinfo(buf, 'A271', mac_type);
}
#endif /* MACH_O_CARBON */
#if defined(RISCOS) && 0
/* do something for RISC OS here? */
if (mode != MODE_READ)
File_SetType(n, ftype);
#endif
return f;
}
/**
* Copy all the standard quests to the player quest history
*/
void player_quests_reset(struct player *p)
{
size_t i;
if (p->quests)
player_quests_free(p);
p->quests = mem_zalloc(z_info->quest_max * sizeof(struct quest));
for (i = 0; i < z_info->quest_max; i++) {
p->quests[i].name = string_make(quests[i].name);
p->quests[i].level = quests[i].level;
p->quests[i].race = quests[i].race;
p->quests[i].max_num = quests[i].max_num;
}
}
static enum parser_error parse_owner(struct parser *p) {
struct store *s = parser_priv(p);
unsigned int maxcost = parser_getuint(p, "purse");
char *name = string_make(parser_getstr(p, "name"));
struct owner *o;
if (!s)
return PARSE_ERROR_MISSING_RECORD_HEADER;
o = mem_zalloc(sizeof *o);
o->oidx = (s->owners ? s->owners->oidx + 1 : 0);
o->next = s->owners;
o->name = name;
o->max_cost = maxcost;
s->owners = o;
return PARSE_ERROR_NONE;
}
/**
* Parsing functions for dungeon_profile.txt
*/
static enum parser_error parse_profile_name(struct parser *p) {
struct cave_profile *h = parser_priv(p);
struct cave_profile *c = mem_zalloc(sizeof *c);
size_t i;
c->name = string_make(parser_getstr(p, "name"));
for (i = 0; i < N_ELEMENTS(cave_builders); i++)
if (streq(c->name, cave_builders[i].name))
break;
if (i == N_ELEMENTS(cave_builders))
return PARSE_ERROR_NO_BUILDER_FOUND;
c->builder = cave_builders[i].builder;
c->next = h;
parser_setpriv(p, c);
return PARSE_ERROR_NONE;
}
int button_add_end(const char *label, keycode_t keypress,
int bottom, int right)
{
button_mouse* button = button_stack;
if (!button) {
return -1;
}
if (bottom) button->bottom = bottom;
if (!right && label) {
right = strlen(label);
right = button->left + right;
}
if (right) button->right = right;
if (keypress) button->key = keypress;
if (label) {
if (button->label) {
(void)string_free(button->label);
}
button->label = (char*)string_make(label);
}
if (button_call_fn) {
button->fn = button_call_fn;
}
if (button_add_2d_hook) {
int res = (*button_add_2d_hook) (button->top, button->left,
button->bottom, button->right, button->label, button->key);
if (res) { // if res != 0
if (res == 1) {
/* pop the button off of the stack */
button_stack = button->next;
/* free the button */
if (button->label)
string_free(button->label);
FREE(button);
}
return res;
}
}
/* Redraw */
p_ptr->redraw |= (PR_BUTTONS);
return 0;
}
static enum parser_error parse_r_plural(struct parser *p)
{
struct monster_race *r = parser_priv(p);
if (r == NULL)
return PARSE_ERROR_MISSING_RECORD_HEADER;
if (parser_hasval(p, "plural")) {
const char *plural = parser_getstr(p, "plural");
if (strlen(plural) > 0)
r->plural = string_make(plural);
else
r->plural = NULL;
}
return PARSE_ERROR_NONE;
}
