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

static String typeString(const CXType &type){    const char *builtIn = builtinTypeName(type.kind);    if (builtIn)        return builtIn;    if (char pointer = (type.kind == CXType_Pointer ? '*' : (type.kind == CXType_LValueReference ? '&' : 0))) {        const CXType pointee = clang_getPointeeType(type);        String ret = typeString(pointee);        if (ret.endsWith('*') || ret.endsWith('&')) {            ret += pointer;        } else {            ret += ' ';            ret += pointer;        }        return ret;    }    if (type.kind == CXType_ConstantArray) {        String arrayType = typeString(clang_getArrayElementType(type));        const long long count = clang_getNumElements(type);        arrayType += '[';        if (count >= 0)            arrayType += String::number(count);        arrayType += ']';        return arrayType;    }    String ret = IndexerJob::typeName(clang_getTypeDeclaration(type));    if (ret.endsWith(' '))        ret.chop(1);    return ret;}

QString QReportBand::header() const{    if(objectName() == "")        return typeString();    else        return typeString() + " - " + objectName();}

String IndexerJob::typeName(const CXCursor &cursor){    String ret;    switch (clang_getCursorKind(cursor)) {    case CXCursor_FunctionTemplate:        // ### If the return value is a template type we get an empty string here    case CXCursor_FunctionDecl:    case CXCursor_CXXMethod:        ret = typeString(clang_getResultType(clang_getCursorType(cursor)));        break;    case CXCursor_ClassTemplate:    case CXCursor_ClassDecl:    case CXCursor_StructDecl:    case CXCursor_UnionDecl:        ret = RTags::eatString(clang_getCursorSpelling(cursor));        break;    case CXCursor_FieldDecl:        // ### If the return value is a template type we get an empty string here    case CXCursor_VarDecl:    case CXCursor_ParmDecl:        ret = typeString(clang_getCursorType(cursor));        break;    default:        return String();    }    if (!ret.isEmpty() && !ret.endsWith('*') && !ret.endsWith('&'))        ret.append(' ');    return ret;}

void KviWindow::savePropertiesAsDefault(){	QString szGroup;	getConfigGroupName(szGroup);	// save also the settings for THIS specialized window	if(!KviQString::equalCI(szGroup, typeString()))		g_pMainWindow->saveWindowProperties(this, szGroup);	g_pMainWindow->saveWindowProperties(this, typeString());}

void Interpreter::outputTokenData(const std::string & instruction){    const Instruction & i = Lexer::tokenize(instruction, machine);    std::cout << (i.label.isNull() ? "" : typeString(i.label.type) + " ")              << typeString(i.opcode.type) << " "              << (i.operand1.isPointer ? "@" : "") + typeString(i.operand1.type) << " "              << (i.operand2.isPointer ? "@" : "") + typeString(i.operand2.type) << std::endl              << (i.label.isNull() ? "" : valueString(i.label) + " ")              << valueString(i.opcode) << " "              << valueString(i.operand1) << " "              << valueString(i.operand2) << std::endl;}

  void runTest() {    try {      parser_.parse(0, input_);    } catch (falcon::Exception& e) {      setErrorMessage("parsing error: " + e.getErrorMessage());      setSuccess(e.getCode() == errorCodeExpected_);      return;    }    falcon::JsonVal* dom = parser_.getDom();    if (!dom) {      if (key_ == "") {        if (errorCodeExpected_ != 0) {          setErrorMessage("wrong error code");        }        setSuccess(errorCodeExpected_ == 0);      } else {        setErrorMessage("parsing error: not a valide JSon");        setSuccess(errorCodeExpected_ == EINVAL);      }      return;    }    falcon::JsonVal* obj = (falcon::JsonVal*)dom->getObject(key_);    if (!obj) {      if (key_ == "") {        if (errorCodeExpected_ != 0) {          setErrorMessage("wrong error code");        }        setSuccess(errorCodeExpected_ == 0);      } else {        setErrorMessage("object not found: " + key_);        setSuccess(false);      }      return;    }    if (obj->_type != type_) {      setErrorMessage("object type error: expected(" + typeString(type_)                      + ") found(" + typeString(obj->_type) + ")");      setSuccess(false);      return;    }    if (obj->_data == data_) {      setSuccess(errorCodeExpected_ == 0);    } else {      setErrorMessage("object do not have the same value: expected("                      + data_ + ") found(" + obj->_data + ")");      setSuccess(false);    }  }

// -----------------------------------------------------------------------------// Returns the property value as a bool.// If [warn_wrong_type] is true, a warning message is written to the log if the// property is not of boolean type// -----------------------------------------------------------------------------bool Property::boolValue(bool warn_wrong_type) const{	// If this is a flag, just return boolean 'true' (or equivalent)	if (type_ == Type::Flag)		return true;	// If the value is undefined, default to false	if (!has_value_)		return false;	// Write warning to log if needed	if (warn_wrong_type && type_ != Type::Boolean)		Log::warning("Requested Boolean value of a {} Property", typeString());	// Return value (convert if needed)	if (type_ == Type::Boolean)		return value_.Boolean;	else if (type_ == Type::Int)		return !!value_.Integer;	else if (type_ == Type::UInt)		return !!value_.Unsigned;	else if (type_ == Type::Float)		return !!((int)value_.Floating);	else if (type_ == Type::String)	{		// Anything except "0", "no" or "false" is considered true		return !(val_string_ == '0' || StrUtil::equalCI(val_string_, "no") || StrUtil::equalCI(val_string_, "false"));	}	// Return default boolean value	return true;}

void XMLModelDefinitionSerializer::readActivations(TiXmlElement* activationsNode, ActionDefinition* action){	const char* tmp = 0;	for (TiXmlElement* activationElem = activationsNode->FirstChildElement();            activationElem != 0; activationElem = activationElem->NextSiblingElement())	{		tmp = activationElem->Attribute("type");		if (tmp)		{			std::string typeString(tmp);			ActivationDefinition::Type type;			if (typeString == "movement") {				type = ActivationDefinition::MOVEMENT;			} else if (typeString == "action") {				type = ActivationDefinition::ACTION;			} else if (typeString == "task") {				type = ActivationDefinition::TASK;			} else {				S_LOG_WARNING("No recognized activation type: " << typeString);				continue;			}			std::string trigger = activationElem->GetText();			action->createActivationDefinition(type, trigger);			S_LOG_VERBOSE( "  Add activation: " << typeString << " : " << trigger);		}	}}

nsWindowInfo*nsWindowMediator::MostRecentWindowInfo(const PRUnichar* inType){  PRInt32       lastTimeStamp = -1;  nsAutoString  typeString(inType);  PRBool        allWindows = !inType || typeString.IsEmpty();  // Find the most window with the highest time stamp that matches  // the requested type  nsWindowInfo *searchInfo,               *listEnd,               *foundInfo = nsnull;  searchInfo = mOldestWindow;  listEnd = nsnull;  while (searchInfo != listEnd) {    if ((allWindows || searchInfo->TypeEquals(typeString)) &&        searchInfo->mTimeStamp >= lastTimeStamp) {      foundInfo = searchInfo;      lastTimeStamp = searchInfo->mTimeStamp;    }    searchInfo = searchInfo->mYounger;    listEnd = mOldestWindow;  }  return foundInfo;}

// metadata section starts at offset 0x40 and ends around 0xb0 depending on filenamelengthstatic SymbolsMetadata parseMetadata(RBuffer *buf, int off) {	SymbolsMetadata sm = { 0 };	ut8 b[0x100] = { 0 };	(void)r_buf_read_at (buf, off, b, sizeof (b));	sm.addr = off;	sm.cputype = r_read_le32 (b);	sm.arch = typeString (sm.cputype, &sm.bits);	//  eprintf ("0x%08x  cputype  0x%x -> %s/n", 0x40, sm.cputype, typeString (sm.cputype));	// bits = (strstr (typeString (sm.cputype, &sm.bits), "64"))? 64: 32;	sm.subtype = r_read_le32 (b + 4);	sm.cpu = subtypeString (sm.subtype);	//  eprintf ("0x%08x  subtype  0x%x -> %s/n", 0x44, sm.subtype, subtypeString (sm.subtype));	sm.n_segments = r_read_le32 (b + 8);	// int count = r_read_le32 (b + 0x48);	sm.namelen = r_read_le32 (b + 0xc);	// eprintf ("0x%08x  count    %d/n", 0x48, count);	// eprintf ("0x%08x  strlen   %d/n", 0x4c, sm.namelen);	// eprintf ("0x%08x  filename %s/n", 0x50, b + 16);	int delta = 16;	sm.segments = parseSegments (buf, off + sm.namelen + delta, sm.n_segments);	sm.size = (sm.n_segments * 32) + 120;	// hack to detect format	ut32 nm, nm2, nm3;	r_buf_read_at (buf, off + sm.size, (ut8*)&nm, sizeof (nm));	r_buf_read_at (buf, off + sm.size + 4, (ut8*)&nm2, sizeof (nm2));	r_buf_read_at (buf, off + sm.size + 8, (ut8*)&nm3, sizeof (nm3));	// eprintf ("0x%x next %x %x %x/n", off + sm.size, nm, nm2, nm3);	if (r_read_le32 (&nm3) != 0xa1b22b1a) {		sm.size -= 8;		//		is64 = true;	}	return sm;}

LPXLFOPER EXCEL_EXPORTxltypeString(LPXLFOPER inputa){EXCEL_BEGIN;	if (XlfExcel::Instance().IsCalledByFuncWiz())		return XlfOper(true);XlfOper input(	(inputa)); double t = (clock()+0.0)/CLOCKS_PER_SEC;std::string result(	typeString(		input)	);  t = (clock()+0.0)/CLOCKS_PER_SEC-t;CellMatrix resultCells(result);CellMatrix time(1,2);time(0,0) = "time taken";time(0,1) = t;resultCells.PushBottom(time);return XlfOper(resultCells);EXCEL_END}

/* Property::getUnsignedValue * Returns the property value as an unsigned int. If [warn_wrong_type] * is true, a warning message is written to the log if the property is * not of integer type *******************************************************************/unsigned Property::getUnsignedValue(bool warn_wrong_type) {	// If this is a flag, just return boolean 'true' (or equivalent)	if (type == PROP_FLAG)		return 1;	// If the value is undefined, default to 0	if (!has_value)		return 0;	// Write warning to log if needed	if (warn_wrong_type && type != PROP_INT)		wxLogMessage("Warning: Requested Integer value of a %s Property", typeString().c_str());	// Return value (convert if needed)	if (type == PROP_INT)		return value.Integer;	else if (type == PROP_BOOL)		return (int)value.Boolean;	else if (type == PROP_FLOAT)		return (int)value.Floating;	else if (type == PROP_STRING)		return atoi(CHR(val_string));	else if (type == PROP_UINT)		return value.Unsigned;	// Return default integer value	return 0;}

  Tag* Presence::tag() const  {    if( m_subtype == Invalid )      return 0;    Tag* t = new Tag( "presence" );    if( m_to )      t->addAttribute( "to", m_to.full() );    if( m_from )      t->addAttribute( "from", m_from.full() );    const std::string& type = typeString( m_subtype );    if( !type.empty() )    {      if( type != "available" )        t->addAttribute( "type", type );    }    else    {      const std::string& show = showString( m_subtype );      if( !show.empty() )        new Tag( t, "show", show );    }    new Tag( t, "priority", util::int2string( m_priority ) );    getLangs( m_stati, m_status, "status", t );    StanzaExtensionList::const_iterator it = m_extensionList.begin();    for( ; it != m_extensionList.end(); ++it )      t->addChild( (*it)->tag() );    return t;  }

  Tag* Message::tag() const  {    if( m_subtype == Invalid )      return 0;    Tag* t = new Tag( "message" );    if( m_to )      t->addAttribute( "to", m_to.full() );    if( m_from )      t->addAttribute( "from", m_from.full() );	if( !m_id.empty() )		t->addAttribute( "id", m_id );	if( !m_timestamp.empty() )		t->addAttribute( "timestamp", m_timestamp );    t->addAttribute( TYPE, typeString( m_subtype ) );    getLangs( m_bodies, m_body, "body", t );	getLangs( m_subjects, m_subject, "subject", t );	getLangs( m_htmls, m_html, "html", t );    if( !m_thread.empty() )      new Tag( t, "thread", m_thread );    StanzaExtensionList::const_iterator it = m_extensionList.begin();    for( ; it != m_extensionList.end(); ++it )      t->addChild( (*it)->tag() );    return t;  }

int32 Model::SupportsMimeType(const char *type, const BObjectList<BString> *list,	bool exactReason) const{	ASSERT((type == 0) != (list == 0));		// pass in one or the other	int32 result = kDoesNotSupportType;			BFile file(EntryRef(), O_RDONLY);	BAppFileInfo handlerInfo(&file);	BMessage message;	if (handlerInfo.GetSupportedTypes(&message) != B_OK) 		return kDoesNotSupportType;	for (int32 index = 0; ; index++) {		// check if this model lists the type of dropped document as supported		const char *mimeSignature;		int32 bufferLength;		if (message.FindData("types", 'CSTR', index, (const void **)&mimeSignature,			&bufferLength)) 			return result;		if (IsSuperHandlerSignature(mimeSignature)) {			if (!exactReason) 				return kSuperhandlerModel;			if (result == kDoesNotSupportType) 				result = kSuperhandlerModel;		}				int32 match;		if (type) {			BString typeString(type);			match = MatchMimeTypeString(&typeString, mimeSignature);		} else			match = WhileEachListItem(const_cast<BObjectList<BString> *>(list),				MatchMimeTypeString, mimeSignature);				// const_cast shouldnt be here, have to have it until MW cleans up				if (match == kMatch) 			// supports the actual type, it can't get any better			return kModelSupportsType;		else if (match == kMatchSupertype) {			if (!exactReason) 				return kModelSupportsSupertype;			// we already know this model supports the file as a supertype,			// now find out if it matches the type			result = kModelSupportsSupertype;		}	}	return result;}

void Chaser::saveToFile(QFile &file){  QString s;  QString t;  // Comment line  s = QString("# Function entry/n");  file.writeBlock((const char*) s, s.length());  // Entry type  s = QString("Entry = Function") + QString("/n");  file.writeBlock((const char*) s, s.length());  // Name  s = QString("Name = ") + name() + QString("/n");  file.writeBlock((const char*) s, s.length());  // Type  s = QString("Type = ") + typeString() + QString("/n");  file.writeBlock((const char*) s, s.length());  // Device class, device name or "Global"  if (deviceClass() != NULL)    {      // For device class chasers we need to save only the steps because      // all scenes are inside the device class      for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())	{	  s = QString("Function = ") + step->feederFunction->name() + QString("/n");	  file.writeBlock((const char*) s, s.length());	}    }  else if (device() != NULL)    {      // For device chasers (that are saved in the workspace file)      // write also the device name that this chaser is attached to      s = QString("Device = ") + device()->name() + QString("/n");      file.writeBlock((const char*) s, s.length());      for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())	{	  s = QString("Function = ") + step->feederFunction->name() + QString("/n");	  file.writeBlock((const char*) s, s.length());	}    }  else    {      // For global chasers, write device+scene pairs      for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())	{	  // Global chasers need a device+scene pair	  s = QString("Device = ") + step->callerDevice->name() + QString("/n");	  file.writeBlock((const char*) s, s.length());	  	  s = QString("Function = ") + step->feederFunction->name() + QString("/n");	  file.writeBlock((const char*) s, s.length());	}    }}

QString Field::typeFromVariantCode() const{	int type = mType;	if( type == Interval ) return "qvariant_cast<Interval>(%1)";	if( type == Float ) type = Double;	if( type == Image || type == Color ) return "%1.value<" + typeString() + ">()";	return QString("%1.to") + variantTypeStrings[type] + "()";}

 Json::Value toJson() const {     Json::Value json;     json["name"] = name();     json["type"] = typeString();     json["size"] = static_cast<Json::UInt64>(size());     return json; }

void Scene::saveToFile(QFile &file){  QString s;  QString t;  // Comment line  s = QString("# Function entry/n");  file.writeBlock((const char*) s, s.length());  // Entry type  s = QString("Entry = Function") + QString("/n");  file.writeBlock((const char*) s, s.length());  // Name  s = QString("Name = ") + name() + QString("/n");  file.writeBlock((const char*) s, s.length());  // Type  s = QString("Type = ") + typeString() + QString("/n");  file.writeBlock((const char*) s, s.length());  // Device class, device name or "Global"  if (deviceClass() != NULL)    {      // Write only the data for device class scenes      for (unsigned i = 1; i < deviceClass()->m_channels.count(); i++)	{	  t.setNum(i);	  s = t + QString(" = ");	  t.setNum(m_values[i]);	  s += t + QString("/n");	  file.writeBlock((const char*) s, s.length());	}    }  else if (device() != NULL)    {      // For device scenes (that are saved in the workspace file)      // write also the device name that this scene is attached to      s = QString("Device = ") + device()->name() + QString("/n");      file.writeBlock((const char*) s, s.length());      // Data      for (unsigned i = 1; i < device()->deviceClass()->m_channels.count(); i++)	{	  t.setNum(i);	  s = t + QString(" = ");	  t.setNum(m_values[i]);	  s += t + QString("/n");	  file.writeBlock((const char*) s, s.length());	}    }  else    {      // For global scenes the device name is "Global"      s = QString("Device = Global") + QString("/n");      file.writeBlock((const char*) s, s.length());    }}

// Convertsa Type to a stringvalue caml_typeString(value t){  CAMLparam1(t);  CAMLlocal1(r);  r = caml_copy_string(typeString(Type_val(t)));  CAMLreturn(r);}

bool PhpConst::parseType(const folly::dynamic& cns) {  auto it = cns.find("type");  if (it != cns.items().end()) {    m_kindOf = kindOfFromDynamic(it->second);    m_cppType = typeString(it->second, false);    return true;  }  return false;}

bool alAuditData(unsigned typeLen, char const * type, unsigned msgLen, char const * msg, unsigned dataLen, void const * dataBlock){    StringBuffer typeString(typeLen, type);    typeString.toUpperCase();    StringBuffer msgString(msgLen, msg);    AuditType typeValue = findAuditType(typeString.str());    if(typeValue >= NUM_AUDIT_TYPES)        return false;    return AUDIT(typeValue, msgString.str(), dataLen, dataBlock);}

void KviWindow::getDefaultLogFileName(QString & szBuffer, QDate date, bool bGzip, unsigned int uDatetimeFormat){	QString szLog;	// dynamic log path	QString szDynamicPath = KVI_OPTION_STRING(KviOption_stringLogsDynamicPath).trimmed();	if(!szDynamicPath.isEmpty())	{		KviQString::escapeKvs(&szDynamicPath, KviQString::PermitVariables | KviQString::PermitFunctions);		KviKvsVariant vRet;		if(KviKvsScript::evaluate(szDynamicPath, this, nullptr, &vRet))			vRet.asString(szDynamicPath);	}	g_pApp->getLocalKvircDirectory(szLog, KviApplication::Log, szDynamicPath);	KviQString::ensureLastCharIs(szLog, KVI_PATH_SEPARATOR_CHAR);	//ensure the directory exists	KviFileUtils::makeDir(szLog);	QString szDate;	switch(uDatetimeFormat)	{		case 1:			szDate = date.toString(Qt::ISODate);			break;		case 2:			szDate = date.toString(Qt::SystemLocaleShortDate);			break;		case 0:		default:			szDate = date.toString("yyyy.MM.dd");			break;	}	szDate.replace('_', '-'); // this would confuse the log viewer	KviFileUtils::cleanFileName(szDate);	QString szBase;	getBaseLogFileName(szBase);	KviFileUtils::encodeFileName(szBase);	szBase = szBase.toLower();	szBase.replace("%%2e", "%2e");	QString szTmp;	if(bGzip)		szTmp = "%1_%2_%3.log.gz";	else		szTmp = "%1_%2_%3.log";	szLog.append(QString(szTmp).arg(typeString(), szBase, szDate));	szBuffer = szLog;}

void MultiDimArrayDeclarationAST::generateCode(CodeGenerator& codeGen, GeneratedFunction& func) {	if (mLengthExpressions.size() > 2) {		codeGen.codeGenError("Array creation of dimension larger than 2 is not supported.");	}	auto& typeChecker = codeGen.typeChecker();	int outerLocal = func.newLocal("$local$_outer_" + std::to_string(func.numLocals()), typeChecker.findType(typeString()));	int subArrayLocal = func.newLocal("$local$_sub_" + std::to_string(func.numLocals()), typeChecker.findType("Int"));	//Create the outer array	mLengthExpressions.at(0)->generateCode(codeGen, func);	func.addInstruction("NEWARR " + typeChecker.findType(typeString(mLengthExpressions.size() - 1))->vmType());	func.addInstruction("STLOC " + std::to_string(outerLocal));	int condStart = func.numInstructions();	int condIndex = -1;	//Condition	mLengthExpressions.at(0)->generateCode(codeGen, func);	func.addInstruction("LDLOC " + std::to_string(subArrayLocal));	condIndex = func.numInstructions();	func.addInstruction("BLE");	//Body	func.addInstruction("LDLOC " + std::to_string(outerLocal));	func.addInstruction("LDLOC " + std::to_string(subArrayLocal));	mLengthExpressions.at(1)->generateCode(codeGen, func);	func.addInstruction("NEWARR " + typeChecker.findType(typeString(mLengthExpressions.size() - 2))->vmType());	func.addInstruction("STELEM " + typeChecker.findType(typeString(mLengthExpressions.size() - 1))->vmType());	func.addInstruction("LDLOC " + std::to_string(subArrayLocal));	func.addInstruction("LDINT 1");	func.addInstruction("ADD");	func.addInstruction("STLOC " + std::to_string(subArrayLocal));	func.addInstruction("BR " + std::to_string(condStart));	func.instruction(condIndex) += " " + std::to_string(func.numInstructions());	func.addInstruction("LDLOC " + std::to_string(outerLocal));}