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

static int makeFunctionTag (const tokenInfo *const token,                            const vString *const arglist,                            const vString *const decorators){	if (PythonKinds[K_FUNCTION].enabled)	{		tagEntryInfo e;		initPythonEntry (&e, token, K_FUNCTION);		if (arglist)			e.extensionFields.signature = vStringValue (arglist);		if (decorators && vStringLength (decorators) > 0)		{			attachParserField (&e, PythonFields[F_DECORATORS].ftype,			                   vStringValue (decorators));		}		return makeTagEntry (&e);	}	return CORK_NIL;}

static void makeFunctionTag (vString * const name, const char *dbp, int scope_index){	functionName (name, dbp);	if (vStringLength (name) > 0 && ClojureKinds[K_FUNCTION].enabled)	{		tagEntryInfo e;		initTagEntry (&e, vStringValue (name), K_FUNCTION);		e.lineNumber = getInputLineNumber ();		e.filePosition = getInputFilePosition ();		e.extensionFields.scopeIndex =  scope_index;		makeTagEntry (&e);	}}

static void makeRegexTag (		const vString* const name, const struct sKind* const kind){	if (kind->enabled)	{		tagEntryInfo e;		Assert (name != NULL  &&  vStringLength (name) > 0);		Assert (kind != NULL);		initTagEntry (&e, vStringValue (name));		e.kind     = kind->letter;		e.kindName = kind->name;		makeTagEntry (&e);	}}

static void parseType (tokenInfo *const token){    boolean bitType;    Assert (isType (token, TOKEN_IDENTIFIER));#ifdef TYPE_REFERENCE_TOOL    reportType (token);#endif    bitType = (boolean)(strcmp ("BIT", vStringValue (token->string)) == 0);    readToken (token);    if (bitType && isType (token, TOKEN_NUMERIC))	readToken (token);    else if (isType (token, TOKEN_OPEN_BRACKET))	parseGeneric (token, FALSE);}

/* `end' points to the equal sign.  Parse from right to left to get the * identifier.  Assume we're dealing with something of form /s*/w+/s*=> */static void makeTagFromLeftSide (const char *begin, const char *end,	vString *name, vString *package){	tagEntryInfo entry;	const char *b, *e;	if (! PerlKinds[K_CONSTANT].enabled)		return;	for (e = end - 1; e > begin && isspace(*e); --e)		;	if (e < begin)		return;	for (b = e; b >= begin && isIdentifier(*b); --b)		;	/* Identifier must be either beginning of line of have some whitespace	 * on its left:	 */	if (b < begin || isspace(*b) || ',' == *b)		++b;	else if (b != begin)		return;	Assert(e - b + 1 > 0);	vStringClear(name);	vStringNCatS(name, b, e - b + 1);	initTagEntry(&entry, vStringValue(name));	entry.kind = PerlKinds[K_CONSTANT].letter;	entry.kindName = PerlKinds[K_CONSTANT].name;	makeTagEntry(&entry);	if (Option.include.qualifiedTags && package && vStringLength(package)) {		vStringClear(name);		vStringCopy(name, package);		vStringNCatS(name, b, e - b + 1);		initTagEntry(&entry, vStringValue(name));		entry.kind = PerlKinds[K_CONSTANT].letter;		entry.kindName = PerlKinds[K_CONSTANT].name;		makeTagEntry(&entry);	}}

/** 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;	const char *this_name;	vStringTerminate (name);	scope = stringListToScope (nesting);	/* extract scope and actual name from tag name in case of tags like	 * "class Foo::Bar::Baz" which are parsed as a single name, "Foo.Bar.Baz" */	this_name = strrchr (vStringValue (name), '.');	if (this_name)	{		if (vStringLength (scope) > 0)			vStringPut (scope, '.');		vStringNCat (scope, name, this_name - vStringValue (name));		vStringTerminate (scope);		this_name ++;	}	else		this_name = vStringValue (name);	initTagEntry (&tag, this_name);	if (vStringLength (scope) > 0) {	    tag.extensionFields.scope [0] = "class";	    tag.extensionFields.scope [1] = vStringValue (scope);	}	tag.kindName = RubyKinds [kind].name;	tag.kind = RubyKinds [kind].letter;	makeTagEntry (&tag);	stringListAdd (nesting, vStringNewCopy (name));	vStringClear (name);	vStringDelete (scope);}

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 findVerilogTags (void){	tokenInfo *const token = newToken ();	int c = '/0';	currentContext = newToken ();	while (c != EOF)	{		c = vGetc ();		c = skipWhite (c);		switch (c)		{			/* Store current block name whenever a : is found			 * This is used later by any tag type that requires this information			 * */			case ':':				vStringCopy (currentContext->blockName, token->name);				break;			/* Skip interface modport port declarations */			case '(':				if (currentContext && currentContext->lastKind == K_MODPORT)				{					skipPastMatch ("()");				}				break;			/* Drop context on single statements, which don't have an end			 * statement */			case ';':				if (currentContext->scope && currentContext->scope->singleStat)				{					verbose ("Dropping context %s/n", vStringValue (currentContext->name));					currentContext = popToken (currentContext);					currentContext->singleStat = FALSE;				}				break;			default :				if (isIdentifierCharacter (c))				{					readIdentifier (token, c);					updateKind (token);					findTag (token);				}		}	}	deleteToken (token);	pruneTokens (currentContext);	currentContext = NULL;}

static void makeFunctionTag (const tokenInfo *const token, const vString *const arglist,							 const char *const access){	if (PowerShellKinds[K_FUNCTION].enabled)	{		tagEntryInfo e;		initPowerShellEntry (&e, token, K_FUNCTION, access);		if (arglist)			e.extensionFields.signature = vStringValue (arglist);		makeTagEntry (&e);	}}

static void makeTag (tokenInfo *const token, const goKind kind,	tokenInfo *const parent_token, const goKind parent_kind,	const char *argList){	const char *const name = vStringValue (token->string);	tagEntryInfo e;	initTagEntry (&e, name, &(GoKinds [kind]));	if (!GoKinds [kind].enabled)		return;	e.lineNumber = token->lineNumber;	e.filePosition = token->filePosition;	if (argList)		e.extensionFields.signature = argList;	if (parent_kind != GOTAG_UNDEFINED && parent_token != NULL)	{		e.extensionFields.scopeKind = &(GoKinds[parent_kind]);		e.extensionFields.scopeName = vStringValue (parent_token->string);	}	makeTagEntry (&e);	if (scope && isXtagEnabled(XTAG_QUALIFIED_TAGS))	{		vString *qualifiedName = vStringNew ();		vStringCopy (qualifiedName, scope);		vStringCatS (qualifiedName, ".");		vStringCat (qualifiedName, token->string);		e.name = vStringValue (qualifiedName);		markTagExtraBit (&e, XTAG_QUALIFIED_TAGS);		makeTagEntry (&e);		vStringDelete (qualifiedName);	}}

static void matchCallbackPattern (		const vString* const line, const regexPattern* const patbuf,		const regmatch_t* const pmatch){	regexMatch matches [BACK_REFERENCE_COUNT];	unsigned int count = 0;	int i;	for (i = 0  ;  i < BACK_REFERENCE_COUNT  &&  pmatch [i].rm_so != -1  ;  ++i)	{		matches [i].start  = pmatch [i].rm_so;		matches [i].length = pmatch [i].rm_eo - pmatch [i].rm_so;		++count;	}	patbuf->u.callback.function (vStringValue (line), matches, count);}

static int skipMacro (int c){	tokenInfo *token = newToken ();;	if (c == '`')	{		/* Skip keyword */		if (isIdentifierCharacter (c = vGetc ()))		{			readIdentifier (token, c);			c = vGetc ();			/* Skip next keyword if macro is `ifdef or `ifndef or `elsif*/			if (strcmp (vStringValue (token->name), "ifdef") == 0 ||			    strcmp (vStringValue (token->name), "ifndef") == 0 ||				strcmp (vStringValue (token->name), "elsif") == 0)			{				verbose ("%c/n", c);				c = skipWhite (c);				readIdentifier (token, c);				c = vGetc ();				verbose ("Skipping conditional macro %s/n", vStringValue (token->name));			}			/* Skip macro functions */			else			{				c = skipWhite (c);				if (c == '(')				{					c = skipPastMatch ("()");				}			}		}	}	deleteToken (token);	return c;}

static void makeEiffelLocalTag (tokenInfo *const token){	if (EiffelKinds [EKIND_LOCAL].enabled && isXtagEnabled(XTAG_FILE_SCOPE))	{		const char *const name = vStringValue (token->string);		vString* scope = vStringNew ();		tagEntryInfo e;		initTagEntry (&e, name, &(EiffelKinds [EKIND_LOCAL]));		e.isFileScope = TRUE;		markTagExtraBit (&e, XTAG_FILE_SCOPE);		vStringCopy (scope, token->className);		vStringPut (scope, '.');		vStringCat (scope, token->featureName);		e.extensionFields.scopeKind = &(EiffelKinds [EKIND_FEATURE]);		e.extensionFields.scopeName = vStringValue (scope);		makeTagEntry (&e);		vStringDelete (scope);	}}

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 makeJsonTag (tokenInfo *const token, const jsonKind kind){	tagEntryInfo e;	if (! JsonKinds[kind].enabled)		return;	initTagEntry (&e, vStringValue (token->string));	e.lineNumber	= token->lineNumber;	e.filePosition	= token->filePosition;	e.kindName		= JsonKinds[kind].name;	e.kind			= JsonKinds[kind].letter;	if (vStringLength (token->scope) > 0)	{		Assert (token->scopeKind > TAG_NONE && token->scopeKind < TAG_COUNT);		e.extensionFields.scope[0] = JsonKinds[token->scopeKind].name;		e.extensionFields.scope[1] = vStringValue (token->scope);	}	makeTagEntry (&e);}

static void createPascalTag (tagEntryInfo* const tag,							 const vString* const name, const int kind,							 const char *arglist, const char *vartype){	if (PascalKinds [kind].enabled  &&  name != NULL  &&  vStringLength (name) > 0)	{		initTagEntry (tag, vStringValue (name), &(PascalKinds [kind]));		tag->extensionFields.signature = arglist;		tag->extensionFields.varType = vartype;	}	else		/* TODO: Passing NULL as name makes an assertion behind initTagEntry failure */		initTagEntry (tag, NULL, NULL);}

static int makeNamespaceTag (vString * const name, const char *dbp){	functionName (name, dbp);	if (vStringLength (name) > 0 && ClojureKinds[K_NAMESPACE].enabled)	{		tagEntryInfo e;		initTagEntry (&e, vStringValue (name), &(ClojureKinds[K_NAMESPACE]));		e.lineNumber = getInputLineNumber ();		e.filePosition = getInputFilePosition ();		return makeTagEntry (&e);	}	else		return CORK_NIL;}

/*  The name of the language interpreter, either directly or as the argument *  to "env". */static vString* determineInterpreter (const char* const cmd){	vString* const interpreter = vStringNew ();	const char* p = cmd;	do	{		vStringClear (interpreter);		for ( ;  isspace ((int) *p)  ;  ++p)			;  /* no-op */		for ( ;  *p != '/0'  &&  ! isspace ((int) *p)  ;  ++p)			vStringPut (interpreter, (int) *p);		vStringTerminate (interpreter);	} while (strcmp (vStringValue (interpreter), "env") == 0);	return interpreter;}

static void plistFindTagsUnderKey (xmlNode *node,				   const struct sTagXpathRecurSpec *spec,				   xmlXPathContext *ctx,				   void *userData){	xmlNode *current;	xmlNode *prev;	stringList *queue;	vString* path;	vString* v;	int c;	queue = stringListNew ();	current = node;	for (current = node; current; current = current->parent)	{		if (isCompoundElement (current)		    && (prev = getPrevKeyElement (current)))		{			char* parent = (char *)xmlNodeGetContent (prev);			if (parent)			{				v = vStringNewInit (parent);				stringListAdd (queue, v);				xmlFree (parent);			}		}	}	path = vStringNew ();	while ((c = stringListCount (queue)) > 0)	{		v = stringListLast (queue);		vStringCat (path, v);		vStringDelete (v);		stringListRemoveLast (queue);		if (c != 1)			vStringPut (path, '.');	}	stringListDelete (queue);	findXMLTags (ctx, node,		     plistXpathTableTable + TABLE_TEXT,		     PlistKinds,		     (vStringLength (path) > 0)? vStringValue (path): NULL);	vStringDelete (path);}

static int parseEscapedCharacter (void){	int d = '/0';	int c = getcFromInputFile ();	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;		case 'Q':  d = '`';   break;		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 = getcFromInputFile ();			if (c == '/'  &&  ascii < 256)				d = ascii;			break;		}		default: break;	}	return d;}

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 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 void makeConstTag (tokenInfo *const token, const texKind kind){    if (TexKinds [kind].enabled )    {        const char *const name = vStringValue (token->string);        tagEntryInfo e;        initTagEntry (&e, name);        e.lineNumber   = token->lineNumber;        e.filePosition = token->filePosition;        e.kindName     = TexKinds [kind].name;        e.kind         = TexKinds [kind].letter;        makeTagEntry (&e);    }}

static void parsePreproc (vString * const ident, objcToken what){	switch (what)	{	case ObjcIDENTIFIER:		if (strcmp (vStringValue (ident), "define") == 0)			toDoNext = &parseMacroName;		else			toDoNext = &ignorePreprocStuff;		break;	default:		toDoNext = &ignorePreprocStuff;		break;	}}

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 int makeRegexTag (		const vString* const name, const kindOption* const kind, int scopeIndex, int placeholder){	if (kind->enabled)	{		tagEntryInfo e;		Assert (name != NULL  &&  ((vStringLength (name) > 0) || placeholder));		Assert (kind != NULL);		initTagEntry (&e, vStringValue (name), kind);		e.extensionFields.scopeIndex = scopeIndex;		e.placeholder = !!placeholder;		return makeTagEntry (&e);	}	else		return SCOPE_NIL;}

static void createPascalTag (tagEntryInfo* const tag,			     const vString* const name, const int kind,			     const char *arglist, const char *vartype){    if (PascalKinds [kind].enabled  &&  name != NULL  &&  vStringLength (name) > 0)    {        initTagEntry (tag, vStringValue (name));        tag->kindName = PascalKinds [kind].name;        tag->kind     = PascalKinds [kind].letter;        tag->extensionFields.arglist = arglist;        tag->extensionFields.varType = vartype;    }    else        initTagEntry (tag, NULL);}

static bool newIdentifierAsHeadOfMemberNotify (struct sCxxSubparser *pSubparser,											   CXXToken *pToken){	struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser *)pSubparser;	keywordId keyword = lookupKeyword (vStringValue (pToken->pszWord), Lang_QtMoc);	if (keyword == KEYWORD_QOBJECT)	{		if (pQtMoc->iDepthOfQtClass == 0)			pQtMoc->iDepthOfQtClass = pQtMoc->iBlockDepth;		CXX_DEBUG_PRINT("Found /"Q_OBJECT/" Qt Object Marker in depth: %d",						pQtMoc->iDepthOfQtClass);		return true;	}	return false;}

static void makeEiffelClassTag (tokenInfo *const token){    if (EiffelKinds [EKIND_CLASS].enabled)    {        const char *const name = vStringValue (token->string);        tagEntryInfo e;        initTagEntry (&e, name);        e.kindName = EiffelKinds [EKIND_CLASS].name;        e.kind     = EiffelKinds [EKIND_CLASS].letter;        makeTagEntry (&e);    }    vStringCopy (token->className, token->string);}

/* Given a string with the contents of a line directly after the "def" keyword, * extract all relevant information and create a tag. */static void makeFunctionTag (vString *const function,	vString *const parent, int is_class_parent, const char *arglist){	tagEntryInfo tag;	initTagEntry (&tag, vStringValue (function));	tag.kindName = PythonKinds[K_FUNCTION].name;	tag.kind = PythonKinds[K_FUNCTION].letter;	tag.extensionFields.arglist = arglist;	/* add argument list of __init__() methods to the class tag */	if (strcmp (vStringValue (function), "__init__") == 0 && parent != NULL)	{		const char *parent_tag_name = get_class_name_from_parent (vStringValue (parent));		if (parent_tag_name != NULL)			setTagArglistByName (parent_tag_name, arglist);	}	if (vStringLength (parent) > 0)	{		if (is_class_parent)		{			tag.kindName = PythonKinds[K_METHOD].name;			tag.kind = PythonKinds[K_METHOD].letter;			tag.extensionFields.scope [0] = "class";			tag.extensionFields.scope [1] = vStringValue (parent);		}		else		{			tag.extensionFields.scope [0] = "function";			tag.extensionFields.scope [1] = vStringValue (parent);		}	}	/* If a function starts with __, we mark it as file scope.	 * FIXME: What is the proper way to signal such attributes?	 * TODO: What does functions/classes starting with _ and __ mean in python?	 */	if (strncmp (vStringValue (function), "__", 2) == 0 &&		strcmp (vStringValue (function), "__init__") != 0)	{		tag.extensionFields.access = "private";		tag.isFileScope = TRUE;	}	else	{		tag.extensionFields.access = "public";	}	makeTagEntry (&tag);}