/* * $Id: f0ececd5fec43bacb417d7b50294accc2121923f $ * Time-stamp: "2008-12-06 10:16:05 bkorb" * * 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. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. * AutoOpts is copyright (c) 1992-2009 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 md5sums: * * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3 * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3 * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd */ tOptionLoadMode option_load_mode = OPTION_LOAD_UNCOOKED; /* = = = START-STATIC-FORWARD = = = */ /* static forward declarations maintained by mk-fwd */ static ag_bool insertProgramPath( char* pzBuf, int bufSize, tCC* pzName, tCC* pzProgPath ); static ag_bool insertEnvVal( char* pzBuf, int bufSize, tCC* pzName, tCC* pzProgPath ); static char* assembleArgValue( char* pzTxt, tOptionLoadMode mode ); /* = = = END-STATIC-FORWARD = = = */ /*=export_func optionMakePath * private: * * what: translate and construct a path * arg: + char* + pzBuf + The result buffer + * arg: + int + bufSize + The size of this buffer + * arg: + char const* + pzName + The input name + * arg: + char const* + pzProgPath + The full path of the current program + * * ret-type: ag_bool * ret-desc: AG_TRUE if the name was handled, otherwise AG_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, carefully 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{AG_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). =*/ ag_bool optionMakePath( char* pzBuf, int bufSize, tCC* pzName, tCC* pzProgPath ) { size_t name_len = strlen( pzName ); # ifndef PKGDATADIR # define PKGDATADIR "" # endif tSCC pkgdatadir[] = PKGDATADIR; ag_bool res = AG_TRUE; if (bufSize <= name_len) return AG_FALSE; /* * IF not an environment variable, just copy the data */ if (*pzName != '$') { tCC* pzS = pzName; char* pzD = pzBuf; int ct = bufSize; for (;;) { if ( (*(pzD++) = *(pzS++)) == NUL) break; if (--ct <= 0) return AG_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 (pzName[1]) { case NUL: return AG_FALSE; case '$': res = insertProgramPath( pzBuf, bufSize, pzName, pzProgPath ); break; case '@': if (pkgdatadir[0] == NUL) return AG_FALSE; if (name_len + sizeof (pkgdatadir) > bufSize) return AG_FALSE; strcpy(pzBuf, pkgdatadir); strcpy(pzBuf + sizeof(pkgdatadir) - 1, pzName + 2); break; default: res = insertEnvVal( pzBuf, bufSize, pzName, pzProgPath ); } if (! res) return AG_FALSE; #if defined(HAVE_CANONICALIZE_FILE_NAME) { char* pz = canonicalize_file_name(pzBuf); if (pz == NULL) return AG_FALSE; if (strlen(pz) < bufSize) strcpy(pzBuf, pz); free(pz); } #elif defined(HAVE_REALPATH) { char z[ PATH_MAX+1 ]; if (realpath( pzBuf, z ) == NULL) return AG_FALSE; if (strlen(z) < bufSize) strcpy( pzBuf, z ); } #endif return AG_TRUE; } static ag_bool insertProgramPath( char* pzBuf, int bufSize, tCC* pzName, tCC* pzProgPath ) { tCC* pzPath; tCC* pz; int skip = 2; switch (pzName[2]) { case DIRCH: skip = 3; case NUL: break; default: return AG_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( pzProgPath, DIRCH ) != NULL) pzPath = pzProgPath; else { pzPath = pathfind( getenv( "PATH" ), (char*)pzProgPath, "rx" ); if (pzPath == NULL) return AG_FALSE; } pz = strrchr( pzPath, 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 AG_FALSE; pzName += skip; /* * Concatenate the file name to the end of the executable path. * The result may be either a file or a directory. */ if ((pz - pzPath)+1 + strlen(pzName) >= bufSize) return AG_FALSE; memcpy( pzBuf, pzPath, (size_t)((pz - pzPath)+1) ); strcpy( pzBuf + (pz - pzPath) + 1, pzName ); /* * If the "pzPath" path was gotten from "pathfind()", then it was * allocated and we need to deallocate it. */ if (pzPath != pzProgPath) AGFREE(pzPath); return AG_TRUE; } static ag_bool insertEnvVal( char* pzBuf, int bufSize, tCC* pzName, tCC* pzProgPath ) { char* pzDir = pzBuf; for (;;) { int ch = (int)*++pzName; if (! IS_VALUE_NAME_CHAR(ch)) break; *(pzDir++) = (char)ch; } if (pzDir == pzBuf) return AG_FALSE; *pzDir = NUL; pzDir = getenv( pzBuf ); /* * Environment value not found -- skip the home list entry */ if (pzDir == NULL) return AG_FALSE; if (strlen( pzDir ) + 1 + strlen( pzName ) >= bufSize) return AG_FALSE; sprintf( pzBuf, "%s%s", pzDir, pzName ); return AG_TRUE; } LOCAL void mungeString( char* pzTxt, tOptionLoadMode mode ) { char* pzE; if (mode == OPTION_LOAD_KEEP) return; if (IS_WHITESPACE_CHAR(*pzTxt)) { char* pzS = pzTxt; char* pzD = pzTxt; while (IS_WHITESPACE_CHAR(*++pzS)) ; while ((*(pzD++) = *(pzS++)) != NUL) ; pzE = pzD-1; } else pzE = pzTxt + strlen( pzTxt ); while ((pzE > pzTxt) && IS_WHITESPACE_CHAR(pzE[-1])) pzE--; *pzE = NUL; if (mode == OPTION_LOAD_UNCOOKED) return; switch (*pzTxt) { default: return; case '"': case '\'': break; } switch (pzE[-1]) { default: return; case '"': case '\'': break; } (void)ao_string_cook( pzTxt, NULL ); } static char* assembleArgValue( char* pzTxt, tOptionLoadMode mode ) { tSCC zBrk[] = " \t\n:="; char* pzEnd = strpbrk( pzTxt, zBrk ); int space_break; /* * Not having an argument to a configurable name is okay. */ if (pzEnd == NULL) return pzTxt + strlen(pzTxt); /* * 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) { *(pzEnd++) = NUL; return pzEnd; } /* * 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(*pzEnd); *(pzEnd++) = NUL; while (IS_WHITESPACE_CHAR(*pzEnd)) pzEnd++; if (space_break && ((*pzEnd == ':') || (*pzEnd == '='))) while (IS_WHITESPACE_CHAR(*++pzEnd)) ; return pzEnd; } /* * 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. */ LOCAL void loadOptionLine( tOptions* pOpts, tOptState* pOS, char* pzLine, tDirection direction, tOptionLoadMode load_mode ) { while (IS_WHITESPACE_CHAR(*pzLine)) pzLine++; { char* pzArg = assembleArgValue( pzLine, load_mode ); if (! SUCCESSFUL( longOptionFind( pOpts, pzLine, pOS ))) return; if (pOS->flags & OPTST_NO_INIT) return; pOS->pzOptArg = pzArg; } switch (pOS->flags & (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(direction)) return; break; case OPTST_IMM: if (PRESETTING(direction)) { /* * We are in the presetting direction with an option we handle * immediately for enablement, but normally for disablement. * Therefore, skip if disabled. */ if ((pOS->flags & OPTST_DISABLED) == 0) return; } 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 ((pOS->flags & OPTST_DISABLED) != 0) return; } break; case OPTST_DISABLE_IMM: if (PRESETTING(direction)) { /* * We are in the presetting direction with an option we handle * immediately for disablement, but normally for disablement. * Therefore, skip if NOT disabled. */ if ((pOS->flags & OPTST_DISABLED) != 0) return; } else { /* * We are in the processing direction with an option we handle * immediately for disablement, but normally for disablement. * Therefore, skip if disabled. */ if ((pOS->flags & OPTST_DISABLED) == 0) return; } 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(direction)) return; break; } /* * Fix up the args. */ if (OPTST_GET_ARGTYPE(pOS->pOD->fOptState) == OPARG_TYPE_NONE) { if (*pOS->pzOptArg != NUL) return; pOS->pzOptArg = NULL; } else if (pOS->pOD->fOptState & OPTST_ARG_OPTIONAL) { if (*pOS->pzOptArg == NUL) pOS->pzOptArg = NULL; else { AGDUPSTR( pOS->pzOptArg, pOS->pzOptArg, "option argument" ); pOS->flags |= OPTST_ALLOC_ARG; } } else { if (*pOS->pzOptArg == NUL) pOS->pzOptArg = zNil; else { AGDUPSTR( pOS->pzOptArg, pOS->pzOptArg, "option argument" ); pOS->flags |= OPTST_ALLOC_ARG; } } { tOptionLoadMode sv = option_load_mode; option_load_mode = load_mode; handleOption( pOpts, pOS ); option_load_mode = sv; } } /*=export_func optionLoadLine * * what: process a string for an option name and value * * arg: tOptions*, pOpts, program options descriptor * arg: char const*, pzLine, 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. 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* pOpts, tCC* pzLine ) { tOptState st = OPTSTATE_INITIALIZER(SET); char* pz; AGDUPSTR( pz, pzLine, "user option line" ); loadOptionLine( pOpts, &st, pz, DIRECTION_PROCESS, OPTION_LOAD_COOKED ); AGFREE( pz ); } /* * Local Variables: * mode: C * c-file-style: "stroustrup" * indent-tabs-mode: nil * End: * end of autoopts/load.c */