/**
* \file load.c
*
* This file contains the routines that deal with processing text strings
* for options, either from a NUL-terminated string passed in or from an
* rc/ini file.
*
* @addtogroup autoopts
* @{
*/
/*
* This file is part of AutoOpts, a companion to AutoGen.
* AutoOpts is free software.
* AutoOpts is Copyright (C) 1992-2018 by Bruce Korb - all rights reserved
*
* AutoOpts is available under any one of two licenses. The license
* in use must be one of these two and the choice is under the control
* of the user of the license.
*
* The GNU Lesser General Public License, version 3 or later
* See the files "COPYING.lgplv3" and "COPYING.gplv3"
*
* The Modified Berkeley Software Distribution License
* See the file "COPYING.mbsd"
*
* These files have the following sha256 sums:
*
* 8584710e9b04216a394078dc156b781d0b47e1729104d666658aecef8ee32e95 COPYING.gplv3
* 4379e7444a0e2ce2b12dd6f5a52a27a4d02d39d247901d3285c88cf0d37f477b COPYING.lgplv3
* 13aa749a5b0a454917a944ed8fffc530b784f5ead522b1aacaf4ec8aa55a6239 COPYING.mbsd
*/
/*=export_func optionMakePath
* private:
*
* what: translate and construct a path
* arg: + char * + p_buf + The result buffer +
* arg: + int + b_sz + The size of this buffer +
* arg: + char const * + fname + The input name +
* arg: + char const * + prg_path + The full path of the current program +
*
* ret-type: bool
* ret-desc: true if the name was handled, otherwise false.
* If the name does not start with ``$'', then it is handled
* simply by copying the input name to the output buffer and
* resolving the name with either
* @code{canonicalize_file_name(3GLIBC)} or @code{realpath(3C)}.
*
* doc:
*
* This routine will copy the @code{pzName} input name into the
* @code{pzBuf} output buffer, not exceeding @code{bufSize} bytes. If the
* first character of the input name is a @code{'$'} character, then there
* is special handling:
* @*
* @code{$$} is replaced with the directory name of the @code{pzProgPath},
* searching @code{$PATH} if necessary.
* @*
* @code{$@} is replaced with the AutoGen package data installation directory
* (aka @code{pkgdatadir}).
* @*
* @code{$NAME} is replaced by the contents of the @code{NAME} environment
* variable. If not found, the search fails.
*
* Please note: both @code{$$} and @code{$NAME} must be at the start of the
* @code{pzName} string and must either be the entire string or be followed
* by the @code{'/'} (backslash on windows) character.
*
* err: @code{false} is returned if:
* @*
* @bullet{} The input name exceeds @code{bufSize} bytes.
* @*
* @bullet{} @code{$$}, @code{$@@} or @code{$NAME} is not the full string
* and the next character is not '/'.
* @*
* @bullet{} libopts was built without PKGDATADIR defined and @code{$@@}
* was specified.
* @*
* @bullet{} @code{NAME} is not a known environment variable
* @*
* @bullet{} @code{canonicalize_file_name} or @code{realpath} return
* errors (cannot resolve the resulting path).
=*/
bool
optionMakePath(char * p_buf, int b_sz, char const * fname, char const * prg_path)
{
{
size_t len = strlen(fname);
/*
* IF not an environment variable, just copy the data
*/
if (*fname != '$') {
char const * src = fname;
char * dst = p_buf;
int ct = b_sz;
for (;;) {
if ( (*(dst++) = *(src++)) == NUL)
break;
if (--ct <= 0)
return false;
}
}
/*
* IF the name starts with "$$", then it must be "$$" or
* it must start with "$$/". In either event, replace the "$$"
* with the path to the executable and append a "/" character.
*/
else switch (fname[1]) {
case NUL:
return false;
case '$':
if (! add_prog_path(p_buf, b_sz, fname, prg_path))
return false;
break;
case '@':
if (program_pkgdatadir[0] == NUL)
return false;
default:
if (! add_env_val(p_buf, b_sz, fname))
return false;
}
return get_realpath(p_buf, b_sz);
}
/**
* convert a leading "$$" into a path to the executable.
*/
static bool
add_prog_path(char * buf, int b_sz, char const * fname, char const * prg_path)
{
char const * path;
char const * pz;
int skip = 2;
size_t fname_len;
size_t dir_len; //!< length of the directory portion of the path to the exe
switch (fname[2]) {
case DIRCH:
skip = 3;
case NUL:
break;
default:
return false;
}
/*
* See if the path is included in the program name.
* If it is, we're done. Otherwise, we have to hunt
* for the program using "pathfind".
*/
if (strchr(prg_path, DIRCH) != NULL)
path = prg_path;
else {
path = pathfind(getenv("PATH"), prg_path, "rx");
if (path == NULL)
return false;
}
pz = strrchr(path, DIRCH);
/*
* IF we cannot find a directory name separator,
* THEN we do not have a path name to our executable file.
*/
if (pz == NULL)
return false;
/*
* Concatenate the file name to the end of the executable path.
* The result may be either a file or a directory.
*/
if (dir_len + fname_len > (unsigned)b_sz)
return false;
/*
* If the "path" path was gotten from "pathfind()", then it was
* allocated and we need to deallocate it.
*/
if (path != prg_path)
AGFREE(path);
return true;
}
/**
* Trim leading and trailing white space.
* If we are cooking the text and the text is quoted, then "cook"
* the string. To cook, the string must be quoted.
*
* @param[in,out] txt the input and output string
* @param[in] mode the handling mode (cooking method)
*/
static void
munge_str(char * txt, tOptionLoadMode mode)
{
char * end;
if (mode == OPTION_LOAD_KEEP)
return;
if (IS_WHITESPACE_CHAR(*txt)) {
char * src = SPN_WHITESPACE_CHARS(txt+1);
size_t l = strlen(src) + 1;
memmove(txt, src, l);
end = txt + l - 1;
} else
end = txt + strlen(txt);
end = SPN_WHITESPACE_BACK(txt, end);
*end = NUL;
if (mode == OPTION_LOAD_UNCOOKED)
return;
switch (*txt) {
default: return;
case '"':
case '\'': break;
}
switch (end[-1]) {
default: return;
case '"':
case '\'': break;
}
(void)ao_string_cook(txt, NULL);
}
static char *
assemble_arg_val(char * txt, tOptionLoadMode mode)
{
char * end = strpbrk(txt, ARG_BREAK_STR);
int space_break;
/*
* Not having an argument to a configurable name is okay.
*/
if (end == NULL)
return txt + strlen(txt);
/*
* If we are keeping all whitespace, then the modevalue starts with the
* character that follows the end of the configurable name, regardless
* of which character caused it.
*/
if (mode == OPTION_LOAD_KEEP) {
*(end++) = NUL;
return end;
}
/*
* If the name ended on a white space character, remember that
* because we'll have to skip over an immediately following ':' or '='
* (and the white space following *that*).
*/
space_break = IS_WHITESPACE_CHAR(*end);
*(end++) = NUL;
end = SPN_WHITESPACE_CHARS(end);
if (space_break && ((*end == ':') || (*end == '=')))
end = SPN_WHITESPACE_CHARS(end+1);
return end;
}
static char *
trim_quotes(char * arg)
{
switch (*arg) {
case '"':
case '\'':
ao_string_cook(arg, NULL);
}
return arg;
}
/**
* See if the option is to be processed in the current scan direction
* (-1 or +1).
*/
static bool
direction_ok(opt_state_mask_t f, int dir)
{
if (dir == 0)
return true;
switch (f & (OPTST_IMM|OPTST_DISABLE_IMM)) {
case 0:
/*
* The selected option has no immediate action.
* THEREFORE, if the direction is PRESETTING
* THEN we skip this option.
*/
if (PRESETTING(dir))
return false;
break;
case OPTST_IMM:
if (PRESETTING(dir)) {
/*
* We are in the presetting direction with an option we handle
* immediately for enablement, but normally for disablement.
* Therefore, skip if disabled.
*/
if ((f & OPTST_DISABLED) == 0)
return false;
} else {
/*
* We are in the processing direction with an option we handle
* immediately for enablement, but normally for disablement.
* Therefore, skip if NOT disabled.
*/
if ((f & OPTST_DISABLED) != 0)
return false;
}
break;
case OPTST_DISABLE_IMM:
if (PRESETTING(dir)) {
/*
* We are in the presetting direction with an option we handle
* immediately for disablement, but normally for handling.
* Therefore, skip if NOT disabled.
*/
if ((f & OPTST_DISABLED) != 0)
return false;
} else {
/*
* We are in the processing direction with an option we handle
* immediately for disablement, but normally for handling.
* Therefore, skip if disabled.
*/
if ((f & OPTST_DISABLED) == 0)
return false;
}
break;
case OPTST_IMM|OPTST_DISABLE_IMM:
/*
* The selected option is always for immediate action.
* THEREFORE, if the direction is PROCESSING
* THEN we skip this option.
*/
if (PROCESSING(dir))
return false;
break;
}
return true;
}
/**
* Load an option from a block of text. The text must start with the
* configurable/option name and be followed by its associated value.
* That value may be processed in any of several ways. See "tOptionLoadMode"
* in autoopts.h.
*
* @param[in,out] opts program options descriptor
* @param[in,out] opt_state option processing state
* @param[in,out] line source line with long option name in it
* @param[in] direction current processing direction (preset or not)
* @param[in] load_mode option loading mode (OPTION_LOAD_*)
*/
static void
load_opt_line(tOptions * opts, tOptState * opt_state, char * line,
tDirection direction, tOptionLoadMode load_mode )
{
/*
* When parsing a stored line, we only look at the characters after
* a hyphen. Long names must always be at least two characters and
* short options are always exactly one character long.
*/
line = SPN_LOAD_LINE_SKIP_CHARS(line);
{
char * arg = assemble_arg_val(line, load_mode);
if (IS_OPTION_NAME_CHAR(line[1])) {
if (! SUCCESSFUL(opt_find_long(opts, line, opt_state)))
return;
} else if (! SUCCESSFUL(opt_find_short(opts, *line, opt_state)))
return;
if ((! CALLED(direction)) && (opt_state->flags & OPTST_NO_INIT))
return;
opt_state->pzOptArg = trim_quotes(arg);
}
if (! direction_ok(opt_state->flags, direction))
return;
/*
* Fix up the args.
*/
if (OPTST_GET_ARGTYPE(opt_state->pOD->fOptState) == OPARG_TYPE_NONE) {
if (*opt_state->pzOptArg != NUL)
return;
opt_state->pzOptArg = NULL;
/*=export_func optionLoadLine
*
* what: process a string for an option name and value
*
* arg: tOptions *, opts, program options descriptor
* arg: char const *, line, NUL-terminated text
*
* doc:
*
* This is a client program callable routine for setting options from, for
* example, the contents of a file that they read in. Only one option may
* appear in the text. It will be treated as a normal (non-preset) option.
*
* When passed a pointer to the option struct and a string, it will find
* the option named by the first token on the string and set the option
* argument to the remainder of the string. The caller must NUL terminate
* the string. The caller need not skip over any introductory hyphens.
* Any embedded new lines will be included in the option
* argument. If the input looks like one or more quoted strings, then the
* input will be "cooked". The "cooking" is identical to the string
* formation used in AutoGen definition files (@pxref{basic expression}),
* except that you may not use backquotes.
*
* err: Invalid options are silently ignored. Invalid option arguments
* will cause a warning to print, but the function should return.
=*/
void
optionLoadLine(tOptions * opts, char const * line)
{
tOptState st = OPTSTATE_INITIALIZER(SET);
char * pz;
proc_state_mask_t sv_flags = opts->fOptSet;
opts->fOptSet &= ~OPTPROC_ERRSTOP;
AGDUPSTR(pz, line, "opt line");
load_opt_line(opts, &st, pz, DIRECTION_CALLED, OPTION_LOAD_COOKED);
AGFREE(pz);
opts->fOptSet = sv_flags;
}
/** @}
*
* Local Variables:
* mode: C
* c-file-style: "stroustrup"
* indent-tabs-mode: nil
* End:
* end of autoopts/load.c */
