自学教程：C++ vStringDelete函数代码示例

/** Emits a tag for the given 'name' of kind 'kind' at the current nesting.*/static void emitRubyTag (vString* name, rubyKind kind){	tagEntryInfo tag;	vString* scope;	tagEntryInfo *parent;	rubyKind parent_kind = K_UNDEFINED;	NestingLevel *lvl;	const char *unqualified_name;	const char *qualified_name;	int r;        if (!RubyKinds[kind].enabled) {            return;        }	scope = nestingLevelsToScope (nesting);	lvl = nestingLevelsGetCurrent (nesting);	parent = getEntryOfNestingLevel (lvl);	if (parent)		parent_kind =  parent->kindIndex;	qualified_name = vStringValue (name);	unqualified_name = strrchr (qualified_name, SCOPE_SEPARATOR);	if (unqualified_name && unqualified_name[1])	{		if (unqualified_name > qualified_name)		{			if (vStringLength (scope) > 0)				vStringPut (scope, SCOPE_SEPARATOR);			vStringNCatS (scope, qualified_name,			              unqualified_name - qualified_name);			/* assume module parent type for a lack of a better option */			parent_kind = K_MODULE;		}		unqualified_name++;	}	else		unqualified_name = qualified_name;	initTagEntry (&tag, unqualified_name, kind);	if (vStringLength (scope) > 0) {		Assert (0 <= parent_kind &&		        (size_t) parent_kind < (ARRAY_SIZE (RubyKinds)));		tag.extensionFields.scopeKindIndex = parent_kind;		tag.extensionFields.scopeName = vStringValue (scope);	}	r = makeTagEntry (&tag);	nestingLevelsPush (nesting, r);	vStringClear (name);	vStringDelete (scope);}

static void parseFunction (const unsigned char *line){	vString *name = vStringNew ();	/* boolean inFunction = FALSE; */	int scope;	const unsigned char *cp = line + 1;	if ((int) *++cp == 'n'	&&	(int) *++cp == 'c'	&&		(int) *++cp == 't'	&&	(int) *++cp == 'i'	&&		(int) *++cp == 'o'	&&	(int) *++cp == 'n')			++cp;	if ((int) *cp == '!')		++cp;	if (isspace ((int) *cp))	{		while (*cp && isspace ((int) *cp))			++cp;		if (*cp)		{			cp = skipPrefix (cp, &scope);			if (isupper ((int) *cp)  ||  					scope == 's'  ||  /* script scope */					scope == '<'  ||  /* script scope */					scope == 'd'  ||  /* dictionary */					scope == 'a')	  /* autoload */			{				do				{					vStringPut (name, (int) *cp);					++cp;				} while (isalnum ((int) *cp) ||  *cp == '_' ||	*cp == '.' ||  *cp == '#');				vStringTerminate (name);				makeSimpleTag (name, VimKinds, K_FUNCTION);				vStringClear (name);			}		}	}	/* TODO - update struct to indicate inside function */	while ((line = readVimLine ()) != NULL)	{		/* 		 * Vim7 added the for/endfo[r] construct, so we must first		 * check for an "endfo", before a "endf"		 */		if ( (!strncmp ((const char*) line, "endfo", (size_t) 5) == 0) && 				(strncmp ((const char*) line, "endf", (size_t) 4) == 0)   )			break;		/* TODO - call parseVimLine */	}	vStringDelete (name);}

static void findRustTags (void){	lexerState lexer;	vString* scope = vStringNew();	initLexer(&lexer);	parseBlock(&lexer, FALSE, K_NONE, scope);	vStringDelete(scope);	deInitLexer(&lexer);}

static void setInputFileName (const char *const fileName){	const char *const head = fileName;	const char *const tail = baseFilename (head);	if (File.name != NULL)		vStringDelete (File.name);	File.name = vStringNewInit (fileName);	if (File.path != NULL)		vStringDelete (File.path);	if (tail == head)		File.path = NULL;	else	{		const size_t length = tail - head - 1;		File.path = vStringNew ();		vStringNCopyS (File.path, fileName, length);	}}

static langType getInterpreterLanguage (const char *const fileName){    langType result = LANG_IGNORE;    FILE* const fp = fopen (fileName, "r");    if (fp != NULL)    {	vString* const vLine = vStringNew ();	const char* const line = readLine (vLine, fp);	if (line != NULL  &&  line [0] == '#'  &&  line [1] == '!')	{	    const char* const lastSlash = strrchr (line, '/');	    const char *const cmd = lastSlash != NULL ? lastSlash+1 : line+2;	    vString* const interpreter = determineInterpreter (cmd);	    result = getExtensionLanguage (vStringValue (interpreter));	    vStringDelete (interpreter);	}	vStringDelete (vLine);	fclose (fp);    }    return result;}

static boolean AutomakeMakeTag (vString *const name, const char* suffix, boolean appending,			    int kindex, int rindex, struct sBlacklist *blacklist,			    void *data){	int *index = data;	size_t expected_len;	size_t len;	char* tail;	vString *subname;	int i;	len = vStringLength (name);	expected_len = strlen (suffix);	if (len <= expected_len)		return FALSE;	for (i = 0; blacklist[i].type != BL_END; i++)	{		if (bl_check (vStringValue(name), blacklist + i) == FALSE)			return FALSE;	}	tail = vStringValue (name) + len - expected_len;	if (strcmp (tail, suffix))		return FALSE;	subname = vStringNew();	/* ??? dist, nodist, nobase, notrans,... */	if (strncmp (vStringValue(name), "dist_", 5) == 0)		vStringNCopyS(subname, vStringValue(name) + 5, len - expected_len - 5);	else		vStringNCopyS(subname, vStringValue(name), len - expected_len);	if (rindex == ROLE_INDEX_DEFINITION)	{		*index = makeSimpleTag (subname, AutomakeKinds, kindex);		addAutomakeDirectory (subname, *index);	}	else	{		*index = CORK_NIL;		if (appending)			*index = lookupAutomakeDirectory (subname);		if ((!appending) || (*index == CORK_NIL))			*index = makeSimpleRefTag (subname, AutomakeKinds, kindex, rindex);	}	vStringDelete (subname);	return TRUE;}

static tgTableEntry* freeTgEntry(tgTableEntry *entry){	tgTableEntry* r;	if (entry->corpus_file)	{		eFree (entry->tg_table);		entry->tg_table = NULL;		vStringDelete (entry->corpus_file);		entry->corpus_file = NULL;	}	vStringDelete (entry->spec);	entry->spec = NULL;	r = entry->next;	entry->next = NULL;	eFree(entry);	return r;}

static void findTags (boolean startsInPhpMode){	tokenInfo *const token = newToken ();	InPhp = startsInPhpMode;	CurrentStatement.access = ACCESS_UNDEFINED;	CurrentStatement.impl = IMPL_UNDEFINED;	CurrentNamesapce = vStringNew ();	FullScope = vStringNew ();	AnonymousID = 0;	do	{		enterScope (token, NULL, -1);	}	while (token->type != TOKEN_EOF); /* keep going even with unmatched braces */	vStringDelete (FullScope);	vStringDelete (CurrentNamesapce);	deleteToken (token);}

static vString* extractZshAutoloadTag(FILE* input){	vString* const vLine = vStringNew ();	const char* const line = readLine (vLine, input);	vString* mode = NULL;	if (line)		mode = determineZshAutoloadTag (line);	vStringDelete (vLine);	return mode;}

static void findOcamlTags (void){	vString *name = vStringNew ();	lexingState st;	ocaToken tok;	initStack ();	computeModuleName ();	tempIdent = vStringNew ();	lastModule = vStringNew ();	lastClass = vStringNew ();	voidName = vStringNew ();	vStringCopyS (voidName, "_");	st.name = vStringNew ();	st.cp = fileReadLine ();	toDoNext = &globalScope;	tok = lex (&st);	while (tok != Tok_EOF)	{		(*toDoNext) (st.name, tok);		tok = lex (&st);	}	vStringDelete (st.name);	vStringDelete (name);	vStringDelete (voidName);	vStringDelete (tempIdent);	vStringDelete (lastModule);	vStringDelete (lastClass);	clearStack ();}

static int parseEscapedCharacter (void){	int d = '/0';	int c = fileGetc ();	switch (c)	{		case 'A':  d = '@';   break;		case 'B':  d = '/b';  break;		case 'C':  d = '^';   break;		case 'D':  d = '$';   break;		case 'F':  d = '/f';  break;		case 'H':  d = '//';  break;		case 'L':  d = '~';   break;		case 'N':  d = '/n';  break;#ifdef QDOS		case 'Q':  d = 0x9F;  break;#else		case 'Q':  d = '`';   break;#endif		case 'R':  d = '/r';  break;		case 'S':  d = '#';   break;		case 'T':  d = '/t';  break;		case 'U':  d = '/0';  break;		case 'V':  d = '|';   break;		case '%':  d = '%';   break;		case '/'': d = '/'';  break;		case '"':  d = '"';   break;		case '(':  d = '[';   break;		case ')':  d = ']';   break;		case '<':  d = '{';   break;		case '>':  d = '}';   break;		case '/n': skipToCharacter ('%'); break;		case '/':		{			vString *string = parseInteger ('/0');			const char *value = vStringValue (string);			const unsigned long ascii = atol (value);			vStringDelete (string);			c = fileGetc ();			if (c == '/'  &&  ascii < 256)				d = ascii;			break;		}		default: break;	}	return d;}

/* Match a "label:" style label. */static void match_colon_label (char const *p){	char const *end = p + strlen (p) - 1;	while (isspace (*end))		end--;	if (*end == ':')	{		vString *name = vStringNew ();		vStringNCatS (name, p, end - p);		makeSimpleTag (name, BasicKinds, K_LABEL);		vStringDelete (name);	}}

static boolean recurseIntoDirectory (const char *const dirName){    boolean resize = FALSE;    if (isRecursiveLink (dirName))	verbose ("ignoring /"%s/" (recursive link)/n", dirName);    else if (! Option.recurse)	verbose ("ignoring /"%s/" (directory)/n", dirName);    else    {	verbose ("RECURSING into directory /"%s/"/n", dirName);#if defined (HAVE_OPENDIR)	resize = recurseUsingOpendir (dirName);#elif defined (HAVE_FINDFIRST) || defined (HAVE__FINDFIRST)	{	    vString *const pattern = vStringNew ();	    vStringCopyS (pattern, dirName);	    vStringPut (pattern, OUTPUT_PATH_SEPARATOR);	    vStringCatS (pattern, "*.*");	    resize = createTagsForWildcardUsingFindfirst (vStringValue (pattern));	    vStringDelete (pattern);	}#elif defined (AMIGA)	{	    vString *const pattern = vStringNew ();	    if (*dirName != '/0'  &&  strcmp (dirName, ".") != 0)	    {		vStringCopyS (pattern, dirName);		if (dirName [strlen (dirName) - 1] != '/')		    vStringPut (pattern, '/');	    }	    vStringCatS (pattern, "#?");	    resize = createTagsForAmigaWildcard (vStringValue (pattern));	    vStringDelete (pattern);	}#endif    }    return resize;}

/* Match a keyword starting at p (case insensitive). */static int match_keyword (const char *p, KeyWord const *kw){	vString *name;	size_t i;	int j;	const char *old_p;	for (i = 0; i < strlen (kw->token); i++)	{		if (tolower (p[i]) != kw->token[i])			return 0;	}	name = vStringNew ();	p += i;	if (kw == &freebasic_keywords[0] ||		kw == &freebasic_keywords[1] ||		kw == &freebasic_keywords[2])		return extract_dim (p, name, kw->kind); /* extract_dim adds the found tag(s) */	old_p = p;	while (isspace (*p))		p++;	/* create tags only if there is some space between the keyword and the identifier */	if (old_p == p)	{		vStringDelete (name);		return 0;	}	for (j = 0; j < 1; j++)	{		p = extract_name (p, name);	}	makeSimpleTag (name, BasicKinds, kw->kind);	vStringDelete (name);	return 1;}

static void setInputFileParametersCommon (inputFileInfo *finfo, vString *const fileName,					  const langType language, stringList *holder){	if (finfo->name != NULL)		vStringDelete (finfo->name);	finfo->name = fileName;	if (finfo->tagPath != NULL)	{		if (holder)			stringListAdd (holder, finfo->tagPath);		else			vStringDelete (finfo->tagPath);	}	if (! Option.tagRelative || isAbsolutePath (vStringValue (fileName)))		finfo->tagPath = vStringNewCopy (fileName);	else		finfo->tagPath =				vStringNewOwn (relativeFilename (vStringValue (fileName), TagFile.directory));	finfo->isHeader = isIncludeFile (vStringValue (fileName));	finfo->language = language;}

static void findSmlTags (void){    vString *const identifier = vStringNew ();    const unsigned char *line;    smlKind lastTag = K_NONE;    while ((line = fileReadLine ()) != NULL)    {        const unsigned char *cp = skipSpace (line);        do        {            smlKind foundTag;            if (CommentLevel != 0)            {                cp = (const unsigned char *) strstr ((const char *) cp, "*)");                if (cp == NULL)                    continue;                else                {                    --CommentLevel;                    cp += 2;                }            }            foundTag = findNextIdentifier (&cp);            if (foundTag != K_NONE)            {                cp = skipSpace (cp);                cp = parseIdentifier (cp, identifier);                if (foundTag == K_AND)                {                    if (lastTag != K_NONE)                        makeSmlTag (lastTag, identifier);                }                else                {                    makeSmlTag (foundTag, identifier);                    lastTag = foundTag;                }            }            if (strstr ((const char *) cp, "(*") != NULL)            {                cp += 2;                cp = (const unsigned char *) strstr ((const char *) cp, "*)");                if (cp == NULL)                    ++CommentLevel;            }        } while (cp != NULL  &&  strcmp ((const char *) cp, "") != 0);    }    vStringDelete (identifier);}

static void findVhdlTags (void){    volatile boolean newStatement = TRUE;    volatile int c = '/0';    exception_t exception = (exception_t) setjmp (Exception);	Name = vStringNew ();    Lastname = vStringNew ();    Keyword = vStringNew ();    TagName = vStringNew ();    if (exception == ExceptionNone) while (c != EOF)    {		c = vGetc ();		switch (c)		{			case ';':			case '/n':			newStatement = TRUE;			break;			case ' ':			case '/t':			break;			default:			if (newStatement && readIdentifier (Name, c)) {				findTag (Name);				}			newStatement = FALSE;			break;		}    }    vStringDelete (Name);    vStringDelete (Lastname);    vStringDelete (Keyword);    vStringDelete (TagName);}

static void setInputFileParametersCommon (inputFileInfo *finfo, vString *const fileName,					  const langType language,					  void (* setLang) (inputLangInfo *, langType),					  stringList *holder){	if (finfo->name != NULL)		vStringDelete (finfo->name);	finfo->name = fileName;	if (finfo->tagPath != NULL)	{		if (holder)			stringListAdd (holder, finfo->tagPath);		else			vStringDelete (finfo->tagPath);	}	if (0)		;	else if (  Option.tagRelative == TREL_ALWAYS )		finfo->tagPath =			vStringNewOwn (relativeFilename (vStringValue (fileName),							 getTagFileDirectory ()));	else if ( Option.tagRelative == TREL_NEVER )		finfo->tagPath =			vStringNewOwn (absoluteFilename (vStringValue (fileName)));	else if ( Option.tagRelative == TREL_NO || isAbsolutePath (vStringValue (fileName)) )		finfo->tagPath = vStringNewCopy (fileName);	else		finfo->tagPath =			vStringNewOwn (relativeFilename (vStringValue (fileName),							 getTagFileDirectory ()));	finfo->isHeader = isIncludeFile (vStringValue (fileName));	setLang (& (finfo->langInfo), language);}

static void makeTexTag (tokenInfo *const token, texKind kind){	if (TexKinds [kind].enabled)	{		const char *const name = vStringValue (token->string);		vString *parentKind = vStringNew();		vString *parentName = vStringNew();		tagEntryInfo e;		initTagEntry (&e, name, &(TexKinds [kind]));		e.lineNumber   = token->lineNumber;		e.filePosition = token->filePosition;		getScopeInfo(kind, parentKind, parentName);		if (vStringLength(parentKind) > 0) {			e.extensionFields.scopeKind = kindFromName (vStringValue(parentKind));			e.extensionFields.scopeName = vStringValue(parentName);		}		makeTagEntry (&e);		vStringDelete (parentKind);		vStringDelete (parentName);	}}

static void found_tag_cb (const char *line,			  const regexMatch *matches,			  unsigned int count,			  void *userData){	if (count > 0)	{		vString *name = vStringNew ();		vStringNCopyS (name, line + matches[1].start, matches[1].length);		makeSimpleTag (name, RpmSpecKinds, K_TAG);		if (count > 1)		{			if (strcasecmp (vStringValue (name), "name") == 0)			{				vString *package = vStringNew ();				vStringNCopyS (package, line + matches[2].start, matches[2].length);				*((int *)userData) = makeSimpleTag (package, RpmSpecKinds, K_PACKAGE);				vStringDelete (package);			}		}		vStringDelete (name);	}}

static void findShTags (void){	vString *name = vStringNew ();	const unsigned char *line;	while ((line = fileReadLine ()) != NULL)	{		const unsigned char* cp = line;		boolean functionFound = FALSE;		if (line [0] == '#')			continue;		while (isspace (*cp))			cp++;		if (strncmp ((const char*) cp, "function", (size_t) 8) == 0  &&			isspace ((int) cp [8]))		{			functionFound = TRUE;			cp += 8;			if (! isspace ((int) *cp))				continue;			while (isspace ((int) *cp))				++cp;		}		if (! (isalnum ((int) *cp) || *cp == '_'))			continue;		while (isalnum ((int) *cp)  ||  *cp == '_')		{			vStringPut (name, (int) *cp);			++cp;		}		vStringTerminate (name);		while (isspace ((int) *cp))			++cp;		if (*cp++ == '(')		{			while (isspace ((int) *cp))				++cp;			if (*cp == ')'  && ! hackReject (name))				functionFound = TRUE;		}		if (functionFound)			makeSimpleTag (name, ShKinds, K_FUNCTION);		vStringClear (name);	}	vStringDelete (name);}

static void matchTagPattern (const vString* const line,		const regexPattern* const patbuf,		const regmatch_t* const pmatch){	vString *const name = substitute (vStringValue (line),			patbuf->u.tag.name_pattern, BACK_REFERENCE_COUNT, pmatch);	vStringStripLeading (name);	vStringStripTrailing (name);	if (vStringLength (name) > 0)		makeRegexTag (name, &patbuf->u.tag.kind);	else		error (WARNING, "%s:%ld: null expansion of name pattern /"%s/"",			getInputFileName (), getInputLineNumber (),			patbuf->u.tag.name_pattern);	vStringDelete (name);}

static void findHtmlTags (void){	tokenInfo token;	token.string = vStringNew ();	do	{		readToken (&token, true);		if (token.type == TOKEN_TAG_START)			readTag (&token, NULL, 0);	}	while (token.type != TOKEN_EOF);	vStringDelete (token.string);}

static smlKind findNextIdentifier (const unsigned char **cp){	smlKind result = K_NONE;	vString *const identifier = vStringNew ();	unsigned int count = sizeof (SmlKeywordTypes) / sizeof (SmlKeywordTypes [0]);	unsigned int i;	*cp = parseIdentifier (*cp, identifier);	for (i = 0  ;  i < count  &&  result == K_NONE ;  ++i)	{		const char *id = vStringValue (identifier);		if (strcmp (id, SmlKeywordTypes [i].keyword) == 0)			result = SmlKeywordTypes [i].kind;	}	vStringDelete (identifier);	return result;}

static boolean createTagsForWildcardEntry (		const char *const pattern, const size_t dirLength,		const char *const entryName){	boolean resize = FALSE;	/* we must not recurse into the directories "." or ".." */	if (strcmp (entryName, ".") != 0  &&  strcmp (entryName, "..") != 0)	{		vString *const filePath = vStringNew ();		vStringNCopyS (filePath, pattern, dirLength);		vStringCatS (filePath, entryName);		resize = createTagsForEntry (vStringValue (filePath));		vStringDelete (filePath);	}	return resize;}

static void parseFunction (tokenInfo *const token){	tokenInfo *const name = newToken ();	vString *const signature = vStringNew ();	boolean is_class = FALSE;	/*	 * This deals with these formats	 *	   function validFunctionTwo(a,b) {}	 */	readToken (name);	if (!isType (name, TOKEN_IDENTIFIER))		goto cleanUp;	/* Add scope in case this is an INNER function */	addToScope(name, token->scope);	readToken (token);	while (isType (token, TOKEN_PERIOD))	{		readToken (token);		if ( isKeyword(token, KEYWORD_NONE) )		{			addContext (name, token);			readToken (token);		}	}	if ( isType (token, TOKEN_OPEN_PAREN) )		skipArgumentList(token, FALSE, signature);	if ( isType (token, TOKEN_OPEN_CURLY) )	{		is_class = parseBlock (token, name);		if ( is_class )			makeClassTag (name, signature);		else			makeFunctionTag (name, signature);	}	findCmdTerm (token, FALSE, FALSE); cleanUp:	vStringDelete (signature);	deleteToken (name);}

static void found_package_cb (const char *line,			      const regexMatch *matches,			      unsigned int count,			      void *userData){	if (count > 0)	{		vString *name = vStringNew ();		tagEntryInfo tag;		vStringNCopyS (name, line + matches[1].start, matches[1].length);		initTagEntry (&tag, vStringValue (name), RpmSpecKinds + K_PACKAGE);		tag.extensionFields.scopeIndex = *(int *)userData;		makeTagEntry (&tag);		vStringDelete (name);	}}

void cxxTokenForceDestroy(CXXToken * t){	if(!t)		return;	if(t->pChain)	{		cxxTokenChainDestroy(t->pChain);		t->pChain = NULL;	}	CXX_DEBUG_ASSERT(t->pszWord,"There should be a word here");	vStringDelete(t->pszWord);	eFree(t);}

static void parseFunction (const unsigned char *line){	vString *name = vStringNew ();	/* boolean inFunction = FALSE; */	int scope;	const unsigned char *cp = line;	if ((int) *cp == '!')		++cp;	if (isspace ((int) *cp))	{		while (*cp && isspace ((int) *cp))			++cp;		if (*cp)		{			cp = skipPrefix (cp, &scope);			if (isupper ((int) *cp)  ||  					scope == 's'  ||  /* script scope */					scope == '<'  ||  /* script scope */					scope == 'd'  ||  /* dictionary */					scope == 'a')	  /* autoload */			{				do				{					vStringPut (name, (int) *cp);					++cp;				} while (isalnum ((int) *cp) ||  *cp == '_' ||	*cp == '.' ||  *cp == '#');				vStringTerminate (name);				makeSimpleTag (name, VimKinds, K_FUNCTION);				vStringClear (name);			}		}	}	/* TODO - update struct to indicate inside function */	while ((line = readVimLine ()) != NULL)	{		if (wordMatchLen (line, "endfunction", 4))			break;		parseVimLine(line, TRUE);	}	vStringDelete (name);}

/* Algorithm adapted from from GNU etags. */static void findLispTags (void){	vString *name = vStringNew ();	const unsigned char* p;	while ((p = fileReadLine ()) != NULL)	{		if (*p == '(')		{			if (L_isdef (p))			{				while (*p != '/0' && !isspace ((int) *p))					p++;				while (isspace ((int) *p))					p++;				L_getit (name, p);			}			else			{				/* Check for (foo::defmumble name-defined ... */				do					p++;				while (*p != '/0' && !isspace ((int) *p)						&& *p != ':' && *p != '(' && *p != ')');				if (*p == ':')				{					do						p++;					while (*p == ':');					if (L_isdef (p - 1))					{						while (*p != '/0' && !isspace ((int) *p))							p++;						while (isspace (*p))							p++;						L_getit (name, p);					}				}			}		}	}	vStringDelete (name);}