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

/* Ensure a constructor is not a type path beginning * with a module */static void constructorValidation (vString * const ident, ocaToken what){	switch (what)	{	case Tok_Op:	/* if we got a '.' which is an operator */		toDoNext = &globalScope;		popStrongContext ();		needStrongPoping = FALSE;		break;	case OcaKEYWORD_of:	/* OK, it must be a constructor :) */		makeTagEntry (&tempTag);		vStringClear (tempIdent);		toDoNext = &tillTokenOrFallback;		comeAfter = &typeSpecification;		waitedToken = Tok_Pipe;		break;	case Tok_Pipe:	/* OK, it was a constructor :)  */		makeTagEntry (&tempTag);		vStringClear (tempIdent);		toDoNext = &typeSpecification;		break;	default:	/* and mean that we're not facing a module name */		makeTagEntry (&tempTag);		vStringClear (tempIdent);		toDoNext = &tillTokenOrFallback;		comeAfter = &typeSpecification;		waitedToken = Tok_Pipe;		/* nothing in the context, discard it */		popStrongContext ();		/* to be sure we use this token */		globalScope (ident, what);	}}

/* Double-quoted strings, we only care about the /" escape. These * last past the end of the line, so be careful not too store too much * of them (see MAX_STRING_LENGTH). The only place we look at their * contents is in the function definitions, and there the valid strings are * things like "C" and "Rust" */static void scanString (lexerState *lexer){	vStringClear(lexer->token_str);	advanceChar(lexer);	while (lexer->cur_c != EOF && lexer->cur_c != '"')	{		if (lexer->cur_c == '//' && lexer->next_c == '"')			advanceChar(lexer);		if (vStringLength(lexer->token_str) < MAX_STRING_LENGTH)			vStringPut(lexer->token_str, (char) lexer->cur_c);		advanceChar(lexer);	}	advanceChar(lexer);}

static const unsigned char *makeTclTag (		const unsigned char *cp,		vString *const name,		const tclKind kind){	vStringClear (name);	while ((int) *cp != '/0'  &&  ! isspace ((int) *cp))	{		vStringPut (name, (int) *cp);		++cp;	}	makeSimpleTag (name, TclKinds, kind);	return cp;}

static void popScope (tokenInfo *const token,					  const tokenInfo *const parent){	char *dot = strrchr (token->scope->buffer, '.');	if (! dot)		vStringClear (token->scope);	else	{		*dot = 0;		token->scope->length = dot - token->scope->buffer;	}	token->scopeKind = parent->scopeKind;}

static bool readIdentifier (vString *const name, int c){	vStringClear (name);	if (isIdentifierCharacter (c))	{		while (isIdentifierCharacter (c))		{			vStringPut (name, c);			c = vGetc ();		}		vUngetc (c);	}	return (bool)(name->length > 0);}

static const unsigned char *readOperator (    const unsigned char *const start,    vString *const operator){    const unsigned char *cp = start;    vStringClear (operator);    while (*cp != '/0'  &&  ! isspace ((int) *cp))    {        vStringPut (operator, *cp);        ++cp;    }    vStringTerminate (operator);    return cp;}

/* parse object ... * used to be sure the class definition is not a type * alias */static void classSpecif (vString * const UNUSED (ident), ocaToken what){	switch (what)	{	case OcaKEYWORD_object:		pushStrongContext (lastClass, ContextClass);		toDoNext = &globalScope;		break;	default:		vStringClear (lastClass);		toDoNext = &globalScope;	}}

/* `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);	}}

/* Raw strings look like this: r"" or r##""## where the number of * hashes must match */static void scanRawString (lexerState *lexer){	size_t num_initial_hashes = 0;	vStringClear(lexer->token_str);	advanceChar(lexer);	/* Count how many leading hashes there are */	while (lexer->cur_c == '#')	{		num_initial_hashes++;		advanceChar(lexer);	}	if (lexer->cur_c != '"')		return;	advanceChar(lexer);	while (lexer->cur_c != EOF)	{		if (vStringLength(lexer->token_str) < MAX_STRING_LENGTH)			vStringPut(lexer->token_str, (char) lexer->cur_c);		/* Count how many trailing hashes there are. If the number is equal or more		 * than the number of leading hashes, break. */		if (lexer->cur_c == '"')		{			size_t num_trailing_hashes = 0;			advanceChar(lexer);			while (lexer->cur_c == '#' && num_trailing_hashes < num_initial_hashes)			{				num_trailing_hashes++;				if (vStringLength(lexer->token_str) < MAX_STRING_LENGTH)					vStringPut(lexer->token_str, (char) lexer->cur_c);				advanceChar(lexer);			}			if (num_trailing_hashes == num_initial_hashes)			{				/* Strip the trailing hashes and quotes */				if (vStringLength(lexer->token_str) < MAX_STRING_LENGTH && vStringLength(lexer->token_str) > num_trailing_hashes + 1)				{					lexer->token_str->length = vStringLength(lexer->token_str) - num_trailing_hashes - 1;					lexer->token_str->buffer[lexer->token_str->length] = '/0';				}				break;			}		}		else		{			advanceChar(lexer);		}	}}

static void findJavaPropertiesTags (void){	const unsigned char *line;	bool in_value = false;	bool value_continues;	static vString *key;	if (key == NULL)		key = vStringNew ();	else		vStringClear (key);	while ((line = readLineFromInputFile ()) != NULL)	{		if (in_value)		{			value_continues = doesValueContinue (line);			if (!value_continues)				in_value = false;			continue;		}		line = skipWhiteSpace (line);		if (*line == '/0'		    || *line == '!' || *line == '#')			continue;		line = extractKey (line, key);		makeSimpleTag (key, K_KEY);		vStringClear (key);		value_continues = doesValueContinue (line);		if (value_continues)			in_value = true;	}}

/*  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;}

/* read the @something directives */static void readIdentifierObjcDirective (lexingState * st){	const unsigned char *p;	vStringClear (st->name);	/* first char is a simple letter */	if (*st->cp == '@')		vStringPut (st->name, (int) *st->cp);	/* Go till you get identifier chars */	for (p = st->cp + 1; isIdent (*p); p++)		vStringPut (st->name, (int) *p);	st->cp = p;}

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 bool readIdentifier (tokenInfo *const token, int c){	vStringClear (token->name);	if (isIdentifierCharacter (c))	{		while (isIdentifierCharacter (c))		{			vStringPut (token->name, c);			c = vGetc ();		}		vUngetc (c);		token->lineNumber = getInputLineNumber ();		token->filePosition = getInputFilePosition ();	}	return (bool)(vStringLength (token->name) > 0);}

static const unsigned char *readSymbol (		const unsigned char *const start,		vString *const sym){	const unsigned char *cp = start;	vStringClear (sym);	if (isInitialSymbolCharacter ((int) *cp))	{		while (isSymbolCharacter ((int) *cp))		{			vStringPut (sym, *cp);			++cp;		}	}	return cp;}

/* Parse type of kind * type bidule = Ctor1 of ... *             | Ctor2 *             | Ctor3 of ... * or * type bidule = | Ctor1 of ... | Ctor2 * * when type bidule = { ... } is detected, * let typeRecord handle it. */static void typeSpecification (vString * const ident, ocaToken what){	switch (what)	{	case OcaIDENTIFIER:		if (isUpperAlpha (ident->buffer[0]))		{			/* here we handle type aliases of type			 * type foo = AnotherModule.bar			 * AnotherModule can mistakenly be took			 * for a constructor. */			if (! OcamlKinds[K_CONSTRUCTOR].enabled)				vStringClear (tempIdent);			else			{				vStringCopy (tempIdent, ident);				prepareTag (&tempTag, tempIdent, K_CONSTRUCTOR);			}			toDoNext = &constructorValidation;		}		else		{			toDoNext = &tillTokenOrFallback;			comeAfter = &typeSpecification;			waitedToken = Tok_Pipe;		}		break;	case OcaKEYWORD_and:		toDoNext = &typeDecl;		break;	case Tok_BRL:	/* the '[' & ']' are ignored to accommodate */	case Tok_BRR:	/* with the revised syntax */	case Tok_Pipe:		/* just ignore it */		break;	case Tok_CurlL:		toDoNext = &typeRecord;		break;	default:	/* don't care */		break;	}}

static void readIdentifier (lexingState * st){	const unsigned char *p;	vStringClear (st->name);	/* first char is a simple letter */	if (isAlpha (*st->cp) || *st->cp == '_')		vStringPut (st->name, (int) *st->cp);	/* Go till you get identifier chars */	for (p = st->cp + 1; isIdent (*p); p++)		vStringPut (st->name, (int) *p);	st->cp = p;	vStringTerminate (st->name);}

static void initPhpEntry (tagEntryInfo *const e, const tokenInfo *const token,						  const phpKind kind, const accessType access){	int parentKind = -1;	vStringClear (FullScope);	if (vStringLength (CurrentNamesapce) > 0)	{		parentKind = K_NAMESPACE;		vStringCat (FullScope, CurrentNamesapce);	}	initTagEntry (e, vStringValue (token->string), kind);	e->lineNumber	= token->lineNumber;	e->filePosition	= token->filePosition;	if (access != ACCESS_UNDEFINED)		e->extensionFields.access = accessToString (access);	if (vStringLength (token->scope) > 0)	{		parentKind = token->parentKind;		if (vStringLength (FullScope) > 0)		{			const char* sep;			sep = phpScopeSeparatorFor (parentKind,						    K_NAMESPACE);			vStringCatS (FullScope, sep);		}			vStringCat (FullScope, token->scope);	}	if (vStringLength (FullScope) > 0)	{		Assert (parentKind >= 0);		e->extensionFields.scopeKindIndex = parentKind;		e->extensionFields.scopeName = vStringValue (FullScope);	}	if (token->anonymous)		markTagExtraBit (e, XTAG_ANONYMOUS);}

/* Used at the beginning of a new scope (begin of a * definition, parenthesis...) to catch inner let * definition that may be in. */static void mayRedeclare (vString * const ident, ocaToken what){	switch (what)	{    case OcaKEYWORD_value:        /* let globalScope handle it */        globalScope (ident, what);        break;	case OcaKEYWORD_let:	case OcaKEYWORD_val:		toDoNext = localLet;		break;	case OcaKEYWORD_object:		vStringClear (lastClass);		pushContext (ContextStrong, ContextClass,			&localScope, NULL /*voidName */ );		needStrongPoping = FALSE;		toDoNext = &globalScope;		break;	case OcaKEYWORD_for:	case OcaKEYWORD_while:		toDoNext = &tillToken;		waitedToken = OcaKEYWORD_do;		comeAfter = &mayRedeclare;		break;	case OcaKEYWORD_try:		toDoNext = &mayRedeclare;		pushSoftContext (matchPattern, ident, ContextFunction);		break;	case OcaKEYWORD_fun:		toDoNext = &matchPattern;		break;		/* Handle the special ;; from the OCaml		 * Top level */	case Tok_semi:	default:		toDoNext = &localScope;		localScope (ident, what);	}}

static void readIdentifier (const int first, vString *const id){    int depth = 0;    int c = first;    vStringClear (id);    while (isIdentifier (c) || (depth > 0 && c != EOF && c != '/n'))    {        if (c == '(' || c == '}')            depth++;        else if (depth > 0 && (c == ')' || c == '}'))            depth--;        vStringPut (id, c);        c = nextChar ();    }    ungetcToInputFile (c);    vStringTerminate (id);}

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);}

/* unroll the stack until the last named context. * then discard it. Used to handle the : * let f x y = ... * in ... * where the context is reseted after the in. Context may have * been really nested before that. */static void popLastNamed ( void ){	int i = getLastNamedIndex ();	if (i >= 0)	{		stackIndex = i;		toDoNext = stack[i].callback;		vStringClear (stack[i].contextName);	}	else	{		/* ok, no named context found... 		 * (should not happen). */		stackIndex = 0;		toDoNext = &globalScope;	}}

static void makeNamespaceTag (vString * const name, const unsigned char *dbp){	vStringClear (CurrentNamespace);	functionName (name, dbp);	vStringCopy (CurrentNamespace, name);	if (vStringLength (CurrentNamespace) > 0)	{		tagEntryInfo e;		initTagEntry (&e, vStringValue (CurrentNamespace));		e.lineNumber = getSourceLineNumber ();		e.filePosition = getInputFilePosition ();		e.kindName = ClojureKinds[K_NAMESPACE].name;		e.kind = (char) ClojureKinds[K_NAMESPACE].letter;		makeTagEntry (&e);	}}

/* TODO: parse overlining & underlining as distinct sections. */static void findRstTags (void){    vString *name = vStringNew ();    fpos_t filepos;    const unsigned char *line;    memset(&filepos, 0, sizeof(fpos_t));    memset(kindchars, 0, sizeof kindchars);    nestingLevels = nestingLevelsNew();    while ((line = readLineFromInputFile ()) != NULL)    {        int line_len = strlen((const char*) line);        int name_len_bytes = vStringLength(name);        int name_len = utf8_strlen(vStringValue(name), name_len_bytes);        /* if the name doesn't look like UTF-8, assume one-byte charset */        if (name_len < 0)            name_len = name_len_bytes;        /* underlines must be the same length or more */        if (line_len >= name_len && name_len > 0 &&                ispunct(line[0]) && issame((const char*) line))        {            char c = line[0];            int kind = get_kind(c);            if (kind >= 0)            {                makeRstTag(name, kind, filepos);                continue;            }        }        vStringClear (name);        if (!isspace(*line))        {            vStringCatS(name, (const char*)line);            filepos = getInputFilePosition();        }        vStringTerminate(name);    }    vStringDelete (name);    nestingLevelsFree(nestingLevels);}

/* Reset everything until the last global space. * a strong context can be : * - module * - class definition * - the initial global space * - a _global_ delcaration (let at global scope or in a module). * Created to exit quickly deeply nested context */static contextType popStrongContext ( void ){	int i;	for (i = stackIndex - 1; i >= 0; --i)	{		if (stack[i].kind == ContextStrong)		{			stackIndex = i;			toDoNext = stack[i].callback;			vStringClear (stack[i].contextName);			return stack[i].type;		}	}	/* ok, no strong context found... */	stackIndex = 0;	toDoNext = &globalScope;	return -1;}

static void L_getit (vString *const name, const unsigned char *dbp){	const unsigned char *p;	if (*dbp == '/'')  /* Skip prefix quote */		dbp++;	else if (*dbp == '(' && L_isquote (dbp))  /* Skip "(quote " */	{		dbp += 7;		while (isspace (*dbp))		dbp++;	}	for (p=dbp ; *p!='/0' && *p!='(' && !isspace ((int) *p) && *p!=')' ; p++)		vStringPut (name, *p);	if (vStringLength (name) > 0)		makeSimpleTag (name, LispKinds, K_FUNCTION);	vStringClear (name);}

/* Essentially grabs the last ident before 'for', '<' and '{', which * tends to correspond to what we want as the impl tag entry name */static void parseQualifiedType (lexerState *lexer, vString* name){	while (lexer->cur_token != TOKEN_EOF)	{		if (lexer->cur_token == TOKEN_IDENT)		{			if (strcmp(lexer->token_str->buffer, "for") == 0)				break;			vStringClear(name);			vStringCat(name, lexer->token_str);		}		else if (lexer->cur_token == '<' || lexer->cur_token == '{')		{			break;		}		advanceToken(lexer, TRUE);	}	skipTypeBlock(lexer);}

static void parseStructMembers (vString * const ident, objcToken what){	static parseNext prev = NULL;	if (prev != NULL)	{		comeAfter = prev;		prev = NULL;	}	switch (what)	{	case ObjcIDENTIFIER:		vStringCopy (tempName, ident);		break;	case Tok_semi:	/* ';' */		addTag (tempName, K_FIELD);		vStringClear (tempName);		break;		/* some types are complex, the only one		 * we will loose is the function type.		 */	case Tok_CurlL:	/* '{' */	case Tok_PARL:	/* '(' */	case Tok_SQUAREL:	/* '[' */		toDoNext = &ignoreBalanced;		prev = comeAfter;		comeAfter = &parseStructMembers;		ignoreBalanced (ident, what);		break;	case Tok_CurlR:		toDoNext = comeAfter;		break;	default:		/* don't care */		break;	}}

extern boolean convertString (vString *const string){	size_t dest_len, src_len;	char *dest, *dest_ptr, *src;	if (iconv_fd == (iconv_t) -1)		return FALSE;	src_len = vStringLength (string);	/* Should be longest length of bytes. so maybe utf8. */	dest_len = src_len * 4;	dest_ptr = dest = xCalloc (dest_len, char);	if (!dest)		return FALSE;	src = vStringValue (string);retry:	if (iconv (iconv_fd, &src, &src_len, &dest_ptr, &dest_len) == (size_t) -1)	{		if (errno == EILSEQ)		{			*dest_ptr++ = '?';			dest_len--;			src++;			src_len--;			verbose ("  Encoding: %s/n", strerror(errno));			goto retry;		}		eFree (dest);		return FALSE;	}	dest_len = dest_ptr - dest;	vStringClear (string);	while (vStringSize (string) <= dest_len + 1)		vStringAutoResize (string);	memcpy (vStringValue (string), dest, dest_len + 1);	vStringLength (string) = dest_len;	eFree (dest);	iconv (iconv_fd, NULL, NULL, NULL, NULL);	return TRUE;}

/** * Reads from 'start' to 'end' and eliminates all spaces * inbetween. */static char *readBetweenDelimitersWhileTrimmingSpaces(char start, char end) {  static vString *wordBuffer = 0;  int z;  if (!wordBuffer)    wordBuffer = vStringNew();  else    vStringClear(wordBuffer);  z = skipToNonWhite();  if (z != start) return NULL;  while ((z = cppGetc()) != EOF && z != end) {    if (isspace(z)) continue;    vStringPut(wordBuffer, z);  }  if (z == EOF) return NULL;  vStringPut(wordBuffer, z);  vStringPut(wordBuffer, 0);  return vStringValue(wordBuffer);}