options.c

ultraEdit的Ctag标签工具的实现源代码

    {
	if (! Option.etags || optDesc [i].usedByEtags)
	    puts (optDesc [i].description);
    }
}

static void printFeatureList (void)
{
    int i;

    for (i = 0 ; Features [i] != NULL ; ++i)
    {
	if (i == 0)
	    printf ("  Optional compiled features: ");
	printf ("%s+%s", (i>0 ? ", " : ""), Features [i]);
#ifdef CUSTOM_CONFIGURATION_FILE
	if (strcmp (Features [i], "custom-conf") == 0)
	    printf ("=%s", CUSTOM_CONFIGURATION_FILE);
#endif
    }
    if (i > 0)
	putchar ('\n');
}

static void printProgramIdentification (void)
{
    printf ("%s %s, Copyright (C) 1996-2003 %s\n",
	    PROGRAM_NAME, PROGRAM_VERSION, AUTHOR_NAME);
    printf ("  Compiled: %s, %s\n", __DATE__, __TIME__);
    printf ("  Addresses: <%s>, %s\n", AUTHOR_EMAIL, PROGRAM_URL);
    printFeatureList ();
}

static void processHelpOption (
	const char *const option __unused__,
	const char *const parameter __unused__)
{
    printProgramIdentification ();
    putchar ('\n');
    printInvocationDescription ();
    putchar ('\n');
    printOptionDescriptions (LongOptionDescription);
    exit (0);
}

static void processLanguageForceOption (
	const char *const option, const char *const parameter)
{
    langType language;
    if (strcasecmp (parameter, "auto") == 0)
	language = LANG_AUTO;
    else
	language = getNamedLanguage (parameter);

    if (strcmp (option, "lang") == 0  ||  strcmp (option, "language") == 0)
	error (WARNING,
	       "\"--%s\" option is obsolete; use \"--language-force\" instead",
	       option);
    if (language == LANG_IGNORE)
	error (FATAL, "Unknown language specified in \"%s\" option", option);
    else
	Option.language = language;
}
static char* skipPastMap (char* p)
{
    while (*p != EXTENSION_SEPARATOR  &&
	    *p != PATTERN_START  &&  *p != ','  &&  *p != '\0')
	++p;
    return p;
}

/* Parses the mapping beginning at `map', adds it to the language map, and
 * returns first character past the map.
 */
static char* addLanguageMap (const langType language, char* map)
{
    char* p = NULL;
    const char first = *map;
    if (first == EXTENSION_SEPARATOR)	    /* extension map */
    {
	++map;
	p = skipPastMap (map);
	if (*p == '\0')
	{
	    verbose (" .%s", map);
	    addLanguageExtensionMap (language, map);
	    p = map + strlen (map);
	}
	else
	{
	    const char separator = *p;
	    *p = '\0';
	    verbose (" .%s", map);
	    addLanguageExtensionMap (language, map);
	    *p = separator;
	}
    }
    else if (first == PATTERN_START)	    /* pattern map */
    {
	++map;
	for (p = map  ;  *p != PATTERN_STOP  &&  *p != '\0'  ;  ++p)
	{
	    if (*p == '\\'  &&  *(p + 1) == PATTERN_STOP)
		++p;
	}
	if (*p == '\0')
	    error (FATAL, "Unterminated file name pattern for %s language",
	       getLanguageName (language));
	else
	{
	    *p++ = '\0';
	    verbose (" (%s)", map);
	    addLanguagePatternMap (language, map);
	}
    }
    else
	error (FATAL, "Badly formed language map for %s language",
		getLanguageName (language));
    return p;
}

static char* processLanguageMap (char* map)
{
    char* const separator = strchr (map, ':');
    char* result = NULL;
    if (separator != NULL)
    {
	langType language;
	char *list = separator + 1;
	boolean clear = FALSE;
	*separator = '\0';
	language = getNamedLanguage (map);
	if (language != LANG_IGNORE)
	{
	    const char *const deflt = "default";
	    char* p;
	    if (*list == '+')
		++list;
	    else
		clear = TRUE;
	    for (p = list  ;  *p != ','  &&  *p != '\0'  ;  ++p) /*no-op*/ ;
	    if ((size_t) (p - list) == strlen (deflt) &&
		strncasecmp (list, deflt, p - list) == 0)
	    {
		verbose ("    Restoring default %s language map: ", getLanguageName (language));
		installLanguageMapDefault (language);
		list = p;
	    }
	    else
	    {
		if (clear)
		{
		    verbose ("    Setting %s language map:", getLanguageName (language));
		    clearLanguageMap (language);
		}
		else
		    verbose ("    Adding to %s language map:", getLanguageName (language));
		while (list != NULL  &&  *list != '\0'  &&  *list != ',')
		    list = addLanguageMap (language, list);
		verbose ("\n");
	    }
	    if (list != NULL  &&  *list == ',')
		++list;
	    result = list;
	}
    }
    return result;
}

static void processLanguageMapOption (
	const char *const option, const char *const parameter)
{
    char *const maps = eStrdup (parameter);
    char *map = maps;

    if (strcmp (parameter, "default") == 0)
    {
	verbose ("    Restoring default language maps:\n");
	installLanguageMapDefaults ();
    }
    else while (map != NULL  &&  *map != '\0')
    {
	char* const next = processLanguageMap (map);
	if (next == NULL)
	    error (WARNING, "Unknown language specified in \"%s\" option", option);
	map = next;
    }
    eFree (maps);
}

static void processLanguagesOption (
	const char *const option, const char *const parameter)
{
    char *const langs = eStrdup (parameter);
    enum { Add, Remove, Replace } mode = Replace;
    boolean first = TRUE;
    char *lang = langs;
    const char* prefix = "";
    verbose ("    Enabled languages: ");
    while (lang != NULL)
    {
	char *const end = strchr (lang, ',');
	if (lang [0] == '+')
	{
	    ++lang;
	    mode = Add;
	    prefix = "+ ";
	}
	else if (lang [0] == '-')
	{
	    ++lang;
	    mode = Remove;
	    prefix = "- ";
	}
	if (mode == Replace)
	    enableLanguages (FALSE);
	if (end != NULL)
	    *end = '\0';
	if (lang [0] != '\0')
	{
	    if (strcmp (lang, "all") == 0)
		enableLanguages ((boolean) (mode != Remove));
	    else
	    {
		const langType language = getNamedLanguage (lang);
		if (language == LANG_IGNORE)
		    error (WARNING, "Unknown language specified in \"%s\" option", option);
		else
		    enableLanguage (language, (boolean) (mode != Remove));
	    }
	    verbose ("%s%s%s", (first ? "" : ", "), prefix, lang);
	    prefix = "";
	    first = FALSE;
	    if (mode == Replace)
		mode = Add;
	}
	lang = (end != NULL ? end + 1 : NULL);
    }
    verbose ("\n");
    eFree (langs);
}

static void processLicenseOption (
	const char *const option __unused__,
	const char *const parameter __unused__)
{
    printProgramIdentification ();
    puts ("");
    puts (License1);
    puts (License2);
    exit (0);
}

static void processListKindsOption (
	const char *const option, const char *const parameter)
{
    if (parameter [0] == '\0' || strcasecmp (parameter, "all") == 0)
        printLanguageKinds (LANG_AUTO);
    else
    {
	langType language = getNamedLanguage (parameter);
	if (language == LANG_IGNORE)
	    error (FATAL, "Unknown language specified in \"%s\" option",option);
	else
	    printLanguageKinds (language);
    }
    exit (0);
}

static void processListMapsOption (
	const char *const __unused__ option,
	const char *const __unused__ parameter)
{
    if (parameter [0] == '\0' || strcasecmp (parameter, "all") == 0)
        printLanguageMaps (LANG_AUTO);
    else
    {
	langType language = getNamedLanguage (parameter);
	if (language == LANG_IGNORE)
	    error (FATAL, "Unknown language specified in \"%s\" option",option);
	else
	    printLanguageMaps (language);
    }
    exit (0);
}

static void processListLanguagesOption (
	const char *const option __unused__,
	const char *const parameter __unused__)
{
    printLanguageList ();
    exit (0);
}

static void processOptionFile (
	const char *const option, const char *const parameter)
{
    if (parameter [0] == '\0')
	error (WARNING, "no option file supplied for \"%s\"", option);
    else if (! parseFileOptions (parameter))
	error (FATAL | PERROR, "cannot open option file \"%s\"", parameter);
}

static void processSortOption (
	const char *const option, const char *const parameter)
{
    if (isFalse (parameter))
	Option.sorted = SO_UNSORTED;
    else if (isTrue (parameter))
	Option.sorted = SO_SORTED;
    else if (strcasecmp (parameter, "f") == 0 ||
	    strcasecmp (parameter, "fold") == 0 ||
	    strcasecmp (parameter, "foldcase") == 0)
	Option.sorted = SO_FOLDSORTED;
    else
	error (FATAL, "Invalid value for \"%s\" option", option);
}

static void installHeaderListDefaults (void)
{
    Option.headerExt = stringListNewFromArgv (HeaderExtensions);
    if (Option.verbose)
    {
	printf ("    Setting default header extensions: ");
	stringListPrint (Option.headerExt);
	putchar ('\n');
    }
}

static void processHeaderListOption (const int option, const char *parameter)
{
    /*  Check to make sure that the user did not enter "ctags -h *.c"
     *  by testing to see if the list is a filename that exists.
     */
    if (doesFileExist (parameter))
	error (FATAL, "-%c: Invalid list", option);
    if (strcmp (parameter, "default") == 0)
	installHeaderListDefaults ();
    else
    {
	boolean clear = TRUE;

	if (parameter [0] == '+')
	{
	    ++parameter;
	    clear = FALSE;
	}
	if (Option.headerExt == NULL)
	    Option.headerExt = stringListNew ();
	verbose ("    Header Extensions:\n");
	addExtensionList (Option.headerExt, parameter, clear);
    }
}

/*
 *  Token ignore processing
 */

/*  Determines whether or not "name" should be ignored, per the ignore list.
 */
extern boolean isIgnoreToken (
	const char *const name, boolean *const pIgnoreParens,
	const char **const replacement)
{
    boolean result = FALSE;

    if (Option.ignore != NULL)
    {
	const size_t nameLen = strlen (name);
	unsigned int i;

	if (pIgnoreParens != NULL)
	    *pIgnoreParens = FALSE;

	for (i = 0  ;  i < stringListCount (Option.ignore)  ;  ++i)
	{
	    vString *token = stringListItem (Option.ignore, i);

	    if (strncmp (vStringValue (token), name, nameLen) == 0)
	    {
		const size_t tokenLen = vStringLength (token);

		if (nameLen == tokenLen)
		{
		    result = TRUE;
		    break;
		}
		else if (tokenLen == nameLen + 1  &&
			vStringChar (token, tokenLen - 1) == '+')
		{
		    result = TRUE;
		    if (pIgnoreParens != NULL)
			*pIgnoreParens = TRUE;
		    break;
		}
		else if (vStringChar (token, nameLen) == '=')
		{
		    if (replacement != NULL)
			*replacement = vStringValue (token) + nameLen + 1;
		    break;
		}
	    }
	}
    }
    return result;
}

static void saveIgnoreToken (vString *const ignoreToken)
{
    if (Option.ignore == NULL)
	Option.ignore = stringListNew ();
    stringListAdd (Option.ignore, ignoreToken);
    verbose ("    ignore token: %s\n", vStringValue (ignoreToken));
}

static void readIgnoreList (const char *const list)
{
    char* newList = stringCopy (list);
    const char *token = strtok (newList, IGNORE_SEPARATORS);

    while (token != NULL)
    {
	vString *const entry = vStringNewInit (token);

	saveIgnoreToken (entry);
	token = strtok (NULL, IGNORE_SEPARATORS);
    }
    eFree (newList);
}

static void addIgnoreListFromFile (const char *const fileName)
{
    stringList* tokens = stringListNewFromFile (fileName);
    if (tokens == NULL)
	error (FATAL | PERROR, "cannot open \"%s\"", fileName);
    if (Option.ignore == NULL)
	Option.ignore = tokens;
    else
	stringListCombine (Option.ignore, tokens);
}

static void processIgnoreOption (const char *const list)
{
    if (strchr ("@./\\", list [0]) != NULL)
    {