/*
* Figure out if we should try to format usage text sort-of like
* the way many GNU programs do.
*/
static ag_bool
checkGNUUsage( tOptions* pOpts )
{
char* pz = getenv( "AUTOOPTS_USAGE" );
if (pz == NULL)
;
else if (streqvcmp( pz, "gnu" ) == 0)
pOpts->fOptSet |= OPTPROC_GNUUSAGE;
else if (streqvcmp( pz, "autoopts" ) == 0)
pOpts->fOptSet &= ~OPTPROC_GNUUSAGE;
return (pOpts->fOptSet & OPTPROC_GNUUSAGE) ? AG_TRUE : AG_FALSE;
}
/**
* Return the template structure matching the name passed in.
*/
LOCAL tTemplate *
findTemplate(char const * pzTemplName)
{
tTemplate * pT = pNamedTplList;
while (pT != NULL) {
if (streqvcmp(pzTemplName, pT->pzTplName) == 0)
break;
pT = (tTemplate*)(void*)(pT->pNext);
}
return pT;
}
/*=gfunc string_ends_eqv_p
*
* what: caseless string 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 an equivalent string.
=*/
static tSuccess
Select_Equivalent_End(char const * sample, char const * pattern)
{
size_t vlen = strlen(pattern);
size_t tlen = strlen(sample);
if (tlen < vlen)
return FAILURE;
return (streqvcmp(sample + (tlen - vlen), pattern) == 0)
? SUCCESS
: FAILURE;
}
/*
* compar_text
*
* merely returns the relative ordering of two input strings.
* The arguments are pointers to pointers to NUL-terminated strings.
* IF the definiton was mal-formed, an error message was printed
* earlier. When we get here, we wil fail to find the "zNameTag"
* string and EXIT_FAILURE.
*/
static int
compar_text(const void* p1, const void* p2)
{
char* pz1 = strstr(*(char const * const *)p1, zNameTag);
char* pe1;
char* pz2 = strstr(*(char const * const *)p2, zNameTag);
char* pe2;
int res;
if (pz1 == NULL) {
if (strncmp(*(char const * const *)p1, zGlobal, sizeof(zGlobal)-1) == 0)
return -1;
die(zBogusDef, *(char const * const *)p1);
}
if (pz2 == NULL) {
if (strncmp(*(char const * const *)p2, zGlobal, sizeof(zGlobal)-1) == 0)
return 1;
die(zBogusDef, *(char const * const *)p2);
}
pz1 += sizeof(zNameTag)-1;
pe1 = strchr(pz1, '\'');
if (pe1 == NULL)
die(zBogusDef, *(char const * const *)p1);
pz2 += sizeof(zNameTag)-1;
pe2 = strchr(pz2, '\'');
if (pe2 == NULL)
die(zBogusDef, *(char const * const *)p2);
*pe1 = *pe2 = NUL;
/*
* We know ordering is enabled because we only get called when
* it is enabled. If the option was also specified, then
* we sort without case sensitivity (and we compare '-', '_'
* and '^' as being equal as well). Otherwise, we do a
* strict string comparison.
*/
if (HAVE_OPT(ORDERING))
res = streqvcmp(pz1, pz2);
else res = strcmp(pz1, pz2);
*pe1 = *pe2 = '\'';
return res;
}
SCM
ag_scm_string_eqv_p(SCM text, SCM substr)
{
char* pzText;
char* pzSubstr;
/*
* We are overloading the "=" operator. Our arguments may be
* numbers...
*/
if (! AG_SCM_STRING_P(text) || ! AG_SCM_STRING_P(substr))
return scm_num_eq_p(text, substr);
pzText = ag_scm2zchars(text, "text to match");
pzSubstr = ag_scm2zchars(substr, "match expr");
return (streqvcmp(pzText, pzSubstr) == 0) ? SCM_BOOL_T : SCM_BOOL_F;
}
/*=gfunc string_eqv_p
*
* what: caseless string match
* general_use:
*
* exparg: text, text to test for pattern
* exparg: match, pattern/substring to search for
*
* string: "="
*
* doc: Test to see if two strings are equivalent. `equivalent' means the
* strings match, but without regard to character case and certain
* characters are considered `equivalent'. Viz., '-', '_' and '^' are
* equivalent. If the arguments are not strings, then the result of the
* numeric comparison is returned.
*
* This is an overloaded operation. If the arguments are not both
* strings, then the query is passed through to @code{scm_num_eq_p()}.
=*/
static tSuccess
Select_Equivalent_Full(char const * sample, char const * pattern)
{
return (streqvcmp(sample, pattern) == 0) ? SUCCESS : FAILURE;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* It may be a number, a name, a keyword or garbage.
* Figure out which.
*/
static char*
assembleName(char * pzScan, te_dp_event * pRetVal)
{
/*
* Check for a number.
* Scan it in and advance "pzScan".
*/
if ( IS_DEC_DIGIT_CHAR(*pzScan)
|| ( (*pzScan == '-')
&& IS_DEC_DIGIT_CHAR(pzScan[1])
) ) {
pz_token = pzScan;
(void)strtol(pzScan, &pzScan, 0);
*pRetVal = DP_EV_NUMBER;
return pzScan;
}
if (! IS_UNQUOTABLE_CHAR(*pzScan))
AG_ABEND(aprf("%s Error: Invalid input char '%c' in %s on line %d\n",
pzProg, *pzScan, pCurCtx->pzCtxFname, pCurCtx->lineNo));
{
unsigned char* pz = (unsigned char*)pzScan;
while (IS_VALUE_NAME_CHAR(*pz)) pz++;
if (IS_UNQUOTABLE_CHAR(*pz)) {
*pRetVal = DP_EV_OTHER_NAME;
while (IS_UNQUOTABLE_CHAR(*++pz)) ;
} else
*pRetVal = DP_EV_VAR_NAME;
/*
* Return a NAME token, maybe.
* If the name is actually a keyword,
* we will return that token code instead.
*/
pz_token = pzScan;
pzScan = (char*)pz;
}
/*
* Now scan the keyword table.
*/
if (*pRetVal == DP_EV_VAR_NAME) {
char sv_ch = *pzScan; /* preserve the following character */
int kw_ix = 0;
*pzScan = NUL; /* NUL terminate the name */
do {
if (streqvcmp(apzKeywords[ kw_ix ], (char*)pz_token) == 0) {
/*
* Return the keyword token code instead of DP_EV_NAME
*/
*pRetVal = aKeywordTkn[ kw_ix ];
break;
}
} while (++kw_ix < KEYWORD_CT);
*pzScan = sv_ch; /* restore the following character */
}
return pzScan;
}
static void
do_env_opt(tOptState * os, char * env_name,
tOptions * pOpts, teEnvPresetType type)
{
os->pzOptArg = getenv(env_name);
if (os->pzOptArg == NULL)
return;
os->flags = OPTST_PRESET | OPTST_ALLOC_ARG | os->pOD->fOptState;
os->optType = TOPT_UNDEFINED;
if ( (os->pOD->pz_DisablePfx != NULL)
&& (streqvcmp(os->pzOptArg, os->pOD->pz_DisablePfx) == 0)) {
os->flags |= OPTST_DISABLED;
os->pzOptArg = NULL;
}
switch (type) {
case ENV_IMM:
/*
* Process only immediate actions
*/
if (DO_IMMEDIATELY(os->flags))
break;
return;
case ENV_NON_IMM:
/*
* Process only NON immediate actions
*/
if (DO_NORMALLY(os->flags) || DO_SECOND_TIME(os->flags))
break;
return;
default: /* process everything */
break;
}
/*
* Make sure the option value string is persistent and consistent.
*
* The interpretation of the option value depends
* on the type of value argument the option takes
*/
if (OPTST_GET_ARGTYPE(os->pOD->fOptState) == OPARG_TYPE_NONE) {
/*
* Ignore any value.
*/
os->pzOptArg = NULL;
} else if (os->pzOptArg[0] == NUL) {
/*
* If the argument is the empty string and the argument is
* optional, then treat it as if the option was not specified.
*/
if ((os->pOD->fOptState & OPTST_ARG_OPTIONAL) == 0)
return;
os->pzOptArg = NULL;
} else {
AGDUPSTR(os->pzOptArg, os->pzOptArg, "option argument");
os->flags |= OPTST_ALLOC_ARG;
}
handle_opt(pOpts, os);
}