bool inWordSet(int i) { const ECString& w = Pst::fromInt(i); if(wordSet.find(w) == wordSet.end()) return false; return true; }
static bool has_repeats(const Fragments& fragments) { StringSet genomes; BOOST_FOREACH (Fragment* f, fragments) { ASSERT_TRUE(f->seq()); std::string genome = f->seq()->genome(); if (genomes.find(genome) != genomes.end()) { return true; } genomes.insert(genome); }
// Note: static method bool LDModelParser::unsetToken(StringSet &tokens, const char *token) { StringSet::iterator it = tokens.find(token); if (it != tokens.end()) { tokens.erase(it); return true; } return false; }
bool SemanticValidator::nameIsUnique(StringSet set, const std::string name, CdefMessage msgType, const std::string& property) { StringSet::const_iterator got = set.find(name); if (got != set.end()) { CompileMessage error(CompileMessage::type_t::Error, msgType, _callback, "The %s '%s' is used more than once", property.c_str(), name.c_str()); return false; } set.insert(name); return true; }
void PointMatcher<T>::ICPChainBase::loadFromYaml(std::istream& in) { this->cleanup(); YAML::Parser parser(in); YAML::Node doc; parser.GetNextDocument(doc); typedef set<string> StringSet; StringSet usedModuleTypes; // Fix for issue #6: compilation on gcc 4.4.4 //PointMatcher<T> pm; const PointMatcher & pm = PointMatcher::get(); { // NOTE: The logger needs to be initialize first to allow ouput from other contructors boost::mutex::scoped_lock lock(loggerMutex); usedModuleTypes.insert(createModuleFromRegistrar("logger", doc, pm.REG(Logger), logger)); } usedModuleTypes.insert(createModulesFromRegistrar("readingDataPointsFilters", doc, pm.REG(DataPointsFilter), readingDataPointsFilters)); usedModuleTypes.insert(createModulesFromRegistrar("readingStepDataPointsFilters", doc, pm.REG(DataPointsFilter), readingStepDataPointsFilters)); usedModuleTypes.insert(createModulesFromRegistrar("referenceDataPointsFilters", doc, pm.REG(DataPointsFilter), referenceDataPointsFilters)); //usedModuleTypes.insert(createModulesFromRegistrar("transformations", doc, pm.REG(Transformation), transformations)); //usedModuleTypes.insert(createModuleFromRegistrar("matcher", doc, pm.REG(Matcher), matcher)); // don't destroy the already created tree usedModuleTypes.insert(createModulesFromRegistrar("outlierFilters", doc, pm.REG(OutlierFilter), outlierFilters)); usedModuleTypes.insert(createModuleFromRegistrar("errorMinimizer", doc, pm.REG(ErrorMinimizer), errorMinimizer)); // See if to use a rigid transformation if (nodeVal("errorMinimizer", doc) != "PointToPointSimilarityErrorMinimizer") this->transformations.push_back(new typename TransformationsImpl<T>::RigidTransformation()); else this->transformations.push_back(new typename TransformationsImpl<T>::SimilarityTransformation()); usedModuleTypes.insert(createModulesFromRegistrar("transformationCheckers", doc, pm.REG(TransformationChecker), transformationCheckers)); usedModuleTypes.insert(createModuleFromRegistrar("inspector", doc, pm.REG(Inspector),inspector)); // FIXME: this line cause segfault when there is an error in the yaml file... //loadAdditionalYAMLContent(doc); // check YAML entries that do not correspend to any module for(YAML::Iterator moduleTypeIt = doc.begin(); moduleTypeIt != doc.end(); ++moduleTypeIt) { string moduleType; moduleTypeIt.first() >> moduleType; if (moduleType != "matcher" && usedModuleTypes.find(moduleType) == usedModuleTypes.end()) throw InvalidModuleType( (boost::format("Module type %1% does not exist") % moduleType).str() ); } }
bool IsBoolField(const string& field_name) { static StringSet int_bool_filter, special_bool_filter; if (int_bool_filter.empty() && special_bool_filter.empty()) { int_bool_filter.insert("lan-mode"); int_bool_filter.insert("announce"); int_bool_filter.insert("query"); int_bool_filter.insert("rcon"); int_bool_filter.insert("logqueries"); int_bool_filter.insert("chatlogging"); special_bool_filter.insert("timestamp"); special_bool_filter.insert("output"); } return int_bool_filter.end() != int_bool_filter.find(field_name) || special_bool_filter.end() != special_bool_filter.find(field_name); }
int MMKVImpl::SIsMember(DBID db, const Data& key, const Data& member) { int err = 0; RWLockGuard<MemorySegmentManager, READ_LOCK> keylock_guard(m_segment); StringSet* set = GetObject<StringSet>(db, key, V_TYPE_SET, false, err)(); if (IS_NOT_EXISTS(err)) { return 0; } if (NULL == set || 0 != err) { return err; } return set->find(Object(member, true)) != set->end(); }
static bool can_finalize_function(StringRef F, SmallSet<Module*, 16> &known) { if (incomplete_fname.find(F) != incomplete_fname.end()) return false; Module *M = module_for_fname.lookup(F); if (M && known.insert(M).second) { for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) { Function *F = &*I; if (F->isDeclaration() && !isIntrinsicFunction(F)) { if (!can_finalize_function(F->getName(), known)) return false; } } } return true; }
void reportingFrequencyGeneralTests(SqlFile& file, const SqlFileTimeSeriesQueryVector& allQueries) { // list of reporting frequencies from file should match .valueDescriptions() from vector StringSet rfStrs; for (const std::string& envPeriod : file.availableEnvPeriods()) { StringVector rfStrsForEnv = file.availableReportingFrequencies(envPeriod); rfStrs.insert(rfStrsForEnv.begin(),rfStrsForEnv.end()); } ReportingFrequencySet rfSetFromVector = reportingFrequencies(allQueries); StringSet rfStrsFromVector; for (const ReportingFrequency& rf : rfSetFromVector) { rfStrsFromVector.insert(rf.valueDescription()); } EXPECT_TRUE(rfStrs.size() >= rfStrsFromVector.size()); for (const std::string& rfStr : rfStrsFromVector) { EXPECT_TRUE(rfStrs.find(rfStr) != rfStrs.end()); } }
int main() { StringSet strings = SourceHighlightUtils::getFileNames(BASEDIR, "lang"); printStringSet(strings); cout << endl; assertTrue(strings.find("java.lang") != strings.end(), "expected java.lang"); assertTrue(strings.find("symbols.lang") != strings.end(), "expected symbols.lang"); assertTrue(strings.find("foobar.lang") == strings.end(), "NON expected foobar.lang"); strings = SourceHighlightUtils::getStyleFileNames(BASEDIR); printStringSet(strings); cout << endl; assertTrue(strings.find("default.style") != strings.end(), "expected default.style"); strings = SourceHighlightUtils::getCssStyleFileNames(BASEDIR); printStringSet(strings); cout << endl; assertTrue(strings.find("default.css") != strings.end(), "expected default.css"); strings = SourceHighlightUtils::getLangFileNames(BASEDIR); printStringSet(strings); cout << endl; assertTrue(strings.find("java.lang") != strings.end(), "expected java.lang"); strings = SourceHighlightUtils::getOutLangFileNames(BASEDIR); printStringSet(strings); cout << endl; assertTrue(strings.find("html.outlang") != strings.end(), "expected html.outlang"); cout << "test_utils: SUCCESS" << endl; return 0; }
void ConvertToBool(string& field_name) { static StringSet special_bool_filter; if(special_bool_filter.empty()) { special_bool_filter.insert("timestamp"); special_bool_filter.insert("output"); } if(special_bool_filter.end() == special_bool_filter.find(field_name)) { if("on" == m_conf[field_name]) m_conf[field_name] = "1"; else m_conf[field_name] = "0"; } else { if("on" == m_conf[field_name]) m_conf[field_name] = "Enable"; else m_conf[field_name] = "Disable"; } }
static void verifyAndReportDangerousProperties(const StringSet &dangerousProperties, const StringSet &clearedProperties, const std::string &ivarName, const QualType ivarType, const std::string &declName, const std::function<void(StringRef)> &emitBugReport) { // Verify that all the dangerous properties have been cleared for(auto it = dangerousProperties.begin(), end = dangerousProperties.end(); it != end; it++) { if (clearedProperties.find(*it) == clearedProperties.end()) { llvm::SmallString<128> buf; llvm::raw_svector_ostream os(buf); StringRef className; const ObjCObjectPointerType *classType = dyn_cast_or_null<ObjCObjectPointerType>(ivarType.getTypePtr()); if (classType && classType->getInterfaceDecl()) { className = classType->getInterfaceDecl()->getName(); } os << "Leaking unsafe reference to self stored in "<< ivarName << "." << *it; if (declName != "") { os << " (in " << declName << ")"; } os << ". "; os << "The assign property '" << *it << "' of the "; if (className != "") { os << "instance of " << className; } else { os << "object"; } os << " stored in '" << ivarName << "' appears to occasionally point to self. "; os << "For memory safety, you need to clear this property explicitly before losing reference to this object, typically by adding a line: '" << ivarName << "." << *it << " = nil;'. "; os << "In case of a false warning, consider adding an assert instead: 'FBAssert(" << ivarName << "." << *it << " != self);' or, if applicable: 'FBAssert(!" << ivarName << ");'."; emitBugReport(os.str()); } } }
int MMKVImpl::SRem(DBID db, const Data& key, const DataArray& members) { if (m_readonly) { return ERR_PERMISSION_DENIED; } int err = 0; RWLockGuard<MemorySegmentManager, WRITE_LOCK> keylock_guard(m_segment); EnsureWritableValueSpace(); StringSet* set = GetObject<StringSet>(db, key, V_TYPE_SET, false, err)(); if (IS_NOT_EXISTS(err)) { return 0; } if (NULL == set || 0 != err) { return err; } int removed = 0; for (size_t i = 0; i < members.size(); i++) { StringSet::iterator found = set->find(Object(members[i], true)); if (found != set->end()) { Object cc = *found; set->erase(found); DestroyObjectContent(cc); removed++; } } if (set->empty()) { GenericDel(GetMMKVTable(db, false),db, Object(key, false)); } return removed; }
void authorize(const AuthParams &challenge, AuthParams &authorization, const URI &uri, const std::string &method, const std::string &username, const std::string &password) { std::string realm, qop, nonce, opaque, algorithm; StringMap::const_iterator it; if ( (it = challenge.parameters.find("realm")) != challenge.parameters.end()) realm = it->second; if ( (it = challenge.parameters.find("qop")) != challenge.parameters.end()) qop = it->second; if ( (it = challenge.parameters.find("nonce")) != challenge.parameters.end()) nonce = it->second; if ( (it = challenge.parameters.find("opaque")) != challenge.parameters.end()) opaque = it->second; if ( (it = challenge.parameters.find("algorithm")) != challenge.parameters.end()) algorithm = it->second; if (algorithm.empty()) algorithm = "MD5"; StringSet qopValues; bool authQop = false; // If the server specified a quality of protection (qop), make sure it allows "auth" if (!qop.empty()) { ListParser parser(qopValues); parser.run(qop); if (parser.error() || !parser.complete()) MORDOR_THROW_EXCEPTION(BadMessageHeaderException()); if (qopValues.find("auth") == qopValues.end()) MORDOR_THROW_EXCEPTION(InvalidQopException(qop)); authQop = true; } // come up with a suitable client nonce std::ostringstream os; os << std::hex << TimerManager::now(); std::string cnonce = os.str(); std::string nc = "00000001"; // compute A1 std::string A1; if (algorithm == "MD5") A1 = username + ':' + realm + ':' + password; else if (algorithm == "MD5-sess") A1 = md5( username + ':' + realm + ':' + password ) + ':' + nonce + ':' + cnonce; else MORDOR_THROW_EXCEPTION(InvalidAlgorithmException(algorithm)); // compute A2 - our qop is always auth or unspecified os.str(""); os << method << ':' << uri; std::string A2 = os.str(); authorization.scheme = "Digest"; authorization.base64.clear(); authorization.parameters["username"] = username; authorization.parameters["realm"] = realm; authorization.parameters["nonce"] = nonce; authorization.parameters["uri"] = uri.toString(); authorization.parameters["algorithm"] = algorithm; std::string response; if (authQop) { qop = "auth"; response = md5( md5(A1) + ':' + nonce + ':' + nc + ':' + cnonce + ':' + qop + ':' + md5(A2) ); authorization.parameters["qop"] = qop; authorization.parameters["nc"] = nc; authorization.parameters["cnonce"] = cnonce; } else { response = md5( md5(A1) + ':' + nonce + ':' + md5(A2) ); } authorization.parameters["response"] = response; if (!opaque.empty()) authorization.parameters["opaque"] = opaque; }
void SBSourcesBuildPhase::writeVCProjectFiles(VCProject& proj) const { // We don't support source compilation when building bundles TargetProductType productType = m_parentTarget.getProductType(); if (productType == TargetBundle) { if (!m_phase->getBuildFileList().empty()) { SBLog::warning() << "Ignoring all source files in \"" << m_parentTarget.getName() << "\" bundle target." << std::endl; } return; } SBBuildPhase::writeVSFileDescriptions(proj, "Text"); String xcProjectDir = m_parentTarget.getProject().getProjectDir(); String vsProjectDir = sb_dirname(proj.getPath()); StringSet prefixHeaders; for (auto bs : m_parentTarget.getBuildSettings()) { VCProjectConfiguration* config = proj.addConfiguration(bs.first); // Prefix header (recalculate relative path) String prefixHeader = bs.second->getValue("GCC_PREFIX_HEADER"); if (!prefixHeader.empty()) { String absHeaderPath = m_parentTarget.makeAbsolutePath(prefixHeader); String relHeaderPath = m_parentTarget.makeRelativePath(prefixHeader, vsProjectDir);; relHeaderPath = winPath(relHeaderPath); config->setItemDefinition("ClangCompile", "PrefixHeader", relHeaderPath); // Add plist file to project (only once) if (prefixHeaders.find(absHeaderPath) == prefixHeaders.end()) { addRelativeFilePathToVS("ClInclude", absHeaderPath, "", proj, *bs.second); prefixHeaders.insert(absHeaderPath); } } // Preprocessor definitions StringVec preprocessorTokens; bs.second->getValue("GCC_PREPROCESSOR_DEFINITIONS", preprocessorTokens); String preprocessorDefs = joinStrings(preprocessorTokens, ";"); if (!preprocessorDefs.empty()) { config->setItemDefinition("ClangCompile", "PreprocessorDefinitions", preprocessorDefs); } // Optimization level String optimizationLevel = bs.second->getValue("GCC_OPTIMIZATION_LEVEL"); if (!optimizationLevel.empty()) { String vsOptimizationLevel; if (optimizationLevel == "s") { vsOptimizationLevel = "MinSpace"; } else if (optimizationLevel == "0") { vsOptimizationLevel = "Disabled"; } else { vsOptimizationLevel = "MaxSpeed"; } config->setItemDefinition("ClangCompile", "OptimizationLevel", vsOptimizationLevel); } // ARC String enableARC = bs.second->getValue("CLANG_ENABLE_OBJC_ARC"); if (enableARC == "YES") { config->setItemDefinition("ClangCompile", "ObjectiveCARC", "true"); } // Modules String enableModules = bs.second->getValue("CLANG_ENABLE_MODULES"); if (enableModules == "YES") { config->setItemDefinition("ClangCompile", "ObjectiveCModules", "true"); } // Header search paths (make them relative) StringVec includePaths; bs.second->getValue("HEADER_SEARCH_PATHS", includePaths); for (auto &cur : includePaths) { cur = m_parentTarget.makeRelativePath(cur, vsProjectDir); cur = winPath(cur); } includePaths.insert(includePaths.begin(), "$(SolutionPublicHeadersDir)"); config->setItemDefinition("ClangCompile", "IncludePaths", joinStrings(includePaths, ";")); // User header search paths (make them relative) StringVec userIncludePaths; bs.second->getValue("USER_HEADER_SEARCH_PATHS", userIncludePaths); for (auto &cur : userIncludePaths) { cur = m_parentTarget.makeRelativePath(cur, vsProjectDir); cur = winPath(cur); } if (!userIncludePaths.empty()) { config->setItemDefinition("ClangCompile", "UserIncludePaths", joinStrings(userIncludePaths, ";")); } // Exclude search path subdirectories StringVec excludeSubDirectories; bs.second->getValue("EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES", excludeSubDirectories); if (!excludeSubDirectories.empty()) { config->setItemDefinition("ClangCompile", "ExcludedSearchPathSubdirectories", joinStrings(excludeSubDirectories, ";")); } // Header map if (bs.second->getValue("USE_HEADERMAP") == "YES") { if (bs.second->getValue("ALWAYS_SEARCH_USER_PATHS") == "YES") { config->setItemDefinition("ClangCompile", "HeaderMap", "Combined"); } else if (bs.second->getValue("HEADERMAP_INCLUDES_PROJECT_HEADERS") == "YES") { config->setItemDefinition("ClangCompile", "HeaderMap", "Project"); } } // Other C flags String otherCFlags = bs.second->getValue("OTHER_CFLAGS"); processClangFlags(otherCFlags, xcProjectDir, vsProjectDir); if (!otherCFlags.empty()) { config->setItemDefinition("ClangCompile", "OtherCFlags", otherCFlags); } // Other C++ flags String otherCPlusPlusFlags = bs.second->getValue("OTHER_CPLUSPLUSFLAGS"); processClangFlags(otherCPlusPlusFlags, xcProjectDir, vsProjectDir); if (!otherCPlusPlusFlags.empty()) { config->setItemDefinition("ClangCompile", "OtherCPlusPlusFlags", otherCPlusPlusFlags); } // CRT String configNameUpper = strToUpper(bs.first); if (configNameUpper.find("DEBUG") != String::npos) { config->setItemDefinition("ClangCompile", "RuntimeLibrary", "MultiThreadedDebugDLL"); } } }
/** * Scan a file for includes, defines and the lot. * @param filename the name of the file to scan. * @param ext the extension of the filename. * @param header whether the file is a header or not. * @param verbose whether to give verbose debugging information. */ void ScanFile(const char *filename, const char *ext, bool header, bool verbose) { static StringSet defines; static std::stack<Ignore> ignore; /* Copy in the default defines (parameters of depend) */ if (!header) { for (StringSet::iterator it = _defines.begin(); it != _defines.end(); it++) { defines.insert(strdup(*it)); } } File file(filename); Lexer lexer(&file); /* Start the lexing! */ lexer.Lex(); while (lexer.GetToken() != TOKEN_END) { switch (lexer.GetToken()) { /* We reached the end of the file... yay, we're done! */ case TOKEN_END: break; /* The line started with a # (minus whitespace) */ case TOKEN_SHARP: lexer.Lex(); switch (lexer.GetToken()) { case TOKEN_INCLUDE: if (verbose) fprintf(stderr, "%s #include ", filename); lexer.Lex(); switch (lexer.GetToken()) { case TOKEN_LOCAL: case TOKEN_GLOBAL: { if (verbose) fprintf(stderr, "%s", lexer.GetString()); if (!ignore.empty() && ignore.top() != NOT_IGNORE) { if (verbose) fprintf(stderr, " (ignored)"); break; } const char *h = GeneratePath(file.GetDirname(), lexer.GetString(), lexer.GetToken() == TOKEN_LOCAL); if (h != NULL) { StringMap::iterator it = _headers.find(h); if (it == _headers.end()) { it = (_headers.insert(StringMapItem(strdup(h), new StringSet()))).first; if (verbose) fprintf(stderr, "\n"); ScanFile(h, ext, true, verbose); } StringMap::iterator curfile; if (header) { curfile = _headers.find(filename); } else { /* Replace the extension with the provided extension of '.o'. */ char path[PATH_MAX]; strcpy(path, filename); *(strrchr(path, '.')) = '\0'; strcat(path, ext != NULL ? ext : ".o"); curfile = _files.find(path); if (curfile == _files.end()) { curfile = (_files.insert(StringMapItem(strdup(path), new StringSet()))).first; } } if (it != _headers.end()) { for (StringSet::iterator header = it->second->begin(); header != it->second->end(); header++) { if (curfile->second->find(*header) == curfile->second->end()) curfile->second->insert(strdup(*header)); } } if (curfile->second->find(h) == curfile->second->end()) curfile->second->insert(strdup(h)); free(h); } } /* FALL THROUGH */ default: break; } break; case TOKEN_DEFINE: if (verbose) fprintf(stderr, "%s #define ", filename); lexer.Lex(); if (lexer.GetToken() == TOKEN_IDENTIFIER) { if (verbose) fprintf(stderr, "%s", lexer.GetString()); if (!ignore.empty() && ignore.top() != NOT_IGNORE) { if (verbose) fprintf(stderr, " (ignored)"); break; } if (defines.find(lexer.GetString()) == defines.end()) defines.insert(strdup(lexer.GetString())); lexer.Lex(); } break; case TOKEN_UNDEF: if (verbose) fprintf(stderr, "%s #undef ", filename); lexer.Lex(); if (lexer.GetToken() == TOKEN_IDENTIFIER) { if (verbose) fprintf(stderr, "%s", lexer.GetString()); if (!ignore.empty() && ignore.top() != NOT_IGNORE) { if (verbose) fprintf(stderr, " (ignored)"); break; } StringSet::iterator it = defines.find(lexer.GetString()); if (it != defines.end()) { free(*it); defines.erase(it); } lexer.Lex(); } break; case TOKEN_ENDIF: if (verbose) fprintf(stderr, "%s #endif", filename); lexer.Lex(); if (!ignore.empty()) ignore.pop(); if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; case TOKEN_ELSE: { if (verbose) fprintf(stderr, "%s #else", filename); lexer.Lex(); Ignore last = ignore.empty() ? NOT_IGNORE : ignore.top(); if (!ignore.empty()) ignore.pop(); if (ignore.empty() || ignore.top() == NOT_IGNORE) { ignore.push(last == IGNORE_UNTIL_ELSE ? NOT_IGNORE : IGNORE_UNTIL_ENDIF); } else { ignore.push(IGNORE_UNTIL_ENDIF); } if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; } case TOKEN_ELIF: { if (verbose) fprintf(stderr, "%s #elif ", filename); lexer.Lex(); Ignore last = ignore.empty() ? NOT_IGNORE : ignore.top(); if (!ignore.empty()) ignore.pop(); if (ignore.empty() || ignore.top() == NOT_IGNORE) { bool value = ExpressionOr(&lexer, &defines, verbose); ignore.push(last == IGNORE_UNTIL_ELSE ? (value ? NOT_IGNORE : IGNORE_UNTIL_ELSE) : IGNORE_UNTIL_ENDIF); } else { ignore.push(IGNORE_UNTIL_ENDIF); } if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; } case TOKEN_IF: { if (verbose) fprintf(stderr, "%s #if ", filename); lexer.Lex(); if (ignore.empty() || ignore.top() == NOT_IGNORE) { bool value = ExpressionOr(&lexer, &defines, verbose); ignore.push(value ? NOT_IGNORE : IGNORE_UNTIL_ELSE); } else { ignore.push(IGNORE_UNTIL_ENDIF); } if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; } case TOKEN_IFDEF: if (verbose) fprintf(stderr, "%s #ifdef ", filename); lexer.Lex(); if (lexer.GetToken() == TOKEN_IDENTIFIER) { bool value = defines.find(lexer.GetString()) != defines.end(); if (verbose) fprintf(stderr, "%s[%d]", lexer.GetString(), value); if (ignore.empty() || ignore.top() == NOT_IGNORE) { ignore.push(value ? NOT_IGNORE : IGNORE_UNTIL_ELSE); } else { ignore.push(IGNORE_UNTIL_ENDIF); } } if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; case TOKEN_IFNDEF: if (verbose) fprintf(stderr, "%s #ifndef ", filename); lexer.Lex(); if (lexer.GetToken() == TOKEN_IDENTIFIER) { bool value = defines.find(lexer.GetString()) != defines.end(); if (verbose) fprintf(stderr, "%s[%d]", lexer.GetString(), value); if (ignore.empty() || ignore.top() == NOT_IGNORE) { ignore.push(!value ? NOT_IGNORE : IGNORE_UNTIL_ELSE); } else { ignore.push(IGNORE_UNTIL_ENDIF); } } if (verbose) fprintf(stderr, " -> %signore", (!ignore.empty() && ignore.top() != NOT_IGNORE) ? "" : "not "); break; default: if (verbose) fprintf(stderr, "%s #<unknown>", filename); lexer.Lex(); break; } if (verbose) fprintf(stderr, "\n"); /* FALL THROUGH */ default: /* Ignore the rest of the garbage on this line */ while (lexer.GetToken() != TOKEN_EOL && lexer.GetToken() != TOKEN_END) lexer.Lex(); lexer.Lex(); break; } } if (!header) { for (StringSet::iterator it = defines.begin(); it != defines.end(); it++) { free(*it); } defines.clear(); while (!ignore.empty()) ignore.pop(); } }
std::string UdmComparator::ObjectName::operator()( Udm::Object udmObject ) { static StringSet reportedClassNameSet; Uml::Class umlClass = udmObject.type(); Uml::Attribute umlNameAttribute; UmlClassNameAttributeMap::iterator cnmItr = _umlClassNameAttributeMap.find( umlClass ); if ( cnmItr != _umlClassNameAttributeMap.end() ) { umlNameAttribute = cnmItr->second; } else { NameUmlAttributeMap nameUmlAttributeMap = getNameUmlAttributeMap( umlClass ); NameUmlAttributeMap::iterator numItr = nameUmlAttributeMap.find( "name" ); if ( numItr != nameUmlAttributeMap.end() ) { umlNameAttribute = numItr->second; } else { numItr = nameUmlAttributeMap.find( "Name" ); if ( numItr != nameUmlAttributeMap.end() ) { umlNameAttribute = numItr->second; } else if ( static_cast< std::string >( umlClass.stereotype() ) != "Connection" ) { std::string className = umlClass.name(); if ( reportedClassNameSet.find( className ) == reportedClassNameSet.end() ) { std::cerr << "WARNING: Class \"" << className << "\" has no \"[Nn]ame\" attribute." << std::endl << std::endl; reportedClassNameSet.insert( className ); } return ""; } } _umlClassNameAttributeMap.insert( std::make_pair( umlClass, umlNameAttribute ) ); } std::string udmObjectName = ""; if ( umlNameAttribute != Udm::null ) { udmObjectName = udmObject.getStringAttr( umlNameAttribute ); if ( umlClass.stereotype() == "Connection" && udmObjectName == static_cast< std::string >( umlClass.name() ) ) { udmObjectName = ""; } } if ( udmObjectName == "" && umlClass.stereotype() == "Connection" ) { UmlAssociationRoleSet umlAssociationRoleSet = getAllUmlAssociationRoles( umlClass ); for( UmlAssociationRoleSet::iterator arsItr = umlAssociationRoleSet.begin() ; arsItr != umlAssociationRoleSet.end() ; ++arsItr ) { UdmObjectSet udmObjectSet = udmObject.getAssociation( *arsItr, Udm::TARGETFROMCLASS ); for( UdmObjectSet::iterator uosItr = udmObjectSet.begin() ; uosItr != udmObjectSet.end() ; ++uosItr ) { if ( !udmObjectName.empty() ) udmObjectName += ":"; udmObjectName += (*this)(*uosItr); } } if ( umlNameAttribute != Udm::null ) { udmObject.setStringAttr( umlNameAttribute, udmObjectName ); } } Udm::Object udmObjectParent = udmObject.GetParent(); if ( udmObjectParent != Udm::null ) { const auto& it = ObjectNameCache.find(udmObjectParent); if (it != ObjectNameCache.end()) { udmObjectName = it->second + "/" + udmObjectName; } else { udmObjectName = operator()( udmObjectParent ) + "/" + udmObjectName; } } return udmObjectName; }
// _LoadAddOns status_t DiskSystemAddOnManager::_LoadAddOns(StringSet& alreadyLoaded, directory_which addOnDir) { // get the add-on directory path BPath path; status_t error = find_directory(addOnDir, &path, false); if (error != B_OK) return error; TRACE("DiskSystemAddOnManager::_LoadAddOns(): %s\n", path.Path()); error = path.Append("disk_systems"); if (error != B_OK) return error; if (!BEntry(path.Path()).Exists()) return B_OK; // open the directory and iterate through its entries BDirectory directory; error = directory.SetTo(path.Path()); if (error != B_OK) return error; entry_ref ref; while (directory.GetNextRef(&ref) == B_OK) { // skip, if already loaded if (alreadyLoaded.find(ref.name) != alreadyLoaded.end()) { TRACE(" skipping \"%s\" -- already loaded\n", ref.name); continue; } // get the entry path BPath entryPath; error = entryPath.SetTo(&ref); if (error != B_OK) { if (error == B_NO_MEMORY) return error; TRACE(" skipping \"%s\" -- failed to get path\n", ref.name); continue; } // load the add-on image_id image = load_add_on(entryPath.Path()); if (image < 0) { TRACE(" skipping \"%s\" -- failed to load add-on\n", ref.name); continue; } AddOnImage* addOnImage = new(nothrow) AddOnImage(image); if (!addOnImage) { unload_add_on(image); return B_NO_MEMORY; } ObjectDeleter<AddOnImage> addOnImageDeleter(addOnImage); // get the add-on objects status_t (*getAddOns)(BList*); error = get_image_symbol(image, "get_disk_system_add_ons", B_SYMBOL_TYPE_TEXT, (void**)&getAddOns); if (error != B_OK) { TRACE(" skipping \"%s\" -- function symbol not found\n", ref.name); continue; } BList addOns; error = getAddOns(&addOns); if (error != B_OK || addOns.IsEmpty()) { TRACE(" skipping \"%s\" -- getting add-ons failed\n", ref.name); continue; } // create and add AddOn objects int32 count = addOns.CountItems(); for (int32 i = 0; i < count; i++) { BDiskSystemAddOn* diskSystemAddOn = (BDiskSystemAddOn*)addOns.ItemAt(i); AddOn* addOn = new(nothrow) AddOn(addOnImage, diskSystemAddOn); if (!addOn) return B_NO_MEMORY; if (fAddOns.AddItem(addOn)) { addOnImage->refCount++; addOnImageDeleter.Detach(); } else { delete addOn; return B_NO_MEMORY; } } TRACE(" got %ld BDiskSystemAddOn(s) from add-on \"%s\"\n", count, ref.name); // add the add-on name to the set of already loaded add-ons try { alreadyLoaded.insert(ref.name); } catch (std::bad_alloc& exception) { return B_NO_MEMORY; } } return B_OK; }
void ATIExecutableKernel::initializeSharedMemory() { report("Allocating shared memory"); typedef std::unordered_map<std::string, size_t> AllocationMap; typedef std::unordered_set<std::string> StringSet; typedef std::deque<ir::PTXOperand*> OperandVector; typedef std::unordered_map<std::string, ir::Module::GlobalMap::const_iterator> GlobalMap; AllocationMap map; GlobalMap sharedGlobals; StringSet external; OperandVector externalOperands; unsigned int externalAlignment = 1; size_t sharedSize = 0; assert(module != 0); // global shared variables ir::Module::GlobalMap globals = module->globals(); ir::Module::GlobalMap::const_iterator global; for (global = globals.begin() ; global != globals.end() ; global++) { ir::PTXStatement statement = global->second.statement; if (statement.directive == ir::PTXStatement::Shared) { if (statement.attribute == ir::PTXStatement::Extern) { report("Found global external shared variable \"" << statement.name << "\""); assertM(external.count(statement.name) == 0, "External global \"" << statement.name << "\" declared more than once."); external.insert(statement.name); externalAlignment = std::max(externalAlignment, (unsigned int)statement.alignment); externalAlignment = std::max(externalAlignment, ir::PTXOperand::bytes(statement.type)); } else { report("Found global shared variable \"" << statement.name << "\""); sharedGlobals.insert( std::make_pair(statement.name, global)); } } } // local shared variables LocalMap::const_iterator local; for (local = locals.begin() ; local != locals.end() ; local++) { if (local->second.space == ir::PTXInstruction::Shared) { if (local->second.attribute == ir::PTXStatement::Extern) { report("Found local external shared variable \"" << local->second.name << "\""); assertM(external.count(local->second.name) == 0, "External local \"" << local->second.name << "\" declared more than once."); external.insert(local->second.name); externalAlignment = std::max(externalAlignment, (unsigned int)local->second.alignment); externalAlignment = std::max(externalAlignment, ir::PTXOperand::bytes(local->second.type)); } else { report("Allocating local shared variable \"" << local->second.name << "\" of size " << local->second.getSize()); _pad(sharedSize, local->second.alignment); map.insert(std::make_pair(local->second.name, sharedSize)); sharedSize += local->second.getSize(); } } } ir::ControlFlowGraph::iterator block; for (block = cfg()->begin() ; block != cfg()->end() ; block++) { ir::ControlFlowGraph::InstructionList insts = block->instructions; ir::ControlFlowGraph::InstructionList::iterator inst; for (inst = insts.begin() ; inst != insts.end() ; inst++) { ir::PTXInstruction& ptx = static_cast<ir::PTXInstruction&>(**inst); if (ptx.opcode == ir::PTXInstruction::Mov || ptx.opcode == ir::PTXInstruction::Ld || ptx.opcode == ir::PTXInstruction::St) { ir::PTXOperand* operands[] = {&ptx.d, &ptx.a, &ptx.b, &ptx.c}; for (unsigned int i = 0 ; i != 4 ; i++) { ir::PTXOperand* operand = operands[i]; if (operand->addressMode == ir::PTXOperand::Address) { StringSet::iterator si = external.find(operand->identifier); if (si != external.end()) { report("For instruction \"" << ptx.toString() << "\", mapping shared label \"" << *si << "\" to external shared memory."); externalOperands.push_back(operand); continue; } GlobalMap::iterator gi = sharedGlobals.find(operand->identifier); if (gi != sharedGlobals.end()) { ir::Module::GlobalMap::const_iterator it = gi->second; sharedGlobals.erase(gi); report("Allocating global shared variable \"" << it->second.statement.name << "\""); map.insert(std::make_pair( it->second.statement.name, sharedSize)); sharedSize += it->second.statement.bytes(); } AllocationMap::iterator mapping = map.find(operand->identifier); if (mapping != map.end()) { report("For instruction " << ptx.toString() << ", mapping shared label " << mapping->first << " to " << mapping->second); operand->addressMode = ir::PTXOperand::Immediate; operand->imm_uint = mapping->second; } } } } } } _pad(sharedSize, externalAlignment); report("Mapping external shared variables."); OperandVector::iterator operand; for (operand = externalOperands.begin() ; operand != externalOperands.end() ; operand++) { report("Mapping external shared label \"" << (*operand)->identifier << "\" to " << sharedSize); (*operand)->addressMode = ir::PTXOperand::Immediate; (*operand)->imm_uint = sharedSize; } // allocate shared memory object _sharedMemorySize = sharedSize; report("Total shared memory size is " << _sharedMemorySize); }
Error DiffStyle::diffStringTable() { DiffPrinter D(2, "String Table", 30, 20, opts::diff::PrintResultColumn, opts::diff::PrintValueColumns, outs()); D.printExplicit("File", DiffResult::UNSPECIFIED, truncateStringFront(File1.getFilePath(), 18), truncateStringFront(File2.getFilePath(), 18)); auto ExpectedST1 = File1.getStringTable(); auto ExpectedST2 = File2.getStringTable(); bool Has1 = !!ExpectedST1; bool Has2 = !!ExpectedST2; std::string Count1 = Has1 ? llvm::utostr(ExpectedST1->getNameCount()) : "(string table not present)"; std::string Count2 = Has2 ? llvm::utostr(ExpectedST2->getNameCount()) : "(string table not present)"; D.print("Number of Strings", Count1, Count2); if (!Has1 || !Has2) { consumeError(ExpectedST1.takeError()); consumeError(ExpectedST2.takeError()); return Error::success(); } auto &ST1 = *ExpectedST1; auto &ST2 = *ExpectedST2; D.print("Hash Version", ST1.getHashVersion(), ST2.getHashVersion()); D.print("Byte Size", ST1.getByteSize(), ST2.getByteSize()); D.print("Signature", ST1.getSignature(), ST2.getSignature()); // Both have a valid string table, dive in and compare individual strings. auto IdList1 = ST1.name_ids(); auto IdList2 = ST2.name_ids(); StringSet<> LS; StringSet<> RS; uint32_t Empty1 = 0; uint32_t Empty2 = 0; for (auto ID : IdList1) { auto S = ST1.getStringForID(ID); if (!S) return S.takeError(); if (S->empty()) ++Empty1; else LS.insert(*S); } for (auto ID : IdList2) { auto S = ST2.getStringForID(ID); if (!S) return S.takeError(); if (S->empty()) ++Empty2; else RS.insert(*S); } D.print("Empty Strings", Empty1, Empty2); for (const auto &S : LS) { auto R = RS.find(S.getKey()); std::string Truncated = truncateStringMiddle(S.getKey(), 28); uint32_t I = cantFail(ST1.getIDForString(S.getKey())); if (R == RS.end()) { D.printExplicit(Truncated, DiffResult::DIFFERENT, I, "(not present)"); continue; } uint32_t J = cantFail(ST2.getIDForString(R->getKey())); D.print<EquivalentDiffProvider>(Truncated, I, J); RS.erase(R); } for (const auto &S : RS) { auto L = LS.find(S.getKey()); std::string Truncated = truncateStringMiddle(S.getKey(), 28); uint32_t J = cantFail(ST2.getIDForString(S.getKey())); if (L == LS.end()) { D.printExplicit(Truncated, DiffResult::DIFFERENT, "(not present)", J); continue; } uint32_t I = cantFail(ST1.getIDForString(L->getKey())); D.print<EquivalentDiffProvider>(Truncated, I, J); } return Error::success(); }
//----------------------------------------------------------------------- void Compositor::createGlobalTextures() { static size_t dummyCounter = 0; if (mSupportedTechniques.empty()) return; //To make sure that we are consistent, it is demanded that all composition //techniques define the same set of global textures. typedef std::set<String> StringSet; StringSet globalTextureNames; //Initialize global textures from first supported technique CompositionTechnique* firstTechnique = mSupportedTechniques[0]; CompositionTechnique::TextureDefinitionIterator texDefIt = firstTechnique->getTextureDefinitionIterator(); while (texDefIt.hasMoreElements()) { CompositionTechnique::TextureDefinition* def = texDefIt.getNext(); if (def->scope == CompositionTechnique::TS_GLOBAL) { //Check that this is a legit global texture if (!def->refCompName.empty()) { OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Global compositor texture definition can not be a reference", "Compositor::createGlobalTextures"); } if (def->width == 0 || def->height == 0) { OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Global compositor texture definition must have absolute size", "Compositor::createGlobalTextures"); } if (def->pooled) { LogManager::getSingleton().logMessage( "Pooling global compositor textures has no effect"); } globalTextureNames.insert(def->name); //TODO GSOC : Heavy copy-pasting from CompositorInstance. How to we solve it? /// Make the tetxure RenderTarget* rendTarget; if (def->formatList.size() > 1) { String MRTbaseName = "c" + StringConverter::toString(dummyCounter++) + "/" + mName + "/" + def->name; MultiRenderTarget* mrt = Root::getSingleton().getRenderSystem()->createMultiRenderTarget(MRTbaseName); mGlobalMRTs[def->name] = mrt; // create and bind individual surfaces size_t atch = 0; for (PixelFormatList::iterator p = def->formatList.begin(); p != def->formatList.end(); ++p, ++atch) { String texname = MRTbaseName + "/" + StringConverter::toString(atch); TexturePtr tex; tex = TextureManager::getSingleton().createManual( texname, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D, (uint)def->width, (uint)def->height, 0, *p, TU_RENDERTARGET, 0, def->hwGammaWrite && !PixelUtil::isFloatingPoint(*p), def->fsaa); RenderTexture* rt = tex->getBuffer()->getRenderTarget(); rt->setAutoUpdated(false); mrt->bindSurface(atch, rt); // Also add to local textures so we can look up String mrtLocalName = getMRTTexLocalName(def->name, atch); mGlobalTextures[mrtLocalName] = tex; } rendTarget = mrt; } else { String texName = "c" + StringConverter::toString(dummyCounter++) + "/" + mName + "/" + def->name; // space in the name mixup the cegui in the compositor demo // this is an auto generated name - so no spaces can't hart us. std::replace( texName.begin(), texName.end(), ' ', '_' ); TexturePtr tex; tex = TextureManager::getSingleton().createManual( texName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME, TEX_TYPE_2D, (uint)def->width, (uint)def->height, 0, def->formatList[0], TU_RENDERTARGET, 0, def->hwGammaWrite && !PixelUtil::isFloatingPoint(def->formatList[0]), def->fsaa); rendTarget = tex->getBuffer()->getRenderTarget(); mGlobalTextures[def->name] = tex; } //Set DepthBuffer pool for sharing rendTarget->setDepthBufferPool( def->depthBufferId ); } } //Validate that all other supported techniques expose the same set of global textures. for (size_t i=1; i<mSupportedTechniques.size(); i++) { CompositionTechnique* technique = mSupportedTechniques[i]; bool isConsistent = true; size_t numGlobals = 0; texDefIt = technique->getTextureDefinitionIterator(); while (texDefIt.hasMoreElements()) { CompositionTechnique::TextureDefinition* texDef = texDefIt.getNext(); if (texDef->scope == CompositionTechnique::TS_GLOBAL) { if (globalTextureNames.find(texDef->name) == globalTextureNames.end()) { isConsistent = false; break; } numGlobals++; } } if (numGlobals != globalTextureNames.size()) isConsistent = false; if (!isConsistent) { OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Different composition techniques define different global textures", "Compositor::createGlobalTextures"); } } }
TEST_F(IddFixture,IddFactory_Units) { std::vector<boost::regex> unsupported; unsupported.push_back(boost::regex("\\$")); unsupported.push_back(boost::regex("eV")); unsupported.push_back(boost::regex("hh:mm")); unsupported.push_back(boost::regex("percent")); unsupported.push_back(boost::regex("ppm")); IddObjectVector objects = IddFactory::instance().getObjects(IddFileType(IddFileType::WholeFactory)); StringSet goodUnits; StringSet badUnits; for (const IddObject& object : objects) { IddFieldVector fields = object.nonextensibleFields(); IddFieldVector temp = object.extensibleGroup(); fields.insert(fields.end(),temp.begin(),temp.end()); for (const IddField& field : fields) { OptionalString iddUnits = field.properties().units; OptionalUnit siUnit; if (iddUnits) { // check if already tested units if (goodUnits.find(*iddUnits) != goodUnits.end()) { continue; } if (badUnits.find(*iddUnits) != badUnits.end()) { continue; } // screen for unsupported units for (const boost::regex& re : unsupported) { if (boost::regex_search(*iddUnits,re)) { iddUnits = boost::none; break; } } if (!iddUnits) { continue; } siUnit = field.getUnits(false); EXPECT_TRUE(siUnit || field.unitsBasedOnOtherField()) << object.name() << " field: " << field.name(); if (siUnit) { // could just return junk unit. if not junk, quantity will be convertible // to UnitSystem::SI. Quantity q(1.0,*siUnit); OptionalQuantity testQ = convert(q,UnitSystem(UnitSystem::SI)); EXPECT_TRUE(testQ) << "Unable to convert unit '" << *iddUnits << "' to SI for field '" << field.name() << "' in IddObject '" << object.name() << "'."; if (testQ) { goodUnits.insert(*iddUnits); EXPECT_TRUE(testQ->system() == UnitSystem::SI); } else { badUnits.insert(*iddUnits); LOG(Debug,"Unable to convert unit '" << *iddUnits << "' to SI for field '" << field.name() << "' in IddObject '" << object.name() << "'."); } } else if (field.unitsBasedOnOtherField()) { goodUnits.insert(*iddUnits); continue; } else { badUnits.insert(*iddUnits); LOG(Debug,"Unable to instantiate unit '" << *iddUnits << "' for field '" << field.name() << "' in IddObject '" << object.name() << "'."); continue; } OptionalUnit ipUnit = field.getUnits(true); EXPECT_TRUE(ipUnit); if (ipUnit) { // could just return junk unit. if not junk, quantity will be convertable // to *siUnit or UnitSystem::SI. Quantity q(1.0,*ipUnit); OptionalQuantity testQ; if (siUnit) { testQ = convert(q,*siUnit); } else { testQ = convert(q,UnitSystem(UnitSystem::SI)); } EXPECT_TRUE(testQ); if (testQ) { goodUnits.insert(*iddUnits); } else { badUnits.insert(ipUnit->standardString()); LOG(Debug,"Unable to convert unit " << *ipUnit << " to IDD/SI units " << *siUnit << " for field '" << field.name() << "' in IddObject '" << object.name() << "'."); } } else { badUnits.insert(*iddUnits); LOG(Debug,"Unable to instantiate ipUnit for field " << field.name() << " in IddObject " << object.name() << ", which has units " << *siUnit << "."); } } } } LOG(Info,"IddUnitStrings not handled properly by the Factories and Converter:"); for (const std::string& str : badUnits) { LOG(Info," " << str); } LOG(Info,"IddUnitStrings handled properly by the Factories and Converter:"); for (const std::string& str : goodUnits) { LOG(Info," " << str); } }
void DataLint::report() { if (m_enabled) { // Error Assets DEBUG_REPORT_LOG_PRINT(true, ("Writing error files\n")); // Setup filenames for client versus server mode std::string dataLintErrorsAll((m_mode == M_client) ? "DataLint_Errors_All.txt" : "DataLintServer_Errors_All.txt"); std::string dataLintErrorsAllFatal((m_mode == M_client) ? "DataLint_Errors_All_Fatal.txt" : "DataLintServer_Errors_All_Fatal.txt"); std::string dataLintErrorsAllWarning((m_mode == M_client) ? "DataLint_Errors_All_Warning.txt" : "DataLintServer_Errors_All_Warning.txt"); std::string dataLintErrorsAllObjectTemplate((m_mode == M_client) ? "DataLint_Errors_ObjectTemplate.txt" : "DataLintServer_Errors_ObjectTemplate.txt"); // Server/client FILE *assetErrorFileAll = fopen(dataLintErrorsAll.c_str(), "wt"); FILE *assetErrorFileAllFatal = fopen(dataLintErrorsAllFatal.c_str(), "wt"); FILE *assetErrorFileAllWarning = fopen(dataLintErrorsAllWarning.c_str(), "wt"); FILE *assetErrorFileObjectTemplate = fopen(dataLintErrorsAllObjectTemplate.c_str(), "wt"); // Client only FILE *assetErrorFileAppearance = NULL; FILE *assetErrorFileArrangementDescriptor = NULL; FILE *assetErrorFileLocalizedStringTable = NULL; FILE *assetErrorFilePortalProperty = NULL; FILE *assetErrorFileShaderTemplate = NULL; FILE *assetErrorFileSkyBox = NULL; FILE *assetErrorFileSlotDescriptor = NULL; FILE *assetErrorFileSoundTemplate = NULL; FILE *assetErrorFileTerrain = NULL; FILE *assetErrorFileTexture = NULL; FILE *assetErrorFileTextureRenderer = NULL; if (m_mode == M_client) { assetErrorFileAppearance = fopen("DataLint_Errors_Appearance.txt", "wt"); assetErrorFileArrangementDescriptor = fopen("DataLint_Errors_ArrangementDescriptor.txt", "wt"); assetErrorFileLocalizedStringTable = fopen("DataLint_Errors_LocalizedStringTable.txt", "wt"); assetErrorFilePortalProperty = fopen("DataLint_Errors_PortalProperty.txt", "wt"); assetErrorFileShaderTemplate = fopen("DataLint_Errors_ShaderTemplate.txt", "wt"); assetErrorFileSkyBox = fopen("DataLint_Errors_SkyBox.txt", "wt"); assetErrorFileSlotDescriptor = fopen("DataLint_Errors_SlotDescriptor.txt", "wt"); assetErrorFileSoundTemplate = fopen("DataLint_Errors_SoundTemplate.txt", "wt"); assetErrorFileTerrain = fopen("DataLint_Errors_Terrain.txt", "wt"); assetErrorFileTexture = fopen("DataLint_Errors_Texture.txt", "wt"); assetErrorFileTextureRenderer = fopen("DataLint_Errors_TextureRenderer.txt", "wt"); } // Might want to think of a better way to keep track of the number of errors for each specific asset type. int totalErrorCountAll = 1; int totalErrorCountAllFatal = 1; int totalErrorCountAllWarning = 1; int totalErrorCountAppearance = 1; int totalErrorCountArrangementDescriptor = 1; int totalErrorCountLocalizedStringTable = 1; int totalErrorCountObjectTemplate = 1; int totalErrorCountPortalProperty = 1; int totalErrorCountShaderTemplate = 1; int totalErrorCountSkyBox = 1; int totalErrorCountSlotDescriptor = 1; int totalErrorCountSoundTemplate = 1; int totalErrorCountTerrain = 1; int totalErrorCountTexture = 1; int totalErrorCountTextureRenderer = 1; typedef std::set<std::string> StringSet; StringSet duplicateStringSet; if (assetErrorFileAll) { WarningList::iterator warningListIter = m_warningList->begin(); for (; warningListIter != m_warningList->end(); ++warningListIter) { // Build a duplicate string std::string duplicateString(warningListIter->first); StringList::const_iterator stringStackIter = warningListIter->second.second.begin(); for (; stringStackIter != warningListIter->second.second.end(); ++stringStackIter) { duplicateString += *stringStackIter; } if (duplicateStringSet.find(duplicateString) == duplicateStringSet.end()) { // This is the first instance of this error, so log it duplicateStringSet.insert(duplicateString); } else { // We found a duplicate warning, so don't show it twice continue; } // Write the error to the appropriate error file switch (warningListIter->second.first) { case AT_appearance: { if (m_mode == M_client) { writeError(assetErrorFileAppearance, *warningListIter, totalErrorCountAppearance); } } break; case AT_arrangementDescriptor: { if (m_mode == M_client) { writeError(assetErrorFileArrangementDescriptor, *warningListIter, totalErrorCountArrangementDescriptor); } } break; case AT_localizedStringTable: { if (m_mode == M_client) { writeError(assetErrorFileLocalizedStringTable, *warningListIter, totalErrorCountLocalizedStringTable); } } break; case AT_objectTemplate: { writeError(assetErrorFileObjectTemplate, *warningListIter, totalErrorCountObjectTemplate); } break; case AT_portalProperty: { if (m_mode == M_client) { writeError(assetErrorFilePortalProperty, *warningListIter, totalErrorCountPortalProperty); } } break; case AT_shaderTemplate: { if (m_mode == M_client) { writeError(assetErrorFileShaderTemplate, *warningListIter, totalErrorCountShaderTemplate); } } break; case AT_skyBox: { if (m_mode == M_client) { writeError(assetErrorFileSkyBox, *warningListIter, totalErrorCountSkyBox); } } break; case AT_slotDescriptor: { if (m_mode == M_client) { writeError(assetErrorFileSlotDescriptor, *warningListIter, totalErrorCountSlotDescriptor); } } break; case AT_soundTemplate: { if (m_mode == M_client) { writeError(assetErrorFileSoundTemplate, *warningListIter, totalErrorCountSoundTemplate); } } break; case AT_terrain: { if (m_mode == M_client) { writeError(assetErrorFileTerrain, *warningListIter, totalErrorCountTerrain); } } break; case AT_texture: { if (m_mode == M_client) { writeError(assetErrorFileTexture, *warningListIter, totalErrorCountTexture); } } break; case AT_textureRendererTemplate: { if (m_mode == M_client) { writeError(assetErrorFileTextureRenderer, *warningListIter, totalErrorCountTextureRenderer); } } break; default: { DEBUG_REPORT_LOG_PRINT(true, ("DataLint::remove() - Unsupported asset type: %s", warningListIter->first.c_str())); } break; } // Write the error to the master error file writeError(assetErrorFileAll, *warningListIter, totalErrorCountAll); // If this is a fatal, write to the fatal list if (strstr(warningListIter->first.c_str(), "FATAL:")) { writeError(assetErrorFileAllFatal, *warningListIter, totalErrorCountAllFatal); } // If a warning, write to the warning list if (strstr(warningListIter->first.c_str(), "WARNING:")) { writeError(assetErrorFileAllWarning, *warningListIter, totalErrorCountAllWarning); } } } // UnSupported Assets DEBUG_REPORT_LOG_PRINT(true, ("Writing unsupported assets list: %s\n", m_dataLintUnSupportedAssetsFile.c_str())); FILE *fp = fopen(m_dataLintUnSupportedAssetsFile.c_str(), "wt"); if (fp) { StringPairList unSupportedStringPairList(getList(AT_unSupported)); StringPairList::iterator stringPairListIter = unSupportedStringPairList.begin(); int count = 1; for (; stringPairListIter != unSupportedStringPairList.end(); ++stringPairListIter) { fprintf(fp, "%3d %s @ %s\n", count, stringPairListIter->first.c_str(), stringPairListIter->second.c_str()); ++count; } fclose(fp); } else { DEBUG_REPORT_LOG_PRINT(true, ("Error writing unsupported assets list: %s\n", m_dataLintUnSupportedAssetsFile.c_str())); } // Categorized Assets DEBUG_REPORT_LOG_PRINT(true, ("Writing categorized files list: %s\n", m_dataLintCategorizedAssetsFile.c_str())); fp = fopen(m_dataLintCategorizedAssetsFile.c_str(), "wt"); if (fp) { fprintf(fp, "This file contains a categorized listing of the linted assets in the game. The categories are as follows:\n"); fprintf(fp, "\n"); fprintf(fp, "1. Appearances (%5d)\n", getList(AT_appearance).size()); fprintf(fp, "2. Arrangement Descriptors (%5d)\n", getList(AT_arrangementDescriptor).size()); fprintf(fp, "3. Localized String Tables (%5d)\n", getList(AT_localizedStringTable).size()); fprintf(fp, "4. Object Templates (%5d)\n", getList(AT_objectTemplate).size()); fprintf(fp, "5. Portal Properties (%5d)\n", getList(AT_portalProperty).size()); fprintf(fp, "6. Shader Templates (%5d)\n", getList(AT_shaderTemplate).size()); fprintf(fp, "7. SkyBoxes (%5d)\n", getList(AT_skyBox).size()); fprintf(fp, "8. Slot Descriptors (%5d)\n", getList(AT_slotDescriptor).size()); fprintf(fp, "9. Sound Templates (%5d)\n", getList(AT_soundTemplate).size()); fprintf(fp, "10. Terrain (%5d)\n", getList(AT_terrain).size()); fprintf(fp, "11. Textures (%5d)\n", getList(AT_texture).size()); fprintf(fp, "12. Texture Renderer Templates (%5d)\n", getList(AT_textureRendererTemplate).size()); fprintf(fp, "--------------------------------------\n"); fprintf(fp, "13. Total Linted Assets (%5d)\n", m_assetList->size() - getList(AT_unSupported).size()); fprintf(fp, "\n"); writeToCategorizedFile(fp, "Appearances", AT_appearance); writeToCategorizedFile(fp, "Arrangement Descriptors", AT_arrangementDescriptor); writeToCategorizedFile(fp, "Localized String Tables", AT_localizedStringTable); writeToCategorizedFile(fp, "Object Templates", AT_objectTemplate); writeToCategorizedFile(fp, "Portal Properties", AT_portalProperty); writeToCategorizedFile(fp, "Shader Templates", AT_shaderTemplate); writeToCategorizedFile(fp, "SkyBoxes", AT_skyBox); writeToCategorizedFile(fp, "Slot Descriptors", AT_slotDescriptor); writeToCategorizedFile(fp, "Sound Templates", AT_soundTemplate); writeToCategorizedFile(fp, "Terrain", AT_terrain); writeToCategorizedFile(fp, "Textures", AT_texture); writeToCategorizedFile(fp, "Texture Renderer Templates", AT_textureRendererTemplate); fclose(fp); } if (assetErrorFileAll) { fclose(assetErrorFileAll); } if (assetErrorFileAllFatal) { fclose(assetErrorFileAllFatal); } if (assetErrorFileAllWarning) { fclose(assetErrorFileAllWarning); } if (assetErrorFileObjectTemplate) { fclose(assetErrorFileObjectTemplate); } if (m_mode == M_client) { if (assetErrorFileAppearance) { fclose(assetErrorFileAppearance); } if (assetErrorFileArrangementDescriptor) { fclose(assetErrorFileArrangementDescriptor); } if (assetErrorFileLocalizedStringTable) { fclose(assetErrorFileLocalizedStringTable); } if (assetErrorFilePortalProperty) { fclose(assetErrorFilePortalProperty); } if (assetErrorFileShaderTemplate) { fclose(assetErrorFileShaderTemplate); } if (assetErrorFileSkyBox) { fclose(assetErrorFileSkyBox); } if (assetErrorFileSlotDescriptor) { fclose(assetErrorFileSlotDescriptor); } if (assetErrorFileSoundTemplate) { fclose(assetErrorFileSoundTemplate); } if (assetErrorFileTerrain) { fclose(assetErrorFileTerrain); } if (assetErrorFileTexture) { fclose(assetErrorFileTexture); } if (assetErrorFileTextureRenderer) { fclose(assetErrorFileTextureRenderer); } } } }