/**
* Associate a name with strtol() value, defaulting to zero.
*
* @param[in,out] pp argument list to add to
* @param[in] name the name of the "suboption"
* @param[in] nm_len the length of the name
* @param[in] val the numeric value for the suboption
* @param[in] d_len the length of the value
*
* @returns the new value structure
*/
static tOptionValue *
add_number(void ** pp, char const * name, size_t nm_len,
char const * val, size_t d_len)
{
size_t sz = nm_len + sizeof(tOptionValue) + 1;
tOptionValue * new_val = AGALOC(sz, "int val");
/*
* Scan over whitespace is constrained by "d_len"
*/
while (IS_WHITESPACE_CHAR(*val) && (d_len > 0)) {
d_len--; val++;
}
if (d_len == 0)
new_val->v.longVal = 0;
else
new_val->v.longVal = strtol(val, 0, 0);
new_val->valType = OPARG_TYPE_NUMERIC;
new_val->pzName = (char *)(new_val + 1);
memcpy(new_val->pzName, name, nm_len);
new_val->pzName[ nm_len ] = NUL;
addArgListEntry(pp, new_val);
return new_val;
}
void
manageAllocatedData(void* pd)
{
static int allocPtrCt = 0;
static int usedPtrCt = 0;
static void** papAllocData = NULL;
if (pd == NULL) {
void** pp = papAllocData;
if (pp == NULL)
return;
while (--usedPtrCt >= 0)
AGFREE(*(pp++));
AGFREE(papAllocData);
papAllocData = NULL;
} else {
if (++usedPtrCt > allocPtrCt) {
allocPtrCt += 16;
papAllocData = (usedPtrCt > 1)
? AGREALOC(papAllocData, allocPtrCt * sizeof(void*), "atbl")
: AGALOC(allocPtrCt * sizeof(void*), "atbl");
}
papAllocData[usedPtrCt-1] = pd;
}
}
/**
* Find the end marker for the named section of XML.
* Trim that text there, trimming trailing white space for all modes
* except for OPTION_LOAD_UNCOOKED.
*/
static char *
trim_xml_text(char * intxt, char const * pznm, tOptionLoadMode mode)
{
static char const fmt[] = "</%s>";
size_t len = strlen(pznm) + sizeof(fmt) - 2 /* for %s */;
char * etext;
{
char z[64], *pz = z;
if (len >= sizeof(z))
pz = AGALOC(len, "scan name");
len = (size_t)sprintf(pz, fmt, pznm);
*intxt = ' ';
etext = strstr(intxt, pz);
if (pz != z) AGFREE(pz);
}
if (etext == NULL)
return etext;
{
char * result = etext + len;
if (mode != OPTION_LOAD_UNCOOKED)
etext = SPN_WHITESPACE_BACK(intxt, etext);
*etext = NUL;
return result;
}
}
/*=export_func optionSaveState
*
* what: saves the option state to memory
* arg: tOptions*, pOpts, program options descriptor
*
* doc:
*
* This routine will allocate enough memory to save the current option
* processing state. If this routine has been called before, that memory
* will be reused. You may only save one copy of the option state. This
* routine may be called before optionProcess(3AO). If you do call it
* before the first call to optionProcess, then you may also change the
* contents of argc/argv after you call optionRestore(3AO)
*
* In fact, more strongly put: it is safest to only use this function
* before having processed any options. In particular, the saving and
* restoring of stacked string arguments and hierarchical values is
* disabled. The values are not saved.
*
* err: If it fails to allocate the memory,
* it will print a message to stderr and exit.
* Otherwise, it will always succeed.
=*/
void
optionSaveState(tOptions* pOpts)
{
tOptions* p = (tOptions*)pOpts->pSavedState;
if (p == NULL) {
size_t sz = sizeof( *pOpts ) + (pOpts->optCt * sizeof( tOptDesc ));
p = AGALOC( sz, "saved option state" );
if (p == NULL) {
tCC* pzName = pOpts->pzProgName;
if (pzName == NULL) {
pzName = pOpts->pzPROGNAME;
if (pzName == NULL)
pzName = zNil;
}
fprintf( stderr, zCantSave, pzName, sz );
exit( EXIT_FAILURE );
}
pOpts->pSavedState = p;
}
memcpy( p, pOpts, sizeof( *p ));
memcpy( p + 1, pOpts->pOptDesc, p->optCt * sizeof( tOptDesc ));
fixupSavedOptionArgs(pOpts);
}
/* addNestedValue
*
* Associate a name with either a string or no value.
*/
static tOptionValue*
addNestedValue( void** pp, char const* pzName, size_t nameLen,
char* pzValue, size_t dataLen )
{
tOptionValue* pNV;
if (dataLen == 0) {
size_t sz = nameLen + sizeof(*pNV) + 1;
pNV = AGALOC( sz, "empty nested value pair" );
if (pNV == NULL)
return NULL;
pNV->v.nestVal = NULL;
pNV->valType = OPARG_TYPE_HIERARCHY;
pNV->pzName = (char*)(pNV + 1);
memcpy( pNV->pzName, pzName, nameLen );
pNV->pzName[ nameLen ] = NUL;
} else {
pNV = optionLoadNested( pzValue, pzName, nameLen );
}
if (pNV != NULL)
addArgListEntry( pp, pNV );
return pNV;
}
/* addNumberValue
*
* Associate a name with either a string or no value.
*/
static tOptionValue*
addNumberValue( void** pp, char const* pzName, size_t nameLen,
char const* pzValue, size_t dataLen )
{
tOptionValue* pNV;
size_t sz = nameLen + sizeof(*pNV) + 1;
pNV = AGALOC( sz, "option name/bool value pair" );
if (pNV == NULL)
return NULL;
while (IS_WHITESPACE_CHAR(*pzValue) && (dataLen > 0)) {
dataLen--; pzValue++;
}
if (dataLen == 0)
pNV->v.longVal = 0;
else
pNV->v.longVal = strtol(pzValue, 0, 0);
pNV->valType = OPARG_TYPE_NUMERIC;
pNV->pzName = (char*)(pNV + 1);
memcpy( pNV->pzName, pzName, nameLen );
pNV->pzName[ nameLen ] = NUL;
addArgListEntry( pp, pNV );
return pNV;
}
/*=export_func optionTimeDate
* private:
*
* what: process an option with a time and date.
* arg: + tOptions* + pOpts + program options descriptor +
* arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
*
* doc:
* Decipher a time and date value.
=*/
void
optionTimeDate(tOptions * pOpts, tOptDesc * pOD)
{
#if defined(HAVE_GETDATE_R) && defined(HAVE_PUTENV)
if ((! HAS_pzPkgDataDir(pOpts)) || (pOpts->pzPkgDataDir == NULL))
goto default_action;
/*
* Export the DATEMSK environment variable. getdate_r() uses it to
* find the file with the strptime formats. If we cannot find the file
* we need ($PKGDATADIR/datemsk), then fall back to just a time duration.
*/
{
static char * envptr = NULL;
if (envptr == NULL) {
static char const fmt[] = "DATEMSK=%s/datemsk";
envptr = AGALOC(sizeof(fmt) + strlen(pOpts->pzPkgDataDir), fmt);
sprintf(envptr, fmt, pOpts->pzPkgDataDir);
putenv(envptr);
}
if (access(envptr+8, R_OK) != 0)
goto default_action;
}
/*
* Convert the date to a time since the epoch and stash it in a long int.
*/
{
struct tm stm;
time_t tm;
if (getdate_r(pOD->optArg.argString, &stm) != 0) {
fprintf(stderr, zNotDate, pOpts->pzProgName,
pOD->optArg.argString);
if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
(*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
return;
}
tm = mktime(&stm);
if (pOD->fOptState & OPTST_ALLOC_ARG) {
AGFREE(pOD->optArg.argString);
pOD->fOptState &= ~OPTST_ALLOC_ARG;
}
pOD->optArg.argInt = tm;
}
return;
default_action:
#endif
optionTimeVal(pOpts, pOD);
if (pOD->optArg.argInt != BAD_TIME)
pOD->optArg.argInt += (unsigned long)time(NULL);
}
/*=gfunc string_eqv_match_p
*
* what: caseless regex match
* general_use:
*
* exparg: text, text to test for pattern
* exparg: match, pattern/substring to search for
*
* string: "~"
*
* doc: Test to see if a string fully matches a pattern.
* Case is not significant, but any character equivalences
* must be expressed in your regular expression.
=*/
static tSuccess
Select_Match_Full(char const * sample, char const * pattern)
{
regmatch_t m[2];
/*
* On the first call for this macro, compile the expression
*/
if (pCurMacro->funcPrivate == NULL) {
void * mat = (void *)pattern;
regex_t* pRe = AGALOC(sizeof(*pRe), "select match full re");
if (OPT_VALUE_TRACE > TRACE_EXPRESSIONS) {
fprintf(pfTrace, "Compiling ``%s'' with bits 0x%lX\n",
pattern, pCurMacro->res);
}
compile_re(pRe, mat, (int)pCurMacro->res);
pCurMacro->funcPrivate = pRe;
}
if (regexec((regex_t*)pCurMacro->funcPrivate, sample, (size_t)2, m, 0)
!= 0)
return FAILURE;
if ( (m[0].rm_eo != strlen( sample ))
|| (m[0].rm_so != 0))
return FAILURE;
return SUCCESS;
}
/**
* make a name resilient to machinations made by 'make'.
* Basically, dollar sign characters are doubled.
*
* @param str the input string
* @returns a newly allocated string with the '$' characters doubled
*/
static char const *
make_quote_str(char const * str)
{
size_t sz = strlen(str) + 1;
char const * scan = str;
char * res;
for (;;) {
char * p = strchr(scan, '$');
if (p == NULL)
break;
sz++;
scan = scan + 1;
}
res = AGALOC(sz, "q name");
scan = res;
for (;;) {
char * p = strchr(str, '$');
if (p == NULL)
break;
sz = (size_t)(p - str) + 1;
memcpy(res, str, sz);
res += sz;
str += sz;
*(res++) = '$';
}
strcpy(res, str);
return scan;
}
static FILE *
open_tmp_usage(char ** buf)
{
char * bf;
size_t bfsz;
{
unsigned int my_pid = (unsigned int)getpid();
char const * tmpdir = getenv(TMPDIR);
if (tmpdir == NULL)
tmpdir = tmp_dir;
bfsz = TMP_FILE_FMT_LEN + strlen(tmpdir) + 10;
bf = AGALOC(bfsz, "tmp fil");
snprintf(bf, bfsz, TMP_FILE_FMT, tmpdir, my_pid);
}
{
static mode_t const cmask = S_IRWXO | S_IRWXG;
mode_t svmsk = umask(cmask);
int fd = mkstemp(bf);
(void)umask(svmsk);
if (fd < 0) {
AGFREE(bf);
return NULL;
}
*buf = bf;
return fdopen(fd, "w");
}
}
static char *
mk_pager_cmd(char const * fname)
{
/*
* Page the file and remove it when done. For shell script processing,
* we must redirect the output to the current stderr, otherwise stdout.
*/
fclose(option_usage_fp);
option_usage_fp = NULL;
{
char const * pager = (char const *)getenv(PAGER_NAME);
size_t bfsz;
char * res;
/*
* Use the "more(1)" program if "PAGER" has not been defined
*/
if (pager == NULL)
pager = MORE_STR;
bfsz = strlen(fname) + strlen(pager) + PAGE_USAGE_FMT_LEN;
res = AGALOC(bfsz, "more cmd");
snprintf(res, bfsz, PAGE_USAGE_FMT, pager, fname);
AGFREE((void*)(intptr_t)fname);
return res;
}
}
/* addBoolValue
*
* Associate a name with either a string or no value.
*/
static tOptionValue*
addBoolValue( void** pp, char const* pzName, size_t nameLen,
char const* pzValue, size_t dataLen )
{
tOptionValue* pNV;
size_t sz = nameLen + sizeof(*pNV) + 1;
pNV = AGALOC( sz, "option name/bool value pair" );
if (pNV == NULL)
return NULL;
while (IS_WHITESPACE_CHAR(*pzValue) && (dataLen > 0)) {
dataLen--; pzValue++;
}
if (dataLen == 0)
pNV->v.boolVal = 0;
else if (IS_DEC_DIGIT_CHAR(*pzValue))
pNV->v.boolVal = atoi(pzValue);
else pNV->v.boolVal = ! IS_FALSE_TYPE_CHAR(*pzValue);
pNV->valType = OPARG_TYPE_BOOLEAN;
pNV->pzName = (char*)(pNV + 1);
memcpy( pNV->pzName, pzName, nameLen );
pNV->pzName[ nameLen ] = NUL;
addArgListEntry( pp, pNV );
return pNV;
}
/**
* Associate a name with a boolean value
*
* @param[in,out] pp argument list to add to
* @param[in] name the name of the "suboption"
* @param[in] nm_len the length of the name
* @param[in] val the boolean value for the suboption
* @param[in] d_len the length of the value
*
* @returns the new value structure
*/
static tOptionValue *
add_bool(void ** pp, char const * name, size_t nm_len,
char const * val, size_t d_len)
{
size_t sz = nm_len + sizeof(tOptionValue) + 1;
tOptionValue * new_val = AGALOC(sz, "bool val");
/*
* Scan over whitespace is constrained by "d_len"
*/
while (IS_WHITESPACE_CHAR(*val) && (d_len > 0)) {
d_len--; val++;
}
if (d_len == 0)
new_val->v.boolVal = 0;
else if (IS_DEC_DIGIT_CHAR(*val))
new_val->v.boolVal = (unsigned)atoi(val);
else new_val->v.boolVal = ! IS_FALSE_TYPE_CHAR(*val);
new_val->valType = OPARG_TYPE_BOOLEAN;
new_val->pzName = (char *)(new_val + 1);
memcpy(new_val->pzName, name, nm_len);
new_val->pzName[ nm_len ] = NUL;
addArgListEntry(pp, new_val);
return new_val;
}
static SCM
shell_stringify(SCM obj, uint_t qt)
{
char * pzNew;
size_t dtaSize = 3;
char * pzDta = ag_scm2zchars(obj, "AG Object");
char * pz = pzDta;
for (;;) {
char c = *(pz++);
switch (c) {
case NUL:
goto loopDone1;
case '"': case '`': case '\\':
dtaSize += 2;
break;
default:
dtaSize++;
}
} loopDone1:;
pzNew = AGALOC(dtaSize, "shell string");
dtaSize = stringify_for_sh(pzNew, qt, pzDta);
{
SCM res = AG_SCM_STR2SCM(pzNew, dtaSize);
AGFREE(pzNew);
return res;
}
}
/**
* Print the bits set in a bit mask option.
* We call the option handling function with a magic value for
* the options pointer and it allocates and fills in the string.
* We print that with a call to prt_entry().
*
* @param[in] fp the file pointer to write to
* @param[in] od the option descriptor with a bit mask value type
*/
static void
prt_set_arg(FILE * fp, tOptDesc * od)
{
char * list = optionMemberList(od);
size_t len = strlen(list);
char * buf = (char *)AGALOC(len + 3, "dir name");
*buf= '=';
memcpy(buf+1, list, len + 1);
prt_entry(fp, od, buf);
AGFREE(buf);
AGFREE(list);
}
/**
* Make sure the directory containing the subject file exists and that
* the file exists or does not exist, per the option requirements.
*
* @param ftype file existence type flags
* @param pOpts program option descriptor
* @param pOD the option descriptor
*/
static void
check_existence(teOptFileType ftype, tOptions * pOpts, tOptDesc * pOD)
{
char const * fname = pOD->optArg.argString;
struct stat sb;
errno = 0;
switch (ftype & FTYPE_MODE_EXIST_MASK) {
case FTYPE_MODE_MUST_NOT_EXIST:
if ((stat(fname, &sb) == 0) || (errno != ENOENT)) {
if (errno == 0)
errno = EINVAL;
fserr_exit(pOpts->pzProgName, "stat", fname);
/* NOTREACHED */
}
/* FALLTHROUGH */
default:
case FTYPE_MODE_MAY_EXIST:
{
char * p = strrchr(fname, DIRCH);
size_t l;
if (p == NULL)
/*
* The file may or may not exist and its directory is ".".
* Assume that "." exists.
*/
break;
l = (size_t)(p - fname);
p = AGALOC(l + 1, "fname");
memcpy(p, fname, l);
p[l] = NUL;
if ((stat(p, &sb) != 0) || (errno = EINVAL, ! S_ISDIR(sb.st_mode)))
fserr_exit(pOpts->pzProgName, "stat", p);
/* NOTREACHED */
AGFREE(p);
break;
}
case FTYPE_MODE_MUST_EXIST:
if ( (stat(fname, &sb) != 0)
|| (errno = EINVAL, ! S_ISREG(sb.st_mode)) )
fserr_exit(pOpts->pzProgName, "stat", fname);
/* NOTREACHED */
break;
}
}
static char *
strdup( char const *s )
{
char *cp;
if (s == NULL)
return NULL;
cp = (char *) AGALOC((unsigned) (strlen(s)+1), "strdup");
if (cp != NULL)
(void) strcpy(cp, s);
return cp;
}
/**
* Load the previous shell script output file. We need to preserve any
* hand-edited additions outside of the START_MARK and END_MARKs.
*
* @param[in] fname the output file name
*/
static char *
load_old_output(char const * fname)
{
/*
* IF we cannot stat the file,
* THEN assume we are creating a new file.
* Skip the loading of the old data.
*/
FILE * fp = fopen(fname, "r" FOPEN_BINARY_FLAG);
struct stat stbf;
char * text;
char * scan;
if (fp == NULL)
return NULL;
/*
* If we opened it, we should be able to stat it and it needs
* to be a regular file
*/
if ((fstat(fileno(fp), &stbf) != 0) || (! S_ISREG(stbf.st_mode))) {
fprintf(stderr, zNotFile, fname);
exit(EXIT_FAILURE);
}
scan = text = AGALOC(stbf.st_size + 1, "f data");
/*
* Read in all the data as fast as our OS will let us.
*/
for (;;) {
int inct = fread((void*)scan, (size_t)1, stbf.st_size, fp);
if (inct == 0)
break;
stbf.st_size -= inct;
if (stbf.st_size == 0)
break;
scan += inct;
}
*scan = NUL;
fclose(fp);
return text;
}
static void
set_memb_names(tOptions * opts, tOptDesc * od, char const * const * nm_list,
unsigned int nm_ct)
{
char * pz;
uintptr_t mask = (1UL << (uintptr_t)nm_ct) - 1UL;
uintptr_t bits = (uintptr_t)od->optCookie & mask;
unsigned int ix = 0;
size_t len = 1;
/*
* Replace the enumeration value with the name string.
* First, determine the needed length, then allocate and fill in.
*/
while (bits != 0) {
if (bits & 1)
len += strlen(nm_list[ix]) + PLUS_STR_LEN + 1;
if (++ix >= nm_ct) break;
bits >>= 1;
}
od->optArg.argString = pz = AGALOC(len, "enum");
bits = (uintptr_t)od->optCookie & mask;
if (bits == 0) {
*pz = NUL;
return;
}
for (ix = 0; ; ix++) {
size_t nln;
int doit = bits & 1;
bits >>= 1;
if (doit == 0)
continue;
nln = strlen(nm_list[ix]);
memcpy(pz, nm_list[ix], nln);
pz += nln;
if (bits == 0)
break;
memcpy(pz, PLUS_STR, PLUS_STR_LEN);
pz += PLUS_STR_LEN;
}
*pz = NUL;
(void)opts;
}
/*=export_func optionSaveState
*
* what: saves the option state to memory
* arg: tOptions*, pOpts, program options descriptor
*
* doc:
*
* This routine will allocate enough memory to save the current option
* processing state. If this routine has been called before, that memory
* will be reused. You may only save one copy of the option state. This
* routine may be called before optionProcess(3AO). If you do call it
* before the first call to optionProcess, then you may also change the
* contents of argc/argv after you call optionRestore(3AO)
*
* In fact, more strongly put: it is safest to only use this function
* before having processed any options. In particular, the saving and
* restoring of stacked string arguments and hierarchical values is
* disabled. The values are not saved.
*
* err: If it fails to allocate the memory,
* it will print a message to stderr and exit.
* Otherwise, it will always succeed.
=*/
void
optionSaveState(tOptions * pOpts)
{
tOptions * p = (tOptions*)pOpts->pSavedState;
if (p == NULL) {
size_t sz = sizeof(*pOpts)
+ ((size_t)pOpts->optCt * sizeof(tOptDesc));
p = AGALOC(sz, "saved option state");
pOpts->pSavedState = p;
}
memcpy(p, pOpts, sizeof(*p));
memcpy(p + 1, pOpts->pOptDesc, (size_t)p->optCt * sizeof(tOptDesc));
fixupSavedOptionArgs(pOpts);
}
/*=gfunc string_has_eqv_match_p
*
* what: caseless regex contains
* general_use:
*
* exparg: text, text to test for pattern
* exparg: match, pattern/substring to search for
*
* string: "*~*"
*
* doc: Test to see if a string contains a pattern.
* Case is not significant.
=*/
static tSuccess
Select_Match(char const * sample, char const * pattern)
{
/*
* On the first call for this macro, compile the expression
*/
if (pCurMacro->funcPrivate == NULL) {
void * mat = (void *)pattern;
regex_t* pRe = AGALOC(sizeof(*pRe), "select match re");
compile_re(pRe, mat, (int)pCurMacro->res);
pCurMacro->funcPrivate = (void*)pRe;
}
if (regexec((regex_t*)pCurMacro->funcPrivate, sample, (size_t)0,
NULL, 0) != 0)
return FAILURE;
return SUCCESS;
}
LOCAL tDefEntry*
getEntry(void)
{
tDefEntry* pRes = pFreeEntryList;
if (pRes != NULL) {
pFreeEntryList = pRes->pNext;
} else {
int ct = ENTRY_ALLOC_CT-1;
void* p = AGALOC(ENTRY_ALLOC_SIZE, "definition headers");
manageAllocatedData(p);
*((void**)p) = pAllocList;
pAllocList = p;
pRes = pFreeEntryList = (tDefEntry*)((void**)p + 1);
/*
* This is a post-loop test loop. It will cycle one fewer times
* than there are 'tDefEntry' structs in the memory we just alloced.
*/
do {
tDefEntry* pNxt = pRes+1;
pRes->pNext = pNxt;
/*
* When the loop ends, "pRes" will point to the last allocated
* structure instance. That is the one we will return.
*/
pRes = pNxt;
} while (--ct > 0);
/*
* Unlink the last entry from the chain. The next time this
* routine is called, the *FIRST* structure in this list will
* be returned.
*/
pRes[-1].pNext = NULL;
}
memset((void*)pRes, 0, sizeof(*pRes));
return pRes;
}
/**
* Process the stuff in the pseudo macro.
*/
static tTemplate *
digest_pseudo_macro(tmap_info_t * minfo, char * real_file)
{
tTemplate * pRes;
/*
* Count the number of macros in the template. Compute
* the output data size as a function of the number of macros
* and the size of the template data. These may get reduced
* by comments.
*/
char const * pzData =
loadPseudoMacro((char const *)minfo->txt_data, real_file);
size_t macroCt = cnt_macros(pzData);
size_t alocSize = (sizeof(*pRes) + (macroCt * sizeof(tMacro))
+ minfo->txt_size
- (pzData - (char const *)minfo->txt_data)
+ strlen(real_file) + 0x10) & ~0x0F;
pRes = (tTemplate*)AGALOC(alocSize, "main template");
memset((void*)pRes, 0, alocSize);
/*
* Initialize the values:
*/
pRes->magic = magicMark;
pRes->descSize = alocSize;
pRes->macroCt = macroCt;
strcpy(pRes->zStartMac, zStartMac); /* must fit */
strcpy(pRes->zEndMac, zEndMac); /* must fit */
load_macs(pRes, real_file, "*template file*", pzData);
pRes->pzTplName -= (long)pRes;
pRes->pzTemplText -= (long)pRes;
pRes = (tTemplate*)AGREALOC((void*)pRes, pRes->descSize,
"resize template");
pRes->pzTplName += (long)pRes;
pRes->pzTemplText += (long)pRes;
return pRes;
}
/* addStringValue
*
* Associate a name with either a string or no value.
*/
static tOptionValue*
addStringValue( void** pp, char const* pzName, size_t nameLen,
char const* pzValue, size_t dataLen )
{
tOptionValue* pNV;
size_t sz = nameLen + dataLen + sizeof(*pNV);
pNV = AGALOC( sz, "option name/str value pair" );
if (pNV == NULL)
return NULL;
if (pzValue == NULL) {
pNV->valType = OPARG_TYPE_NONE;
pNV->pzName = pNV->v.strVal;
} else {
pNV->valType = OPARG_TYPE_STRING;
if (dataLen > 0) {
char const * pzSrc = pzValue;
char * pzDst = pNV->v.strVal;
int ct = dataLen;
do {
int ch = *(pzSrc++) & 0xFF;
if (ch == NUL) goto data_copy_done;
if (ch == '&')
ch = get_special_char(&pzSrc, &ct);
*(pzDst++) = ch;
} while (--ct > 0);
data_copy_done:
*pzDst = NUL;
} else {
pNV->v.strVal[0] = NUL;
}
pNV->pzName = pNV->v.strVal + dataLen + 1;
}
memcpy( pNV->pzName, pzName, nameLen );
pNV->pzName[ nameLen ] = NUL;
addArgListEntry( pp, pNV );
return pNV;
}
/*
* Put an entry into an argument list. The first argument points to
* a pointer to the argument list structure. It gets passed around
* as an opaque address.
*/
LOCAL void
addArgListEntry(void ** ppAL, void * entry)
{
tArgList* pAL = *(void**)ppAL;
/*
* IF we have never allocated one of these,
* THEN allocate one now
*/
if (pAL == NULL) {
pAL = (tArgList*)AGALOC(sizeof(*pAL), "new option arg stack");
if (pAL == NULL)
return;
pAL->useCt = 0;
pAL->allocCt = MIN_ARG_ALLOC_CT;
*ppAL = (void*)pAL;
}
/*
* ELSE if we are out of room
* THEN make it bigger
*/
else if (pAL->useCt >= pAL->allocCt) {
size_t sz = sizeof(*pAL);
pAL->allocCt += INCR_ARG_ALLOC_CT;
/*
* The base structure contains space for MIN_ARG_ALLOC_CT
* pointers. We subtract it off to find our augment size.
*/
sz += sizeof(char*) * ((size_t)pAL->allocCt - MIN_ARG_ALLOC_CT);
pAL = (tArgList*)AGREALOC((void*)pAL, sz, "expanded opt arg stack");
if (pAL == NULL)
return;
*ppAL = (void*)pAL;
}
/*
* Insert the new argument into the list
*/
pAL->apzArgs[ (pAL->useCt)++ ] = entry;
}
/**
* Associate a name with either a string or no value.
*
* @param[in,out] pp argument list to add to
* @param[in] name the name of the "suboption"
* @param[in] nm_len the length of the name
* @param[in] val the string value for the suboption
* @param[in] d_len the length of the value
*
* @returns the new value structure
*/
static tOptionValue *
add_string(void ** pp, char const * name, size_t nm_len,
char const * val, size_t d_len)
{
tOptionValue * pNV;
size_t sz = nm_len + d_len + sizeof(*pNV);
pNV = AGALOC(sz, "option name/str value pair");
if (val == NULL) {
pNV->valType = OPARG_TYPE_NONE;
pNV->pzName = pNV->v.strVal;
} else {
pNV->valType = OPARG_TYPE_STRING;
if (d_len > 0) {
char const * src = val;
char * pzDst = pNV->v.strVal;
int ct = (int)d_len;
do {
int ch = *(src++) & 0xFF;
if (ch == NUL) goto data_copy_done;
if (ch == '&')
ch = get_special_char(&src, &ct);
*(pzDst++) = (char)ch;
} while (--ct > 0);
data_copy_done:
*pzDst = NUL;
} else {
pNV->v.strVal[0] = NUL;
}
pNV->pzName = pNV->v.strVal + d_len + 1;
}
memcpy(pNV->pzName, name, nm_len);
pNV->pzName[ nm_len ] = NUL;
addArgListEntry(pp, pNV);
return pNV;
}
/*=gfunc string_end_eqv_match_p
*
* what: caseless regex ending
* general_use:
*
* exparg: text, text to test for pattern
* exparg: match, pattern/substring to search for
*
* string: "*~"
*
* doc: Test to see if a string ends with a pattern.
* Case is not significant.
=*/
static tSuccess
Select_Match_End(char const * sample, char const * pattern)
{
regmatch_t m[2];
/*
* On the first call for this macro, compile the expression
*/
if (pCurMacro->funcPrivate == NULL) {
void * mat = (void *)pattern;
regex_t* pRe = AGALOC(sizeof(*pRe), "select match end re");
compile_re(pRe, mat, (int)pCurMacro->res);
pCurMacro->funcPrivate = (void*)pRe;
}
if (regexec((regex_t*)pCurMacro->funcPrivate, sample, (size_t)2, m, 0)
!= 0)
return FAILURE;
if (m[0].rm_eo != strlen(sample))
return FAILURE;
return SUCCESS;
}
/**
* handle AutoOpts mode flags
*/
static char *
aoflags_directive(tOptions * pOpts, char * pzText)
{
char * pz = pzText;
while (IS_WHITESPACE_CHAR(*++pz)) ;
pzText = strchr(pz, '>');
if (pzText != NULL) {
size_t len = pzText - pz;
char * ftxt = AGALOC(len + 1, "aoflags");
memcpy(ftxt, pz, len);
ftxt[len] = NUL;
set_usage_flags(pOpts, ftxt);
AGFREE(ftxt);
pzText++;
}
return pzText;
}
/**
* handle AutoOpts mode flags.
*
* @param[in,out] opts program option descriptor
* @param[in] txt scanning pointer
* @returns the next character to look at
*/
static char *
aoflags_directive(tOptions * opts, char * txt)
{
char * pz;
pz = SPN_WHITESPACE_CHARS(txt+1);
txt = strchr(pz, '>');
if (txt != NULL) {
size_t len = (unsigned)(txt - pz);
char * ftxt = AGALOC(len + 1, "aoflags");
memcpy(ftxt, pz, len);
ftxt[len] = NUL;
set_usage_flags(opts, ftxt);
AGFREE(ftxt);
txt++;
}
return txt;
}
/**
* handle program segmentation of config file.
*
* @param[in,out] opts program option descriptor
* @param[in] txt scanning pointer
* @returns the next character to look at
*/
static char *
program_directive(tOptions * opts, char * txt)
{
static char const ttlfmt[] = "<?";
size_t ttl_len = sizeof(ttlfmt) + strlen(zCfgProg);
char * ttl = AGALOC(ttl_len, "prog title");
size_t name_len = strlen(opts->pzProgName);
memcpy(ttl, ttlfmt, sizeof(ttlfmt) - 1);
memcpy(ttl + sizeof(ttlfmt) - 1, zCfgProg, ttl_len - (sizeof(ttlfmt) - 1));
do {
txt = SPN_WHITESPACE_CHARS(txt+1);
if ( (strneqvcmp(txt, opts->pzProgName, (int)name_len) == 0)
&& (IS_END_XML_TOKEN_CHAR(txt[name_len])) ) {
txt += name_len;
break;
}
txt = strstr(txt, ttl);
} while (txt != NULL);
AGFREE(ttl);
if (txt != NULL)
for (;;) {
if (*txt == NUL) {
txt = NULL;
break;
}
if (*(txt++) == '>')
break;
}
return txt;
}
