options.c

VIM文本编辑器

    else
    {
	equivalent = TRUE;
	do
	{
	    if (toupper(*s1) != toupper(*s2))
	    {
		equivalent = FALSE;
		break;
	    }
	} while (*s1++ != '\0'  &&  *s2++ != '\0');
    }
    return equivalent;
}

static langType getLangType( name )
    const char *const name;
{
    unsigned int i;
    langType language = LANG_IGNORE;

    for (i = 0  ;  i < LANG_COUNT  ;  ++i)
    {
         if (strequiv(name, getLanguageName((langType)i)))
	 {
	    language = (langType)i;
	    break;
	 }
    }
    return language;
}

static void processLangOption( optionName, parameter )
    const char *const optionName;
    const char *const parameter;
{
    const langType language = getLangType(parameter);

    if (language == LANG_IGNORE)
	error(FATAL, "Invalid value for option --%s", optionName);
    else
	Option.language = language;
}

static void installLangMap( map )
    char *const map;
{
    char *const separator = strchr(map, ':');

    if (separator != NULL)
    {
	langType language;

	*separator = '\0';
	language = getLangType(map);
	if (language == LANG_IGNORE)
	    error(FATAL, "Invalid language specified for option --langmap");
	DebugStatement( if (debug(DEBUG_STATUS))
			    printf("%s map:\n", map); )
	Option.langMap[(int)language] = readExtensionList(separator + 1);
    }
}

static void processLangMapOption( optionName, parameter )
    const char *const __unused__ optionName;
    const char *const parameter;
{
    char *const maps = (char *)malloc(strlen(parameter) + 1);
    char *map = maps;

    if (maps == NULL)
	error(FATAL | PERROR, "");
    strcpy(maps, parameter);

    DebugStatement( if (debug(DEBUG_STATUS))
			printf("Language-extension maps:\n"); )
    while (map != NULL)
    {
	char *end = strchr(parameter, ',');

	if (end != NULL)
	    *end = '\0';
	installLangMap(map);
	if (end != NULL)
	    map = end + 1;
	else
	    map = NULL;
    }
    free(maps);
}

static void processLongOption( optionString )
    const char *const optionString;
{
    enum { MaxOptionName = 10 };
    char optionName[MaxOptionName + 1];
    const char *const equal = strchr(optionString, '=');
    const char *parameter = (equal == NULL) ? "" : equal + 1;
    const size_t optionLength = (equal == NULL) ? strlen(optionString) :
	    					  (equal - optionString);

    DebugStatement( if (debug(DEBUG_OPTION))
			fprintf(errout, "Option: --%s\n", optionString); )

    strncpy(optionName, optionString, optionLength);
    if (optionLength < (size_t)MaxOptionName)
	optionName[optionLength] = '\0';
    else
	optionName[(size_t)MaxOptionName] = '\0';

#define isOption(string)	(strcmp(optionName, string) == 0)
    if (isOption("append"))
	Option.append = getBooleanOption(optionName, parameter, TRUE);
    else if (isOption("excmd"))
	processExcmdOption(optionName, parameter);
    else if (isOption("format"))
	processFormatOption(optionName, parameter);
    else if (isOption("help"))
	{ printHelp(LongOptionDescription, stdout); exit(0); }
    else if (isOption("if0"))
	Option.if0 = getBooleanOption(optionName, parameter, TRUE);
    else if (isOption("lang"))
	processLangOption(optionName, parameter);
    else if (isOption("langmap"))
	processLangMapOption(optionName, parameter);
    else if (isOption("recurse"))
#ifdef RECURSE_SUPPORTED
	Option.recurse = getBooleanOption(optionName, parameter, TRUE);
#else
	error(FATAL, "--%s option not supported on this host", optionName);
#endif
    else if (isOption("sort"))
	Option.sorted = getBooleanOption(optionName, parameter, TRUE);
    else if (isOption("totals"))
	Option.printTotals = getBooleanOption(optionName, parameter, TRUE);
    else if (isOption("version"))
    {
	printProgramIdentification(stdout);
	exit(0);
    }
    else
	error(FATAL, "Unknown option: --%s", optionName);
#undef isOption
}

static void processCompoundOption( option, pArg, argList, pArgNum )
    const int option;
    char **const pArg;
    char *const *const argList;
    int *const pArgNum;
{
    char *param;

    DebugStatement( if (debug(DEBUG_OPTION) && option != '-')
			fprintf(errout, "Option: -%c ", option); )
    switch (option)
    {
    /*	Options requiring parameters.
     */
    case 'f':
    case 'o':	Option.tagFileName=readOptionArg(option, pArg, argList,pArgNum);
		break;
    case 'h':	processHeaderListOption(option, pArg, argList, pArgNum);
		break;
    case 'i':	param = readOptionArg(option, pArg, argList, pArgNum);
		applyTagInclusionList(param);
		break;
    case 'I':	processIgnoreOption(option, pArg, argList, pArgNum);
		break;
    case 'L':	Option.fileList = readOptionArg(option, pArg, argList, pArgNum);
		break;
    case 'p':	Option.path = readOptionArg(option, pArg, argList, pArgNum);
		break;
#ifdef DEBUG
    case 'D':	param = readOptionArg(option, pArg, argList, pArgNum);
		Option.debugLevel = atoi(param);
		break;
    case 'b':	param = readOptionArg(option, pArg, argList, pArgNum);
		if (atol(param) < 0)
		    error(FATAL, "-%c: Invalid line number", option);
		Option.breakLine = atol(param);
		break;
#endif
    default: error(FATAL, "Unknown option: -%c", option); break;
    }
    DebugStatement( if (debug(DEBUG_OPTION)) fputs("\n", errout); )
}

static boolean processSimpleOption( option )
    const int option;
{
    boolean handled = TRUE;

    switch (option)
    {
	case 'a':	Option.append		= TRUE;		break;
	case 'B':	Option.backward		= TRUE;		break;
	case 'e':	Option.etags		= TRUE;
			Option.sorted		= FALSE;	break;
	case 'F':	Option.backward		= FALSE;	break;
	case 'n':	Option.locate		= EX_LINENUM;	break;
	case 'N':	Option.locate		= EX_PATTERN;	break;
	case 'R':
#ifdef RECURSE_SUPPORTED
			Option.recurse		= TRUE;		break;
#else
			error(FATAL, "-R option not supported on this host");
#endif
	case 'u':	Option.sorted		= FALSE;	break;
	case 'w':
	case 'W':	break;
	case 'x':	Option.xref		= TRUE;		break;

	case '?':	printHelp(LongOptionDescription, stdout);
			exit(0);

	default:	handled = FALSE;			break;
    }

    DebugStatement( if (handled && debug(DEBUG_OPTION))
			fprintf(errout, "Option: -%c\n", option); )

    return handled;
}

extern char *const *parseOptions( argList )
    char *const *const argList;
{
    int	argNum;

    for (argNum = 0  ;  argList[argNum] != NULL  ;  ++argNum)
    {
	char *arg = argList[argNum];
	int c;

	if (*arg++ != '-')		/* stop at first non-option switch */
	    break;
	else if (*arg == '-')		/* double dash: "--" */
	    processLongOption(arg + 1);
	else while ((c = *arg++) != '\0')
	{
	    if (! processSimpleOption(c))
		processCompoundOption(c, &arg, argList, &argNum);
	}
    }
    return &argList[argNum];
}

/*----------------------------------------------------------------------------
*-	Conversion of string into arg list
----------------------------------------------------------------------------*/

static void parseStringToArgs( string, parsedBuffer, argList, maxArgs )
    const char *const string;
    char *parsedBuffer;
    char **const argList;
    const unsigned int maxArgs;
{
    boolean argInProgress = FALSE;
    unsigned int count = 0;
    const char *src;

    for (src = string  ;  *src != '\0'  ;  ++src)
    {
	if (*src == ' ')			/* designates end of argument */
	{
	    if (argInProgress)
	    {
		*parsedBuffer++ = '\0';		/* terminate arg in progress */
		argInProgress = FALSE;
		if (count >= maxArgs)
		    break;
	    }
	}
	else
	{
	    if (! argInProgress)
	    {
		argInProgress = TRUE;
		argList[count++] = parsedBuffer;	/* point to new arg */
	    }
	    if (*src == '\\')			/* next character is literal */
		++src;				/* skip over '\\' */
	    *parsedBuffer++ = *src;
	}
    }
    *parsedBuffer = '\0';		/* null terminate last argument */
    argList[count] = NULL;		/* terminate list */
}

static unsigned int countStringWords( string )
    const char *const string;
{
    const char *const whiteSpace = " \t\n";
    const char *p = string;
    unsigned int numWords = 0;

    p += strspn(p, whiteSpace);			/* skip over leading spaces */
    while (*p != '\0')
    {
	++numWords;
	p += strcspn(p, whiteSpace);		/* skip to white space */
	p += strspn(p, whiteSpace);		/* skip to non-white space */
    }
    return numWords;
}

static char **creatArgListForString( string )
    const char *const string;
{
    const unsigned int numWords = countStringWords(string);
    char **argList = NULL;

    if (string != NULL  &&  string[0] != '\0')
    {
	/*  We place the parsed string at the end of the memory block, past
	 *  the bottom of the argument table.
	 */
	const size_t argListSize= (numWords + 1) * sizeof(char *);
	const size_t blockSize	= argListSize + strlen(string) + 1;

	argList	= (char **)malloc(blockSize);
	if (argList != NULL)
	    parseStringToArgs(string, (char *)argList + argListSize,
			      argList, numWords);
    }
    return argList;
}

extern void *parseEnvironmentOptions()
{
    const char *envOptions = NULL;
    char **argList = NULL;

    if (Option.startedAsEtags)
	envOptions = getenv(ETAGS_ENVIRONMENT);
    if (envOptions == NULL)
	envOptions = getenv(CTAGS_ENVIRONMENT);
    if (envOptions != NULL  &&  envOptions[0] != '\0')
    {
	argList = creatArgListForString(envOptions);
	parseOptions(argList);
    }
    return argList;
}

/* vi:set tabstop=8 shiftwidth=4: */