int Font::cacheAllFontNames() { nameFileMap.clear(); fileNameMap.clear(); Array<String> fontFiles; Array<String> fontNames; enumFontFilesAndNames(Adder<Array<String>, String>(fontFiles), Adder<Array<String>, String>(fontNames)); int count = fontFiles.getCount(); BL_ASSERT(count == fontNames.getCount()); for (int i = 0; i < count; ++i) { BaseLib::Console::trace << fontNames[i] << ": " << fontFiles[i] << BaseLib::Streams::newLine; nameFileMap[fontNames[i]] = fontFiles[i]; fileNameMap[fontFiles[i]] = fontNames[i]; } return count; }
void Directory::getFileInfo(StringMap &map) const { // Note: fileInfo must not contain path map.clear(); map["name"] = fileName(); map["time"] << fileTime(); if(fileIsDir()) map["type"] = "directory"; else { map["type"] = "file"; map["size"] << fileSize(); } }
void findSubstringInChunk(string S, int startPos, int wordLength, int wordNum, StringMap &Lmap, vector<int> &result) { int start = startPos; int strLength = (int)S.length(); StringMap candidate; int wordCount = 0; while (start + wordLength <= strLength) { // we can safely try S[start...start + wordLength - 1] string word = S.substr(start, wordLength); // compare word with every element in L auto findWord = Lmap.find(word); if (findWord == Lmap.end()) { candidate.clear(); wordCount = 0; } else { // insert this word into the candidate auto it = candidate.find(word); if (it == candidate.end()) { candidate[word] = 1; } else { candidate[word]++; } wordCount++; if (wordCount == wordNum) { // test whether candidate is the same as Lmap if (compareStringMap(candidate, Lmap)) { // we have found one! result.push_back(start - (wordNum - 1) * wordLength); } // remove the first word in the candidate word = S.substr(start - (wordNum - 1) * wordLength, wordLength); candidate[word]--; if (candidate[word] == 0) { // remove this item candidate.erase(word); } wordCount--; } } start += wordLength; } }
void cl::ParseCommandLineOptions(int argc, char **argv, const char *Overview, bool ReadResponseFiles) { // Process all registered options. SmallVector<Option*, 4> PositionalOpts; SmallVector<Option*, 4> SinkOpts; StringMap<Option*> Opts; GetOptionInfo(PositionalOpts, SinkOpts, Opts); assert((!Opts.empty() || !PositionalOpts.empty()) && "No options specified!"); // Expand response files. std::vector<char*> newArgv; if (ReadResponseFiles) { newArgv.push_back(strdup(argv[0])); ExpandResponseFiles(argc, argv, newArgv); argv = &newArgv[0]; argc = static_cast<int>(newArgv.size()); } // Copy the program name into ProgName, making sure not to overflow it. std::string ProgName = sys::path::filename(argv[0]); size_t Len = std::min(ProgName.size(), size_t(79)); memcpy(ProgramName, ProgName.data(), Len); ProgramName[Len] = '\0'; ProgramOverview = Overview; bool ErrorParsing = false; // Check out the positional arguments to collect information about them. unsigned NumPositionalRequired = 0; // Determine whether or not there are an unlimited number of positionals bool HasUnlimitedPositionals = false; Option *ConsumeAfterOpt = 0; if (!PositionalOpts.empty()) { if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { assert(PositionalOpts.size() > 1 && "Cannot specify cl::ConsumeAfter without a positional argument!"); ConsumeAfterOpt = PositionalOpts[0]; } // Calculate how many positional values are _required_. bool UnboundedFound = false; for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); i != e; ++i) { Option *Opt = PositionalOpts[i]; if (RequiresValue(Opt)) ++NumPositionalRequired; else if (ConsumeAfterOpt) { // ConsumeAfter cannot be combined with "optional" positional options // unless there is only one positional argument... if (PositionalOpts.size() > 2) ErrorParsing |= Opt->error("error - this positional option will never be matched, " "because it does not Require a value, and a " "cl::ConsumeAfter option is active!"); } else if (UnboundedFound && !Opt->ArgStr[0]) { // This option does not "require" a value... Make sure this option is // not specified after an option that eats all extra arguments, or this // one will never get any! // ErrorParsing |= Opt->error("error - option can never match, because " "another positional argument will match an " "unbounded number of values, and this option" " does not require a value!"); } UnboundedFound |= EatsUnboundedNumberOfValues(Opt); } HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; } // PositionalVals - A vector of "positional" arguments we accumulate into // the process at the end. // SmallVector<std::pair<StringRef,unsigned>, 4> PositionalVals; // If the program has named positional arguments, and the name has been run // across, keep track of which positional argument was named. Otherwise put // the positional args into the PositionalVals list... Option *ActivePositionalArg = 0; // Loop over all of the arguments... processing them. bool DashDashFound = false; // Have we read '--'? for (int i = 1; i < argc; ++i) { Option *Handler = 0; Option *NearestHandler = 0; std::string NearestHandlerString; StringRef Value; StringRef ArgName = ""; // If the option list changed, this means that some command line // option has just been registered or deregistered. This can occur in // response to things like -load, etc. If this happens, rescan the options. if (OptionListChanged) { PositionalOpts.clear(); SinkOpts.clear(); Opts.clear(); GetOptionInfo(PositionalOpts, SinkOpts, Opts); OptionListChanged = false; } // Check to see if this is a positional argument. This argument is // considered to be positional if it doesn't start with '-', if it is "-" // itself, or if we have seen "--" already. // if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { // Positional argument! if (ActivePositionalArg) { ProvidePositionalOption(ActivePositionalArg, argv[i], i); continue; // We are done! } if (!PositionalOpts.empty()) { PositionalVals.push_back(std::make_pair(argv[i],i)); // All of the positional arguments have been fulfulled, give the rest to // the consume after option... if it's specified... // if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt != 0) { for (++i; i < argc; ++i) PositionalVals.push_back(std::make_pair(argv[i],i)); break; // Handle outside of the argument processing loop... } // Delay processing positional arguments until the end... continue; } } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && !DashDashFound) { DashDashFound = true; // This is the mythical "--"? continue; // Don't try to process it as an argument itself. } else if (ActivePositionalArg && (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { // If there is a positional argument eating options, check to see if this // option is another positional argument. If so, treat it as an argument, // otherwise feed it to the eating positional. ArgName = argv[i]+1; // Eat leading dashes. while (!ArgName.empty() && ArgName[0] == '-') ArgName = ArgName.substr(1); Handler = LookupOption(ArgName, Value, Opts); if (!Handler || Handler->getFormattingFlag() != cl::Positional) { ProvidePositionalOption(ActivePositionalArg, argv[i], i); continue; // We are done! } } else { // We start with a '-', must be an argument. ArgName = argv[i]+1; // Eat leading dashes. while (!ArgName.empty() && ArgName[0] == '-') ArgName = ArgName.substr(1); Handler = LookupOption(ArgName, Value, Opts); // Check to see if this "option" is really a prefixed or grouped argument. if (Handler == 0) Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing, Opts); // Otherwise, look for the closest available option to report to the user // in the upcoming error. if (Handler == 0 && SinkOpts.empty()) NearestHandler = LookupNearestOption(ArgName, Opts, NearestHandlerString); } if (Handler == 0) { if (SinkOpts.empty()) { errs() << ProgramName << ": Unknown command line argument '" << argv[i] << "'. Try: '" << argv[0] << " -help'\n"; if (NearestHandler) { // If we know a near match, report it as well. errs() << ProgramName << ": Did you mean '-" << NearestHandlerString << "'?\n"; } ErrorParsing = true; } else { for (SmallVectorImpl<Option*>::iterator I = SinkOpts.begin(), E = SinkOpts.end(); I != E ; ++I) (*I)->addOccurrence(i, "", argv[i]); } continue; } // If this is a named positional argument, just remember that it is the // active one... if (Handler->getFormattingFlag() == cl::Positional) ActivePositionalArg = Handler; else ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); } // Check and handle positional arguments now... if (NumPositionalRequired > PositionalVals.size()) { errs() << ProgramName << ": Not enough positional command line arguments specified!\n" << "Must specify at least " << NumPositionalRequired << " positional arguments: See: " << argv[0] << " -help\n"; ErrorParsing = true; } else if (!HasUnlimitedPositionals && PositionalVals.size() > PositionalOpts.size()) { errs() << ProgramName << ": Too many positional arguments specified!\n" << "Can specify at most " << PositionalOpts.size() << " positional arguments: See: " << argv[0] << " -help\n"; ErrorParsing = true; } else if (ConsumeAfterOpt == 0) { // Positional args have already been handled if ConsumeAfter is specified. unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { if (RequiresValue(PositionalOpts[i])) { ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, PositionalVals[ValNo].second); ValNo++; --NumPositionalRequired; // We fulfilled our duty... } // If we _can_ give this option more arguments, do so now, as long as we // do not give it values that others need. 'Done' controls whether the // option even _WANTS_ any more. // bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; while (NumVals-ValNo > NumPositionalRequired && !Done) { switch (PositionalOpts[i]->getNumOccurrencesFlag()) { case cl::Optional: Done = true; // Optional arguments want _at most_ one value // FALL THROUGH case cl::ZeroOrMore: // Zero or more will take all they can get... case cl::OneOrMore: // One or more will take all they can get... ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, PositionalVals[ValNo].second); ValNo++; break; default: llvm_unreachable("Internal error, unexpected NumOccurrences flag in " "positional argument processing!"); } } } } else { assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); unsigned ValNo = 0; for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) if (RequiresValue(PositionalOpts[j])) { ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], PositionalVals[ValNo].first, PositionalVals[ValNo].second); ValNo++; } // Handle the case where there is just one positional option, and it's // optional. In this case, we want to give JUST THE FIRST option to the // positional option and keep the rest for the consume after. The above // loop would have assigned no values to positional options in this case. // if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], PositionalVals[ValNo].first, PositionalVals[ValNo].second); ValNo++; } // Handle over all of the rest of the arguments to the // cl::ConsumeAfter command line option... for (; ValNo != PositionalVals.size(); ++ValNo) ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, PositionalVals[ValNo].first, PositionalVals[ValNo].second); } // Loop over args and make sure all required args are specified! for (StringMap<Option*>::iterator I = Opts.begin(), E = Opts.end(); I != E; ++I) { switch (I->second->getNumOccurrencesFlag()) { case Required: case OneOrMore: if (I->second->getNumOccurrences() == 0) { I->second->error("must be specified at least once!"); ErrorParsing = true; } // Fall through default: break; } } // Now that we know if -debug is specified, we can use it. // Note that if ReadResponseFiles == true, this must be done before the // memory allocated for the expanded command line is free()d below. DEBUG(dbgs() << "Args: "; for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' '; dbgs() << '\n'; );
StringTable() { m_map.clear(); m_vec.clear(); m_invalid = "invalid-string"; }
/** * Entry point. Arguably the most common function in all applications. * @param argc the number of arguments. * @param argv the actual arguments. * @return return value for the caller to tell we succeed or not. */ int main(int argc, char *argv[]) { bool ignorenext = true; char *filename = NULL; char *ext = NULL; char *delimiter = NULL; bool append = false; bool verbose = false; for (int i = 0; i < argc; i++) { if (ignorenext) { ignorenext = false; continue; } if (argv[i][0] == '-') { /* Append */ if (strncmp(argv[i], "-a", 2) == 0) append = true; /* Include dir */ if (strncmp(argv[i], "-I", 2) == 0) { if (argv[i][2] == '\0') { i++; _include_dirs.insert(strdup(argv[i])); } else { _include_dirs.insert(strdup(&argv[i][2])); } continue; } /* Define */ if (strncmp(argv[i], "-D", 2) == 0) { char *p = strchr(argv[i], '='); if (p != NULL) *p = '\0'; _defines.insert(strdup(&argv[i][2])); continue; } /* Output file */ if (strncmp(argv[i], "-f", 2) == 0) { if (filename != NULL) continue; filename = strdup(&argv[i][2]); continue; } /* Object file extension */ if (strncmp(argv[i], "-o", 2) == 0) { if (ext != NULL) continue; ext = strdup(&argv[i][2]); continue; } /* Starting string delimiter */ if (strncmp(argv[i], "-s", 2) == 0) { if (delimiter != NULL) continue; delimiter = strdup(&argv[i][2]); continue; } /* Verbose */ if (strncmp(argv[i], "-v", 2) == 0) verbose = true; continue; } ScanFile(argv[i], ext, false, verbose); } /* Default output file is Makefile */ if (filename == NULL) filename = strdup("Makefile"); /* Default delimiter string */ if (delimiter == NULL) delimiter = strdup("# DO NOT DELETE"); char backup[PATH_MAX]; strcpy(backup, filename); strcat(backup, ".bak"); char *content = NULL; long size = 0; /* Read in the current file; so we can overwrite everything from the * end of non-depend data marker down till the end. */ FILE *src = fopen(filename, "rb"); if (src != NULL) { fseek(src, 0, SEEK_END); size = ftell(src); rewind(src); content = (char*)malloc(size * sizeof(*content)); if (fread(content, 1, size, src) != (size_t)size) { fprintf(stderr, "Could not read %s\n", filename); exit(-2); } fclose(src); } FILE *dst = fopen(filename, "w"); bool found_delimiter = false; if (size != 0) { src = fopen(backup, "wb"); if (fwrite(content, 1, size, src) != (size_t)size) { fprintf(stderr, "Could not write %s\n", filename); exit(-2); } fclose(src); /* Then append it to the real file. */ src = fopen(backup, "rb"); while (fgets(content, size, src) != NULL) { fputs(content, dst); if (!strncmp(content, delimiter, strlen(delimiter))) found_delimiter = true; if (!append && found_delimiter) break; } fclose(src); } if (!found_delimiter) fprintf(dst, "\n%s\n", delimiter); for (StringMap::iterator it = _files.begin(); it != _files.end(); it++) { for (StringSet::iterator h = it->second->begin(); h != it->second->end(); h++) { fprintf(dst, "%s: %s\n", it->first, *h); } } /* Clean up our mess. */ fclose(dst); free(delimiter); free(filename); free(ext); free(content); for (StringMap::iterator it = _files.begin(); it != _files.end(); it++) { for (StringSet::iterator h = it->second->begin(); h != it->second->end(); h++) { free(*h); } it->second->clear(); delete it->second; free(it->first); } _files.clear(); for (StringMap::iterator it = _headers.begin(); it != _headers.end(); it++) { for (StringSet::iterator h = it->second->begin(); h != it->second->end(); h++) { free(*h); } it->second->clear(); delete it->second; free(it->first); } _headers.clear(); for (StringSet::iterator it = _defines.begin(); it != _defines.end(); it++) { free(*it); } _defines.clear(); for (StringSet::iterator it = _include_dirs.begin(); it != _include_dirs.end(); it++) { free(*it); } _include_dirs.clear(); return 0; }
int main (int argc, char *argv[]) { if(argc < 2) { ERR("usage: \n" << argv[0] << " <file.osm/.osm.bz2/.osm.pbf> [<profile.lua>]"); } /*** Setup Scripting Environment ***/ ScriptingEnvironment scriptingEnvironment((argc > 2 ? argv[2] : "profile.lua"), argv[1]); unsigned numberOfThreads = omp_get_num_procs(); if(testDataFile("extractor.ini")) { ExtractorConfiguration extractorConfig("extractor.ini"); unsigned rawNumber = stringToInt(extractorConfig.GetParameter("Threads")); if( rawNumber != 0 && rawNumber <= numberOfThreads) numberOfThreads = rawNumber; } omp_set_num_threads(numberOfThreads); INFO("extracting data from input file " << argv[1]); bool isPBF(false); std::string outputFileName(argv[1]); std::string restrictionsFileName(argv[1]); std::string::size_type pos = outputFileName.find(".osm.bz2"); if(pos==std::string::npos) { pos = outputFileName.find(".osm.pbf"); if(pos!=std::string::npos) { isPBF = true; } } if(pos!=string::npos) { outputFileName.replace(pos, 8, ".osrm"); restrictionsFileName.replace(pos, 8, ".osrm.restrictions"); } else { pos=outputFileName.find(".osm"); if(pos!=string::npos) { outputFileName.replace(pos, 5, ".osrm"); restrictionsFileName.replace(pos, 5, ".osrm.restrictions"); } else { outputFileName.append(".osrm"); restrictionsFileName.append(".osrm.restrictions"); } } unsigned amountOfRAM = 1; unsigned installedRAM = GetPhysicalmemory(); if(installedRAM < 2048264) { WARN("Machine has less than 2GB RAM."); } StringMap stringMap; ExtractionContainers externalMemory; stringMap[""] = 0; extractCallBacks = new ExtractorCallbacks(&externalMemory, &stringMap); BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> * parser; if(isPBF) { parser = new PBFParser(argv[1]); } else { parser = new XMLParser(argv[1]); } parser->RegisterCallbacks(extractCallBacks); parser->RegisterScriptingEnvironment(scriptingEnvironment); if(!parser->Init()) ERR("Parser not initialized!"); double time = get_timestamp(); parser->Parse(); INFO("parsing finished after " << get_timestamp() - time << " seconds"); externalMemory.PrepareData(outputFileName, restrictionsFileName, amountOfRAM, scriptingEnvironment.luaStateVector[0]); stringMap.clear(); delete parser; delete extractCallBacks; INFO("finished"); std::cout << "\nRun:\n" "./osrm-prepare " << outputFileName << " " << restrictionsFileName << std::endl; return 0; }
int main (int argc, char *argv[]) { if(argc < 2) { ERR("usage: \n" << argv[0] << " <file.osm/.osm.bz2/.osm.pbf> [<profile.lua>]"); } INFO("extracting data from input file " << argv[1]); bool isPBF(false); std::string outputFileName(argv[1]); std::string restrictionsFileName(argv[1]); std::string::size_type pos = outputFileName.find(".osm.bz2"); if(pos==std::string::npos) { pos = outputFileName.find(".osm.pbf"); if(pos!=std::string::npos) { isPBF = true; } } if(pos!=string::npos) { outputFileName.replace(pos, 8, ".osrm"); restrictionsFileName.replace(pos, 8, ".osrm.restrictions"); } else { pos=outputFileName.find(".osm"); if(pos!=string::npos) { outputFileName.replace(pos, 5, ".osrm"); restrictionsFileName.replace(pos, 5, ".osrm.restrictions"); } else { outputFileName.append(".osrm"); restrictionsFileName.append(".osrm.restrictions"); } } /*** Setup Scripting Environment ***/ // Create a new lua state lua_State *myLuaState = luaL_newstate(); // Connect LuaBind to this lua state luabind::open(myLuaState); // Add our function to the state's global scope luabind::module(myLuaState) [ luabind::def("print", LUA_print<std::string>), luabind::def("parseMaxspeed", parseMaxspeed), luabind::def("durationIsValid", durationIsValid), luabind::def("parseDuration", parseDuration) ]; if(0 != luaL_dostring( myLuaState, "print('Initializing LUA engine')\n" )) { ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block"); } luabind::module(myLuaState) [ luabind::class_<HashTable<std::string, std::string> >("keyVals") .def("Add", &HashTable<std::string, std::string>::Add) .def("Find", &HashTable<std::string, std::string>::Find) ]; luabind::module(myLuaState) [ luabind::class_<ImportNode>("Node") .def(luabind::constructor<>()) .def_readwrite("lat", &ImportNode::lat) .def_readwrite("lon", &ImportNode::lon) .def_readwrite("id", &ImportNode::id) .def_readwrite("bollard", &ImportNode::bollard) .def_readwrite("traffic_light", &ImportNode::trafficLight) .def_readwrite("tags", &ImportNode::keyVals) ]; luabind::module(myLuaState) [ luabind::class_<_Way>("Way") .def(luabind::constructor<>()) .def_readwrite("name", &_Way::name) .def_readwrite("speed", &_Way::speed) .def_readwrite("type", &_Way::type) .def_readwrite("access", &_Way::access) .def_readwrite("roundabout", &_Way::roundabout) .def_readwrite("is_duration_set", &_Way::isDurationSet) .def_readwrite("is_access_restricted", &_Way::isAccessRestricted) .def_readwrite("ignore_in_grid", &_Way::ignoreInGrid) .def_readwrite("tags", &_Way::keyVals) .def_readwrite("direction", &_Way::direction) .enum_("constants") [ luabind::value("notSure", 0), luabind::value("oneway", 1), luabind::value("bidirectional", 2), luabind::value("opposite", 3) ] ]; // Now call our function in a lua script INFO("Parsing speedprofile from " << (argc > 2 ? argv[2] : "profile.lua") ); if(0 != luaL_dofile(myLuaState, (argc > 2 ? argv[2] : "profile.lua") )) { ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block"); } //open utility libraries string library; luaL_openlibs(myLuaState); /*** End of Scripting Environment Setup; ***/ unsigned amountOfRAM = 1; unsigned installedRAM = GetPhysicalmemory(); if(installedRAM < 2048264) { WARN("Machine has less than 2GB RAM."); } /* if(testDataFile("extractor.ini")) { ExtractorConfiguration extractorConfig("extractor.ini"); unsigned memoryAmountFromFile = atoi(extractorConfig.GetParameter("Memory").c_str()); if( memoryAmountFromFile != 0 && memoryAmountFromFile <= installedRAM/(1024*1024)) amountOfRAM = memoryAmountFromFile; INFO("Using " << amountOfRAM << " GB of RAM for buffers"); } */ StringMap stringMap; ExtractionContainers externalMemory; stringMap[""] = 0; extractCallBacks = new ExtractorCallbacks(&externalMemory, &stringMap); BaseParser<_Node, _RawRestrictionContainer, _Way> * parser; if(isPBF) { parser = new PBFParser(argv[1]); } else { parser = new XMLParser(argv[1]); } parser->RegisterCallbacks(&nodeFunction, &restrictionFunction, &wayFunction); parser->RegisterLUAState(myLuaState); if(!parser->Init()) INFO("Parser not initialized!"); parser->Parse(); externalMemory.PrepareData(outputFileName, restrictionsFileName, amountOfRAM); stringMap.clear(); delete parser; delete extractCallBacks; INFO("[extractor] finished."); std::cout << "\nRun:\n" "./osrm-prepare " << outputFileName << " " << restrictionsFileName << std::endl; return 0; }
void SymbolType::deleteAll(){ WriteLock l=WL(Types::tSymbol); locations.clear(); strings.clear(); }