static
int add_alias(struct poclidek_ctx *cctx,
const char *aliasname, const char *cmdline)
{
struct poclidek_cmd *cmd, tmpcmd;
int rc = 1;
tmpcmd.name = (char*)aliasname;
if ((cmd = n_array_bsearch(cctx->commands, &tmpcmd)) == NULL) {
cmd = command_new_alias(aliasname, cmdline);
n_array_push(cctx->commands, cmd);
} else {
if ((cmd->flags & COMMAND_IS_ALIAS) == 0) {
logn(LOGWARN, _("%s: alias could not shadow a command"), aliasname);
rc = 0;
} else {
if (poldek_verbose() > 1)
logn(LOGWARN, _("%s (%s) overwrites %s"), aliasname, cmdline,
cmd->cmdline);
free(cmd->name);
cmd->name = n_strdup(aliasname);
free(cmd->cmdline);
cmd->cmdline = n_strdup(cmdline);
}
}
n_array_sort(cctx->commands);
return rc;
}
/* determine to what command alias is aliased */
static char *alias_to(struct poclidek_ctx *cctx, const char *cmdline)
{
tn_array *ents;
char *p, *cmd = NULL;
if (strchr(cmdline, '|') == NULL) {
cmd = n_strdup(cmdline);
} else if ((ents = poclidek_prepare_cmdline(cctx, cmdline))) {
struct cmd_chain_ent *ent = n_array_nth(ents, 0);
while (ent->next_piped)
ent = ent->next_piped;
cmd = n_strdup(ent->cmd->name);
n_array_free(ents);
}
if (cmd == NULL)
return NULL;
if ((p = strchr(cmd, ' ')))
*p = '\0';
return cmd;
}
static
int do_test_capmatch(char *capevr, char *evr, int relation, unsigned maflags,
int expected)
{
struct capreq *cap, *req;
int rc;
if (capevr)
cap = capreq_new_evr(NULL, "coo", n_strdup(capevr), REL_EQ, 0);
else
cap = capreq_new(NULL, "coo", 0, NULL, NULL, 0, 0);
req = capreq_new_evr(NULL, "coo", n_strdup(evr), relation, 0);
rc = cap_xmatch_req(cap, req, maflags) ? 1 : 0;
msgn_i(1, 2, "%s match%s %s => %s", capreq_snprintf_s(cap),
maflags_snprintf_s(maflags), capreq_snprintf_s0(req),
rc ? "YES" : "NO");
fail_if(rc != expected,
"match %s <=> %s not equal %d",
capreq_snprintf_s0(cap), capreq_snprintf_s(req), expected);
capreq_free(cap);
capreq_free(req);
return rc;
}
static int do_test_pkgmatch(char *capevr, char *evr, int relation, unsigned maflags,
int expected)
{
struct pkg *pkg;
struct capreq *req;
const char *ver, *rel;
int rc;
int32_t epoch;
if (!poldek_util_parse_evr(n_strdup(capevr), &epoch, &ver, &rel))
return -1;
pkg = pkg_new("poo", epoch, ver, rel, NULL, NULL);
req = capreq_new_evr(NULL, "poo", n_strdup(evr), relation, 0);
rc = pkg_xmatch_req(pkg, req, maflags) ? 1 : 0;
msgn_i(1, 2, "%s match%s %s => %s", pkg_evr_snprintf_s(pkg),
maflags_snprintf_s(maflags), capreq_snprintf_s(req),
rc ? "YES" : "NO");
fail_if(rc != expected,
"match %s <=> %s not equal %d",
pkg_evr_snprintf_s(pkg), capreq_snprintf_s(req), expected);
pkg_free(pkg);
capreq_free(req);
return rc;
}
struct source *source_new(const char *name, const char *type,
const char *path, const char *pkg_prefix)
{
struct source *src;
struct stat st;
char clpath[PATH_MAX], clprefix[PATH_MAX];
int n;
n_assert(name || path);
if (path) {
if ((n = vf_cleanpath(clpath, sizeof(clpath), path)) == 0 ||
n == sizeof(clpath))
return NULL;
if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
if (clpath[n - 1] != '/')
clpath[n++] = '/';
} else {
int l = strlen(path);
if (clpath[n - 1] != '/' && path[l - 1] == '/')
clpath[n++] = '/';
}
clpath[n] = '\0';
}
if (pkg_prefix) {
n_assert(path);
if ((n = vf_cleanpath(clprefix, sizeof(clprefix), pkg_prefix)) == 0 ||
n == sizeof(clprefix))
return NULL;
}
src = source_malloc();
if (name) {
src->flags |= PKGSOURCE_NAMED;
src->name = n_strdup(name);
}
if (type) {
src->type = n_strdup(type);
src->flags |= PKGSOURCE_TYPE;
} else {
src->type = n_strdup(poldek_conf_PKGDIR_DEFAULT_TYPE);
}
if (path)
src->path = n_strdup(clpath);
if (pkg_prefix)
src->pkg_prefix = n_strdup(clprefix);
return src;
}
static
error_t parse_opt(int key, char *arg, struct argp_state *state)
{
struct poclidek_opgroup_rt *rt;
struct arg_s *arg_s;
rt = state->input;
if (rt->_opdata) {
arg_s = rt->_opdata;
} else {
arg_s = n_malloc(sizeof(*arg_s));
arg_s->cnflags = 0;
arg_s->size = arg_s->first_free_space = 0;
arg_s->prefix = NULL;
rt->_opdata = arg_s;
rt->_opdata_free = arg_s_free;
rt->run = oprun;
}
switch (key) {
case OPT_SPLITSIZE: {
char *p;
int rc;
if ((p = strrchr(arg, ':'))) {
rc = sscanf(arg, "%d:%d", &arg_s->size,
&arg_s->first_free_space);
rc = (rc == 2);
} else {
rc = sscanf(arg, "%d", &arg_s->size);
rc = (rc == 1);
}
if (rc)
arg_s->cnflags |= DO_SPLIT;
else {
logn(LOGERR, _("split: bad option argument"));
exit(EXIT_FAILURE);
}
}
break;
case OPT_SPLITCONF:
poldek_configure(rt->ctx, POLDEK_CONF_PRIFILE, arg);
break;
case OPT_SPLITPREFIX:
arg_s->prefix = n_strdup(arg);
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static void set_game_filename(const char *name)
{
n_free(game_filename);
game_filename = 0;
#if defined(_GNU_SOURCE)
game_filename = canonicalize_file_name(name);
#else
#if defined(_BSD_SOURCE) || defined(_XOPEN_SOURCE)
game_filename = (char *) n_malloc(PATH_MAX);
if(!realpath(name, game_filename)) {
n_free(game_filename);
game_filename = 0;
}
#else
#ifdef __DJGPP__
game_filename = (char *) n_malloc(FILENAME_MAX);
_fixpath(name, game_filename);
#endif
#endif
#endif
if(!game_filename)
game_filename = n_strdup(name);
}
static
struct poclidek_cmd *command_new_alias(const char *name, const char *cmdline)
{
struct poclidek_cmd *alias;
alias = n_malloc(sizeof(*alias));
memset(alias, 0, sizeof(*alias));
alias->flags = COMMAND_IS_ALIAS | COMMAND__MALLOCED;
alias->name = n_strdup(name);
alias->cmdline = n_strdup(cmdline);
alias->aliasto = NULL;
alias->_free = free_alias;
if (strchr(alias->cmdline, '%'))
alias->flags |= COMMAND_PARAMETERIZED;
return alias;
}
BOOL automap_init(int numobj, const char *location_exp)
{
automap_kill();
if(!roomsymbol)
roomsymbol = n_strdup("*udb@UDB+");
if(location_exp)
loc_exp = n_strdup(location_exp);
n_hash_construct_table(&rooms, numobj / 2);
automap_win = z_split_screen(wintype_TextGrid,
automap_split | winmethod_Fixed,
automap_draw_callback, automap_mouse_callback);
return TRUE;
}
const char *expand_env_var(const char *v)
{
char tmp[PATH_MAX];
const char *s;
s = poldek_util_expand_env_vars(tmp, sizeof(tmp), v);
fail_if(s == NULL);
return n_strdup(s);
}
static char *deps_generator(const char *text, int state)
{
static tn_array *deps_table = NULL; /* XXX static variable */
if (state == 0) {
tn_array *ents;
int i, j, len;
ents = sh_ctx.cctx->currdir->pkg_dent_ents;
if (ents == NULL)
return NULL;
len = strlen(text);
n_assert(deps_table == NULL);
/* create deps_table */
deps_table = n_array_new(n_array_size(ents) * 4, NULL, (tn_fn_cmp)strcmp);
/* fill deps_table with data */
for (i = 0; i < n_array_size(ents); i++) {
struct pkg_dent *ent = n_array_nth(ents, i);
struct pkg *pkg = ent->pkg_dent_pkg;
tn_array *caps = NULL;
if (pkg_dent_isdir(ent))
continue;
switch (sh_ctx.completion_ctx) {
case COMPLETITION_CTX_WHAT_PROVIDES:
caps = pkg->caps;
break;
case COMPLETITION_CTX_WHAT_REQUIRES:
caps = pkg->reqs;
break;
}
if (caps) {
for (j = 0; j < n_array_size(caps); j++) {
struct capreq *cr = n_array_nth(caps, j);
const char *name = capreq_name(cr);
if (len == 0 || strncmp(name, text, len) == 0)
n_array_push(deps_table, (void*)name);
}
}
}
}
if (state >= n_array_size(deps_table)) {
n_array_cfree(&deps_table);
return NULL;
}
return n_strdup(n_array_nth(deps_table, state));
}
static
unsigned get_subopt(struct source *src, struct src_option *opt,
const char *str, const char *options_str)
{
unsigned v = 0;
n_assert(strncmp(str, opt->name, opt->len) == 0);
str += opt->len;
if (*str != '=') {
logn(LOGWARN, _("%s: %s unknown option"), options_str, str);
return 0;
}
str++;
if (opt->flag & PKGSOURCE_TYPE) {
src->type = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_DSCR) {
src->dscr = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_COMPRESS) {
src->compress = n_strdup(str);
v = 1;
} else if (opt->flag & PKGSOURCE_PRI) {
if (sscanf(str, "%d", &v) == 1) {
src->pri = v;
v = 1;
}
}
if (v == 0)
logn(LOGWARN, _("%s%sinvalid value ('%s') for option '%s'"),
src->name ? src->name : "", src->name ? ": " : "",
str, opt->name);
return v;
}
static tn_array *parse_depdirs(char *str)
{
char *p, *token;
tn_array *arr;
arr = n_array_new(16, free, (tn_fn_cmp)strcmp);
p = str;
p = eatws(p);
while ((token = next_tokn(&p, ':', NULL)) != NULL) {
n_array_push(arr, n_strdup(token));
}
n_array_push(arr, n_strdup(p));
if (n_array_size(arr))
n_array_sort(arr);
return arr;
}
static
void set_config_option(struct args *argsp, const char *op, const char *val)
{
char tmp[1024];
if (argsp->addon_cnflines == NULL)
argsp->addon_cnflines = n_array_new(8, free, NULL);
n_snprintf(tmp, sizeof(tmp), "%s = %s", op, val);
n_array_push(argsp->addon_cnflines, n_strdup(tmp));
}
strid_t startup_findfile(void)
{
static DIR *dir = NULL;
static char *pathstart = NULL;
static char *path = NULL;
strid_t stream;
struct dirent *d;
char *name = NULL;
if(!pathstart) {
char *p = search_path;
if(!p)
return 0;
pathstart = n_strdup(p);
if(!(path = n_strtok(pathstart, ":"))) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
do {
if(!dir) {
dir = opendir(path);
if(!dir) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
d = readdir(dir);
if(!d) {
closedir(dir);
dir = NULL;
if(!(path = n_strtok(NULL, ":"))) {
n_free(pathstart);
pathstart = 0;
return 0;
}
}
} while(!dir);
name = (char *) n_malloc(n_strlen(path) + n_strlen(d->d_name) + 2);
n_strcpy(name, path);
n_strcat(name, "/");
n_strcat(name, d->d_name);
stream = glkunix_stream_open_pathname(name, fileusage_Data |
fileusage_BinaryMode, 0);
if(stream)
set_game_filename(name);
n_free(name);
return stream;
}
void cTraits::LoadXMLTraits(string filename)
{
CLog l;
l.ss() << "loading " << filename; l.ssend();
TiXmlDocument doc(filename);
if (!doc.LoadFile())
{
l.ss() << "can't load XML girls " << filename << endl;
l.ss() << "Error: line " << doc.ErrorRow() << ", col " << doc.ErrorCol() << ": " << doc.ErrorDesc() << endl;
l.ssend();
return;
}
const char *pt;
sTrait* newTrait = 0;
TiXmlElement *el, *root_el = doc.RootElement();
// loop over the elements attached to the root
for (el = root_el->FirstChildElement(); el; el = el->NextSiblingElement())
{
newTrait = new sTrait;
if (pt = el->Attribute("Name")) newTrait->m_Name = n_strdup(pt);
if (pt = el->Attribute("Desc")) newTrait->m_Desc = n_strdup(pt);
if (pt = el->Attribute("Type")) newTrait->m_Type = n_strdup(pt);
if (pt = el->Attribute("InheritChance"))
{
int ival = -1;
pt = el->Attribute("InheritChance", &ival);
newTrait->m_InheritChance = ival;
}
if (pt = el->Attribute("RandomChance"))
{
int ival = -1;
pt = el->Attribute("RandomChance", &ival);
newTrait->m_RandomChance = ival;
}
AddTrait(newTrait);
newTrait = 0;
}
}
static
char *source_set(char **member, const char *value)
{
if (*member) {
free(*member);
*member = NULL;
}
if (value)
*member = n_strdup(value);
return *member;
}
struct source *source_set_pkg_prefix(struct source *src, const char *prefix)
{
char clprefix[PATH_MAX];
int n;
n_assert(prefix);
n_assert(src->pkg_prefix == NULL);
if ((n = vf_cleanpath(clprefix, sizeof(clprefix), prefix)) == 0 ||
n == sizeof(clprefix))
return NULL;
src->pkg_prefix = n_strdup(clprefix);
return src;
}
static char *make_conf_line(const char *opname, int no, int sep)
{
char line[1024];
int i = 0, n = 0;
n = n_snprintf(line, sizeof(line), "%s = ", opname);
while (values_list[i]) {
char buf[64];
n_snprintf(buf, sizeof(buf), "%s%d", values_list[i], no);
n += n_snprintf(&line[n], sizeof(line) - n,
"%s %c", buf, sep);
i++;
}
line[n - 1] = '\0'; /* remove last sep */
return n_strdup(line);
}
strid_t startup_open(const char *name)
{
strid_t str;
char *s;
str = glkunix_stream_open_pathname((char *) name, fileusage_Data | fileusage_BinaryMode, 0);
if(str) {
set_game_filename(name);
#ifdef USE_GARGLK_FEATURES
s = strrchr(name, '\\');
if (!s) s = strrchr(name, '/');
garglk_set_story_name(s ? s + 1 : name);
#endif
} else {
char *path = search_path;
if(path) {
char *p;
char *newname = (char *) n_malloc(strlen(path) + strlen(name) + 2);
path = n_strdup(path);
for(p = n_strtok(path, ":"); p; p = n_strtok(NULL, ":")) {
n_strcpy(newname, p);
n_strcat(newname, "/");
n_strcat(newname, name);
str = glkunix_stream_open_pathname((char *) newname, fileusage_Data |
fileusage_BinaryMode, 0);
if(str) {
set_game_filename(newname);
#ifdef USE_GARGLK_FEATURES
s = strrchr(newname, '\\');
if (!s) s = strrchr(newname, '/');
garglk_set_story_name(s ? s + 1 : newname);
#endif
break;
}
}
n_free(path);
}
}
if(!str)
fprintf(stderr, "Cannot open '%s'\n", name);
return str;
}
static
int posthook_diff(struct pkgdir *pd1, struct pkgdir* pd2, struct pkgdir *diff)
{
struct pndir *idx, *idx2;
pd2 = pd2; /* unused */
if ((idx2 = pd1->mod_data) == NULL)
return 0;
idx = diff->mod_data;
if (idx == NULL) {
idx = n_malloc(sizeof(*idx));
pndir_init(idx);
diff->mod_data = idx;
}
idx->md_orig = n_strdup(idx2->dg->md);
return 1;
}
static
int get_conf_opt_list(const tn_hash *htcnf, const char *name,
tn_array *tolist)
{
tn_array *list;
int i = 0;
if (n_array_size(tolist) > 0)
return 0;
if ((list = poldek_conf_get_multi(htcnf, name))) {
for (i=0; i < n_array_size(list); i++)
n_array_push(tolist, n_strdup(n_array_nth(list, i)));
n_array_free(list);
}
n_array_sort(tolist);
n_array_uniq(tolist);
return i;
}
static char *command_generator(const char *text, int state)
{
static int i, len;
char *name = NULL;
struct poclidek_cmd tmpcmd;
tmpcmd.name = (char*)text;
if (state == 0) {
len = strlen(text);
if (len == 0)
i = 0;
else
i = n_array_bsearch_idx_ex(sh_ctx.cctx->commands, &tmpcmd,
(tn_fn_cmp)poclidek_cmd_ncmp);
}
if (i > -1 && i < n_array_size(sh_ctx.cctx->commands)) {
struct poclidek_cmd *cmd = n_array_nth(sh_ctx.cctx->commands, i++);
if (len == 0 || strncmp(cmd->name, text, len) == 0)
name = n_strdup(cmd->name);
}
return name;
}
int pndir_open(struct pndir *idx, const char *path, int vfmode, unsigned flags,
const char *srcnam)
{
pndir_init(idx);
if ((flags & PKGDIR_OPEN_DIFF) == 0)
if ((idx->dg = pndir_digest_new(path, vfmode, srcnam)) == NULL)
return 0;
if (srcnam)
idx->srcnam = n_strdup(srcnam);
idx->db = do_dbopen(path, vfmode, &idx->_vf, srcnam);
if (idx->db == NULL)
goto l_err;
snprintf(idx->idxpath, sizeof(idx->idxpath), "%s", path);
return 1;
l_err:
pndir_close(idx);
return 0;
}
static void code_prompt(const char *string)
#line 39 "nitfol.opt"
{ n_free(db_prompt); db_prompt = n_strdup(string); }
static void code_path(const char *string)
#line 42 "nitfol.opt"
{ n_free(search_path); search_path = n_strdup(string); }
static char *arg_generator(const char *text, int state, int genpackages)
{
int uprev = 0, upgradeable_mode = 0;
static int i, len;
const char *name = NULL;
tn_array *ents;
if (sh_ctx.completion_ctx == COMPLETITION_CTX_UPGRADEABLE) {
char pwd[256];
upgradeable_mode = 1;
poclidek_pwd(sh_ctx.cctx, pwd, sizeof(pwd));
#if 0 /* for "installed> upgrade foo-X with foo-X"; disabled - NFY */
if (n_str_eq(pwd, POCLIDEK_INSTALLEDDIR))
uprev = 1;
#endif
}
if (genpackages) {
if (sh_ctx.completion_ctx == COMPLETITION_CTX_INSTALLED)
ents = poclidek_get_dent_ents(sh_ctx.cctx, POCLIDEK_INSTALLEDDIR);
else
ents = sh_ctx.cctx->currdir->pkg_dent_ents;
} else {
ents = sh_ctx.cctx->rootdir->pkg_dent_ents;
// completion through directory tree, NFY
//const char *path = text ? n_dirname(n_strdup(text)) : n_strdup(".");
//ents = poclidek_get_dents(sh_ctx.cctx, path);
//ents = sh_ctx.cctx->rootdir->pkg_dent_ents;
//printf("path %s, ents = %d, %s\n", path, ents ? n_array_size(ents) : 0, text);
//free(path);
}
if (ents == NULL)
return NULL;
//printf("text %s\n", text);
if (state == 0) {
len = strlen(text);
if (len == 0)
i = 0;
else
i = n_array_bsearch_idx_ex(ents, n_basenam(text),
(tn_fn_cmp)pkg_dent_strncmp);
}
while (i > -1 && i < n_array_size(ents)) {
struct pkg_dent *ent = n_array_nth(ents, i++);
char ent_path[PATH_MAX];
const char *path;
if (genpackages) {
struct pkg *pkg = ent->pkg_dent_pkg;
if (pkg_dent_isdir(ent))
continue;
if (upgradeable_mode && !is_upgradeable(sh_ctx.cctx, pkg, uprev))
continue;
path = ent->name;
} else {
if (!pkg_dent_isdir(ent))
continue;
path = ent->name;
//path = poclidek_dent_dirpath(ent_path, sizeof(ent_path), ent);
}
//printf("path %s, (%s)\n", path, text);
if (len == 0 || strncmp(text, path, len) == 0) {
name = path;
break;
} else if (len > 1 && *text == '/' &&
strncmp((text + 1), path, len - 1) == 0) {
name = poclidek_dent_dirpath(ent_path, sizeof(ent_path), ent);
break;
} else if (len == 1 && *text == '/') {
name = poclidek_dent_dirpath(ent_path, sizeof(ent_path), ent);
break;
}
}
if (name)
return n_strdup(name);
return NULL;
}
struct source *source_new_htcnf(const tn_hash *htcnf)
{
char spec[PATH_MAX];
struct source *src;
const char *vs, *type, *srcnam;
int n = 0;
int v;
vs = poldek_conf_get(htcnf, "name", NULL);
if (vs == NULL)
vs = "anon";
srcnam = vs;
n += n_snprintf(&spec[n], sizeof(spec) - n, "%s", vs);
if ((vs = poldek_conf_get(htcnf, "type", NULL)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",type=%s", vs);
type = vs;
if ((v = poldek_conf_get_int(htcnf, "pri", 0)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",pri=%d", v);
if ((v = poldek_conf_get_bool(htcnf, "noauto", 0)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",noauto");
else if ((v = poldek_conf_get_bool(htcnf, "auto", 1)) == 0)
n += n_snprintf(&spec[n], sizeof(spec) - n, ",noauto");
if ((v = poldek_conf_get_bool(htcnf, "noautoup", 0)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",noautoup");
else if ((v = poldek_conf_get_bool(htcnf, "autoup", 1)) == 0)
n += n_snprintf(&spec[n], sizeof(spec) - n, ",noautoup");
if ((v = poldek_conf_get_bool(htcnf, "signed", 0)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",sign");
else if ((v = poldek_conf_get_bool(htcnf, "sign", 0)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",sign");
if ((vs = poldek_conf_get(htcnf, "lang", NULL)))
n += n_snprintf(&spec[n], sizeof(spec) - n, ",lang=%s", vs);
vs = poldek_conf_get(htcnf, "path", NULL);
if (vs == NULL)
vs = poldek_conf_get(htcnf, "url", NULL);
if (vs == NULL && type && n_str_ne(type, source_TYPE_GROUP)) {
logn(LOGERR, "source: %s: missing required 'path'", srcnam);
return NULL;
}
if (type && n_str_eq(type, source_TYPE_GROUP)) {
char tmp[PATH_MAX], *p;
int i, n = 0;
tn_array *arr = poldek_conf_get_multi(htcnf, "sources");
n_array_sort(arr);
for (i=0; i<n_array_size(arr); i++)
n += n_snprintf(&tmp[n], sizeof(tmp) - n, "%s%s", n_array_nth(arr, i),
i < n_array_size(arr) - 1 ? ", " : "");
n_array_free(arr);
n_strdupap((char*)tmp, &p);
vs = p;
}
//printf("spec %d = %s\n", n_hash_size(htcnf), spec);
//n_assert(vs);
n_snprintf(&spec[n], sizeof(spec) - n, " %s", vs);
vs = poldek_conf_get(htcnf, "prefix", NULL);
src = source_new_pathspec(NULL, spec, vs);
vs = poldek_conf_get(htcnf, "original type", NULL);
if (vs && src->type && n_str_eq(src->type, vs)) {
logn(LOGERR, "%s: original type and type must be differ",
source_idstr(src));
source_free(src);
return NULL;
}
if (vs)
src->original_type = n_strdup(vs);
get_conf_opt_list(htcnf, "exclude path", src->exclude_path);
get_conf_opt_list(htcnf, "ignore", src->ign_patterns);
return src;
}
static void code_mapsym(const char *string)
#line 67 "nitfol.opt"
{ n_free(roomsymbol); roomsymbol = n_strdup(string); }
static void cp_str_ifnotnull(char **dst, const char *src)
{
if (src)
*dst = n_strdup(src);
}
