int main(int argc, const char** argv) { try{ e1.assign(expression_text); e2.assign(pre_expression); for(int i = 1; i < argc; ++i) { std::cout << "Processing file " << argv[i] << std::endl; std::ifstream fs(argv[i]); std::string in; load_file(in, fs); fs.close(); std::string out_name = std::string(argv[i]) + std::string(".htm"); std::ofstream os(out_name.c_str()); os << header_text; // strip '<' and '>' first by outputting to a // temporary string stream std::ostringstream t(std::ios::out | std::ios::binary); std::ostream_iterator<char> oi(t); boost::regex_replace(oi, in.begin(), in.end(), e2, pre_format, boost::match_default | boost::format_all); // then output to final output stream // adding syntax highlighting: std::string s(t.str()); std::ostream_iterator<char> out(os); boost::regex_replace(out, s.begin(), s.end(), e1, format_string, boost::match_default | boost::format_all); os << footer_text; os.close(); } } catch(...) { return -1; } return 0; }
//Extracts opcodes out of the client QStringList OpcodeFinder::ExtractOpcodes(QString path) { QStringList opcodes; QFile file(path); //Open the file if(file.open(QIODevice::ReadOnly)) { //Read the file data and convert it to hex std::string data = QString(file.readAll().toHex()).toUpper().toAscii().data(); file.close(); if(data.empty()) { //No data read QMessageBox::critical(this, "Error", "No data was read from the client."); } else { //Regex string for locating opcodes const static boost::regex e("C744240C(?<opcode>....)0000C7442410........E8........8D|8D..24108D..2418....8BCEC7442418(?<opcode>....)0000C744241C........E8|8B4E10C7442410(?<opcode>....)000041C74424..........518BCEE8"); boost::match_results<std::string::const_iterator> what; boost::match_flag_type flags = boost::match_default; std::string::const_iterator start = data.begin(); std::string::const_iterator end = data.end(); try { //Search while(boost::regex_search(start, end, what, e, flags)) { //Get the opcode std::string temp = what["opcode"]; //Add it to the list opcodes.append((temp.substr(2, 2) + temp.substr(0, 2)).c_str()); //Next start = what[0].second; flags |= boost::match_prev_avail; flags |= boost::match_not_bob; } } catch(std::exception & e) { //Display error message (regular expression is probably outdated for this client) QMessageBox::critical(this, "Error", e.what()); } } } else { //File open error QMessageBox::critical(this, "Error", QString("Unable to open %0 for reading. Could not extract opcodes.").arg(path)); } return opcodes; }
/** * Generic tokenizer. * Splits source into tokens and tries to lexically cast them to TARGET. * If that fails, boost::bad_lexical_cast is thrown. * \param source the source string to be split up * \param separator regular expression to delimit the tokens (defaults to \\s+) * \param prefix regular expression for text to be removed from the string before it is split up * ("^" if not given, will be added at the beginning) * \param postfix regular expression for text to be removed from the string before it is split up * ("$" if not given, will be added at the end) * \returns a list of the casted tokens */ template<typename TARGET> std::list<TARGET> stringToList( std::string source, const boost::regex &separator, boost::regex prefix, boost::regex postfix ) { std::list<TARGET> ret; assert( ! separator.empty() ); if ( ! prefix.empty() ) { if ( prefix.str()[0] != '^' ) prefix = boost::regex( std::string( "^" ) + prefix.str(), prefix.flags() ); source = boost::regex_replace( source, prefix, "", boost::format_first_only | boost::match_default ); } if ( ! postfix.empty() ) { if ( postfix.str()[postfix.size() - 1] != '$' ) postfix = boost::regex( postfix.str() + "$", postfix.flags() ); source = boost::regex_replace( source, postfix, "", boost::format_first_only | boost::match_default ); } boost::sregex_token_iterator i = boost::make_regex_token_iterator( source, separator, -1 ); const boost::sregex_token_iterator token_end; while ( i != token_end ) { ret.push_back( boost::lexical_cast<TARGET>( ( i++ )->str() ) ); } return ret; }
bool operator()(boost::regex& r) const { try { if (wildCard) { r.assign(AirUtil::regexEscape(pattern, true), boost::regex::icase); } else { r.assign(pattern); } return true; } catch(const std::runtime_error&) { LogManager::getInstance()->message(STRING_F(INVALID_PATTERN, pattern), LogManager::LOG_ERROR); return false; } }
bool EnumService::parse_regex_replace(const std::string& regex_replace, boost::regex& regex, std::string& replace) { bool success = false; // Split the regular expression into the match and replace sections. RFC3402 // says any character other than 1-9 or i can be the delimiter, but // recommends / or !. We just use the first character and reject if it // doesn't neatly split the regex into two. std::vector<std::string> match_replace; Utils::split_string(regex_replace, regex_replace[0], match_replace); if (match_replace.size() == 2) { TRC_DEBUG("Split regex into match=%s, replace=%s", match_replace[0].c_str(), match_replace[1].c_str()); try { regex.assign(match_replace[0], boost::regex::extended); replace = match_replace[1]; success = true; } catch (...) { success = false; } } else { success = false; } return success; }
void Location::parseGprmc(string gprmc) { DebugOut(7)<<"parsing gprmc message"<<endl; regularExpression.assign(gprmcRegEx); boost::smatch tokens; if (boost::regex_match (gprmc, tokens, regularExpression) ) { if(tokens[4] == "A") { isActive = true; } int i=0; for(auto tok : tokens) { DebugOut(0)<<i++<<":"<<tok<<endl; } parseTime(tokens[1],tokens[2],tokens[3],tokens[13],tokens[14],tokens[15]); parseLatitude(tokens[5], tokens[6], tokens[7]); parseLongitude(tokens[8], tokens[9], tokens[10]); parseSpeed(tokens[11]); parseDirection(tokens[12]); } }
bool operator()(const boost::regex& r) const { try { return !r.empty() && boost::regex_search(str, r); } catch(const std::runtime_error&) { // most likely a stack overflow, ignore... return false; } }
int ChessEngineGnu::match(const string &str, boost::regex &re, vector<string> &matches) { boost::cmatch what; matches.clear(); GC_TRACE("match(): %s\n", re.str().c_str()); if( boost::regex_match(str.c_str(), what, re) ) { // what[0] is the whole string for(size_t i=1; i<what.size(); ++i) { GC_TRACE(" \"%s\"\n", what[i].str().c_str()); matches.push_back(what[i].str()); } } GC_TRACE(" %zu matches\n", matches.size()); return (int)matches.size(); }
TestCaseReader::TestCaseReader(const boost::filesystem::path & testCaseDir) { const boost::regex expr("(\\d{3,4})-(.*)\\.xml"); for (boost::filesystem::directory_iterator it = boost::filesystem::directory_iterator(testCaseDir); it != boost::filesystem::directory_iterator(); ++it) { const boost::filesystem::path path = it->path(); //ignore files that don't end in ".xml" if (path.extension() != ".xml") { continue; } #if defined (BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION == 3 const std::string filename = path.filename().string(); #else const std::string filename = path.filename(); #endif boost::smatch matchResults; if (boost::regex_match(filename,matchResults,expr)) { //std::wcout << "Found testcase " << matchResults[1].str().c_str() << " brief description '" << matchResults[2].str().c_str()<< "'" << std::endl; const size_t tc = boost::lexical_cast<size_t>(matchResults[1]); if (m_testCases.size() < (tc + 1)) { m_testCases.resize(tc + 1); } if (m_testCases[tc] != NULL) { std::wcerr << "There appears to be two test cases with number " << tc << std::endl; exit(1); } std::ostringstream xml; xml << boost::filesystem::ifstream(path).rdbuf(); //std::wcout << "Read xml (" << xml.str().size() << " bytes) '" << xml.str().c_str() << "'" << std::endl; try { m_testCases[tc] = boost::dynamic_pointer_cast<DoseTest::Items::TestCase> (Safir::Dob::Typesystem::Serialization::ToObject(Safir::Dob::Typesystem::Utilities::ToWstring(xml.str()))); } catch (const std::exception & exc) { std::wcerr << "Failed to read file '" << path.string().c_str() << "' due to exception with message" << std::endl <<exc.what() << std::endl; exit(2); } } else { std::wcerr << "File '" << path.filename().c_str() << "' did not match the pattern for test case files: '" << expr.str().c_str() << "'" << std::endl; } } }
void write( const string& sourceFilepath, pwiz::identdata::IdentDataFile::Format outputFormat, const string& filenameSuffix, const string& searchEngineName, const string& searchEngineVersion, const string& searchEngineURI, const string& searchDatabase, boost::regex cleavageAgentRegex, const string& decoyPrefix, const RunTimeVariableMap& vars ) const { using namespace pwiz::identdata; namespace msdata = pwiz::msdata; namespace proteome = pwiz::proteome; IdentData mzid; mzid.id = sourceFilepath + " " + searchDatabase + " " + searchEngineName + " " + searchEngineVersion; mzid.creationDate = GetDateTime(); // add default CVs mzid.cvs = defaultCVList(); // add the SpectrumIdentificationProtocol SpectrumIdentificationProtocolPtr sipPtr(new SpectrumIdentificationProtocol("SIP")); mzid.analysisProtocolCollection.spectrumIdentificationProtocol.push_back(sipPtr); CVTranslator cvTranslator; CVID searchEngineCVID = cvTranslator.translate(searchEngineName); // add analysis software sipPtr->analysisSoftwarePtr.reset(new AnalysisSoftware("AS")); mzid.analysisSoftwareList.push_back(sipPtr->analysisSoftwarePtr); // set software name if (searchEngineCVID != CVID_Unknown) sipPtr->analysisSoftwarePtr->softwareName.set(searchEngineCVID); else sipPtr->analysisSoftwarePtr->softwareName.set(MS_custom_unreleased_software_tool, searchEngineName); // set version and URI sipPtr->analysisSoftwarePtr->version = searchEngineVersion; sipPtr->analysisSoftwarePtr->URI = searchEngineURI; // set search type sipPtr->searchType.cvid = MS_ms_ms_search; // add a mass table for all MS levels MassTablePtr massTable(new MassTable("MT")); massTable->msLevel.push_back(1); massTable->msLevel.push_back(2); massTable->msLevel.push_back(3); sipPtr->massTable.push_back(massTable); // specify amino acid masses used const char* residueSymbols = "ACDEFGHIKLMNPQRSTUVWY"; for (int i=0; i < 21; ++i) { const AminoAcid::Info::Record& record = AminoAcid::Info::record(residueSymbols[i]); ResiduePtr rp(new Residue); rp->code = record.symbol; rp->mass = record.residueFormula.monoisotopicMass(); massTable->residues.push_back(rp); } // add the SpectrumIdentificationList SpectrumIdentificationListPtr silPtr(new SpectrumIdentificationList("SIL")); mzid.dataCollection.analysisData.spectrumIdentificationList.push_back(silPtr); if (vars.count("SearchStats: Overall")) { string searchStats = vars.find("SearchStats: Overall")->second; silPtr->numSequencesSearched = lexical_cast<int>(searchStats.substr(0, searchStats.find_first_of(' '))); } // add the SpectrumIdentification SpectrumIdentificationPtr siPtr(new SpectrumIdentification("SI")); siPtr->spectrumIdentificationListPtr = silPtr; siPtr->spectrumIdentificationProtocolPtr = sipPtr; siPtr->activityDate = mzid.creationDate; mzid.analysisCollection.spectrumIdentification.push_back(siPtr); // add search database SearchDatabasePtr sdb(new SearchDatabase("SDB")); sdb->fileFormat.cvid = MS_FASTA_format; sdb->location = searchDatabase; sdb->name = bfs::path(searchDatabase).filename(); sdb->set(MS_database_type_amino_acid); sdb->databaseName.userParams.push_back(UserParam("database name", sdb->name, "xsd:string")); mzid.dataCollection.inputs.searchDatabase.push_back(sdb); mzid.analysisCollection.spectrumIdentification[0]->searchDatabase.push_back(sdb); // add source file SpectraDataPtr spectraData(new SpectraData("SD")); spectraData->location = sourceFilepath; spectraData->name = bfs::path(spectraData->location).filename(); mzid.dataCollection.inputs.spectraData.push_back(spectraData); mzid.analysisCollection.spectrumIdentification[0]->inputSpectra.push_back(spectraData); // set source file format (required for a semantically valid mzIdentML file) msdata::ReaderPtr readers(new msdata::FullReaderList); CVID sourceFileFormat = msdata::identifyFileFormat(readers, sourceFilepath); if (sourceFileFormat != CVID_Unknown) spectraData->fileFormat.cvid = sourceFileFormat; else if (outputFormat == IdentDataFile::Format_MzIdentML) throw runtime_error("[SearchSpectraList::write] unable to determine source file format of \"" + sourceFilepath + "\""); { msdata::MSDataFile msd(sourceFilepath, readers.get()); spectraData->spectrumIDFormat.cvid = msdata::id::getDefaultNativeIDFormat(msd); } // add the cleavage rules EnzymePtr enzyme(new Enzyme); enzyme->id = "ENZ_" + lexical_cast<string>(sipPtr->enzymes.enzymes.size()+1); enzyme->terminalSpecificity = (proteome::Digestion::Specificity) lexical_cast<int>(vars.find("Config: MinTerminiCleavages")->second); enzyme->nTermGain = "H"; enzyme->cTermGain = "OH"; enzyme->missedCleavages = lexical_cast<int>(vars.find("Config: MaxMissedCleavages")->second); enzyme->minDistance = 1; enzyme->siteRegexp = cleavageAgentRegex.str(); CVID cleavageAgent = proteome::Digestion::getCleavageAgentByRegex(enzyme->siteRegexp); if (cleavageAgent != CVID_Unknown) enzyme->enzymeName.set(cleavageAgent); sipPtr->enzymes.enzymes.push_back(enzyme); // use monoisotopic mass unless PrecursorMzToleranceRule forces average bool forceAverageMass = vars.find("Config: PrecursorMzToleranceRule")->second == "avg"; if (forceAverageMass) sipPtr->additionalSearchParams.set(MS_parent_mass_type_average); else sipPtr->additionalSearchParams.set(MS_parent_mass_type_mono); sipPtr->additionalSearchParams.set(MS_fragment_mass_type_mono); MZTolerance precursorMzTolerance; string precursorMassType = forceAverageMass ? "Avg" : "Mono"; parse(precursorMzTolerance, vars.find("Config: " + precursorMassType + "PrecursorMzTolerance")->second); sipPtr->parentTolerance.set(MS_search_tolerance_minus_value, precursorMzTolerance.value); sipPtr->parentTolerance.set(MS_search_tolerance_plus_value, precursorMzTolerance.value); sipPtr->parentTolerance.cvParams[0].units = sipPtr->parentTolerance.cvParams[1].units = precursorMzTolerance.units == MZTolerance::PPM ? UO_parts_per_million : UO_dalton; MZTolerance fragmentMzTolerance; parse(fragmentMzTolerance, vars.find("Config: FragmentMzTolerance")->second); sipPtr->fragmentTolerance.set(MS_search_tolerance_minus_value, fragmentMzTolerance.value); sipPtr->fragmentTolerance.set(MS_search_tolerance_plus_value, fragmentMzTolerance.value); sipPtr->fragmentTolerance.cvParams[0].units = sipPtr->fragmentTolerance.cvParams[1].units = fragmentMzTolerance.units == MZTolerance::PPM ? UO_parts_per_million : UO_dalton; sipPtr->threshold.set(MS_no_threshold); string fragmentationRule = vars.find("Config: FragmentationRule")->second; if (bal::icontains(fragmentationRule, "cid")) translateIonSeriesConsidered(*sipPtr, "b,y"); if (bal::icontains(fragmentationRule, "etd")) translateIonSeriesConsidered(*sipPtr, "c,z+1"); if (bal::icontains(fragmentationRule, "manual")) translateIonSeriesConsidered(*sipPtr, fragmentationRule.substr(7)); // skip "manual:" DynamicModSet dynamicMods( vars.find("Config: DynamicMods")->second ); BOOST_FOREACH(const DynamicMod& mod, dynamicMods) { SearchModificationPtr searchModification(new SearchModification); switch( mod.unmodChar ) { case PEPTIDE_N_TERMINUS_SYMBOL: searchModification->massDelta = mod.modMass; searchModification->fixedMod = false; searchModification->specificityRules.cvid = MS_modification_specificity_N_term; break; case PEPTIDE_C_TERMINUS_SYMBOL: searchModification->massDelta = mod.modMass; searchModification->fixedMod = false; searchModification->specificityRules.cvid = MS_modification_specificity_C_term; break; default: { string specificity; // either empty, n, or c, but not both if (mod.NTerminalFilters.size() == 1 && mod.NTerminalFilters[0].m_filter[PEPTIDE_N_TERMINUS_SYMBOL]) specificity += 'n'; else if (mod.CTerminalFilters.size() == 1 && mod.CTerminalFilters[0].m_filter[PEPTIDE_C_TERMINUS_SYMBOL]) specificity += 'c'; searchModification->massDelta = mod.modMass; searchModification->residues.push_back(mod.unmodChar); searchModification->fixedMod = false; if (specificity == "n") searchModification->specificityRules.cvid = MS_modification_specificity_N_term; else if (specificity == "c") searchModification->specificityRules.cvid = MS_modification_specificity_C_term; break; } } sipPtr->modificationParams.push_back(searchModification); }
void bcp_implementation::copy_path(const fs::path& p) { assert(!fs::is_directory(m_boost_path / p)); if(fs::exists(m_dest_path / p)) { std::cout << "Copying (and overwriting) file: " << p.string() << "\n"; fs::remove(m_dest_path / p); } else std::cout << "Copying file: " << p.string() << "\n"; // // create the path to the new file if it doesn't already exist: // create_path(p.branch_path()); // // do text based copy if requested: // if(p.leaf() == "Jamroot") { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { libname_matcher.assign("boost_"); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, m_namespace_name + "_"); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && m_lib_names.size() && is_jam_file(p)) { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { std::string re = "\\<"; re += *m_lib_names.begin(); for(std::set<std::string>::const_iterator i = ++m_lib_names.begin(); i != m_lib_names.end(); ++i) { re += "|" + *i; } re += "\\>"; libname_matcher.assign(re); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, get_new_library_name(m_namespace_name)); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && is_source_file(p)) { // // v1 hold the current content, v2 is temp buffer. // Each time we do a search and replace the new content // ends up in v2: we then swap v1 and v2, and clear v2. // static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static const boost::regex namespace_matcher( "(?|" "(namespace\\s+)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+)(adstl|phoenix|rapidxml)\\>" "|" "()\\<boost((?:_(?!intrusive_tags)\\w+)?\\s*(?:::))(?:(\\s*)phoenix)?" "|" "()\\<((?:adstl|phoenix|rapidxml)\\s*(?:::))" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?(?:\\w+\\s*::\\s*)?)(adstl|phoenix|rapidxml)\\>" "|" "(^\\s*#\\s*define\\s+\\w+\\s+)boost((?:_\\w+)?\\s*)$" "|" "(^\\s*#\\s*define[^\\n]+)((?:adstl|phoenix|rapidxml)\\s*)$" "|" "()boost(_asio_detail_posix_thread_function|_regex_free_static_mutex)" "|" "()(lw_thread_routine|at_thread_exit|on_process_enter|on_process_exit|on_thread_enter|on_thread_exit|tss_cleanup_implemented)" "|" "(BOOST_CLASS_REQUIRE4?[^;]*)boost((?:_\\w+)?\\s*,)" "|" "(\\(\\s*)boost(\\s*\\))" ")" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_matcher, "$1" + m_namespace_name + "$2(?3$3" + m_namespace_name + "phoenix)", boost::regex_constants::format_all); std::swap(v1, v2); v2.clear(); if(m_namespace_alias) { static const boost::regex namespace_alias( /* "namespace\\s+" + m_namespace_name + "\\s*" "(" "\\{" "(?:" "(?>[^\\{\\}/]+)" "(?>" "(?:" "(?1)" "|//[^\\n]+$" "|/[^/]" "|(?:^\\s*#[^\\n]*" "(?:(?<=\\\\)\\n[^\\n]*)*)" ")" "[^\\{\\}]+" ")*" ")*" "\\}" ")" */ /* "(namespace\\s+" + m_namespace_name + "\\s*\\{.*" "\\})([^\\{\\};]*)\\z" */ "namespace\\s+" + m_namespace_name + "\\s*\\{" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_alias, "namespace " + m_namespace_name + "{} namespace boost = " + m_namespace_name + "; namespace " + m_namespace_name + "{"); std::swap(v1, v2); v2.clear(); } std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); if(v1.size()) os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_unix_lines && !is_binary_file(p)) { std::ifstream is((m_boost_path / p).c_str()); std::istreambuf_iterator<char> isi(is); std::istreambuf_iterator<char> end; std::ofstream os((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); std::ostreambuf_iterator<char> osi(os); std::copy(isi, end, osi); } else { // binary copy: fs::copy_file(m_boost_path / p, m_dest_path / p); } }
MarkExtracter(std::ostream& inOutStream, const DesignSharedPtr& inDesign, string inPattern) : mStream(inOutStream), mDesign(inDesign), mPattern(inPattern) { mStream << "Searching for '" << mPattern << "'" << std::endl; mStream << "NEAT" << std::endl; mRegex.assign(mPattern); }
int main(int argc, char * argv[]) { try{ po::options_description opts("Options"); opts.add_options() ("help,h", "produce help message") //("after-context,A", po::value<int>(&after_context)->default_value(0), "Print arg lines of trailing context after matching lines. Places a line containing -- between contiguous groups of matches.") //("before-context,B", po::value<int>(&before_context)->default_value(0), "Print arg lines of leading context before matching lines. Places a line containing -- between contiguous groups of matches.") //("context,C", po::value<int>(), "Print arg lines of output context. Places a line containing -- between contiguous groups of matches.") ("byte-offset,b", "Print the byte offset within the input file before each line of output.") ("count,c", "Suppress normal output; instead print a count of matching lines for each input file. With the -v, --invert-match option (see below), count non-matching lines.") ("extended-regexp,E", "Interpret PATTERN as an POSIX-extended regular expression.") ("perl-regexp,P", "Interpret PATTERN as a Perl regular expression.") //("regexp,e", po::value<std::string>(&pattern), "Use PATTERN as the pattern; useful to protect patterns beginning with -.") ("basic-regexp,G", "Interpret arg as a POSIX-basic regular expression (see below). This is the default.") ("ignore-case,i", "Ignore case distinctions in both the PATTERN and the input files.") ("files-without-match,L", "Suppress normal output; instead print the name of each input file from which no output would normally have been printed. The scanning will stop on the first match.") ("files-with-matches,l", "Suppress normal output; instead print the name of each input file from which output would normally have been printed. The scanning will stop on the first match.") ("line-number,n", "Prefix each line of output with the line number within its input file.") ; // Hidden options, will be allowed both on command line and // in config file, but will not be shown to the user. po::options_description hidden("Hidden options"); hidden.add_options() ("input-file", po::value< std::vector<std::string> >(), "input file") ("input-pattern", po::value< std::string >(), "input file") ; po::options_description cmdline_options; cmdline_options.add(opts).add(hidden); po::positional_options_description p; p.add("input-pattern", 1); p.add("input-file", -1); po::variables_map vm; po::store(po::command_line_parser(argc, argv).options(cmdline_options)/*.options(hidden)*/.positional(p).run(), vm); po::notify(vm); if (vm.count("help")) { std::cout << opts << "\n"; return 0; } if (vm.count("context")) { after_context = vm["context"].as< int >(); before_context = after_context; } if(vm.count("extended-regexp")) { flags = boost::regex_constants::extended; } if(vm.count("basic-regexp")) { flags = boost::regex_constants::basic; } if(vm.count("perl-regexp")) { flags = boost::regex_constants::perl; } if(vm.count("ignore-case")) { flags |= boost::regex_constants::icase; } if(vm.count("byte-offset")) { print_byte_offset = true; } if(vm.count("count")) { count_only = true; } if(vm.count("files-without-match")) { print_non_matching_files = true; } if(vm.count("files-with-matches")) { files_only = true; } if(vm.count("line-number")) { print_line_numbers = true; } if(vm.count("input-pattern")) { pattern = vm["input-pattern"].as< std::string >(); re.assign(pattern, flags); } else { std::cerr << "No pattern specified" << std::endl; return 1; } if (vm.count("input-file")) { const std::vector<std::string>& files = vm["input-file"].as< std::vector<std::string> >(); file_count = files.size(); for(std::vector<std::string>::const_iterator i = files.begin(); i != files.end(); ++i) { process_file(*i); } } else { // no input files, scan stdin instead: process_stream(std::cin); } } catch(const std::exception& e) { std::cerr << e.what() << std::endl; } return 0; }
int main (int argc, const char *argv[]) { Filesystem::convert_native_arguments (argc, (const char **)argv); ArgParse ap; ap.options ("iinfo -- print information about images\n" OIIO_INTRO_STRING "\n" "Usage: iinfo [options] filename...", "%*", parse_files, "", "--help", &help, "Print help message", "-v", &verbose, "Verbose output", "-m %s", &metamatch, "Metadata names to print (default: all)", "-f", &filenameprefix, "Prefix each line with the filename", "-s", &sum, "Sum the image sizes", "-a", &subimages, "Print info about all subimages", "--hash", &compute_sha1, "Print SHA-1 hash of pixel values", "--stats", &compute_stats, "Print image pixel statistics (data window)", NULL); if (ap.parse(argc, argv) < 0 || filenames.empty()) { std::cerr << ap.geterror() << std::endl; ap.usage (); return EXIT_FAILURE; } if (help) { ap.usage (); exit (EXIT_FAILURE); } if (! metamatch.empty()) field_re.assign (metamatch, boost::regex::extended | boost::regex_constants::icase); // Find the longest filename size_t longestname = 0; BOOST_FOREACH (const std::string &s, filenames) longestname = std::max (longestname, s.length()); longestname = std::min (longestname, (size_t)40); long long totalsize = 0; BOOST_FOREACH (const std::string &s, filenames) { ImageInput *in = ImageInput::open (s.c_str()); if (! in) { std::string err = geterror(); if (err.empty()) err = Strutil::format ("Could not open \"%s\"", s.c_str()); std::cerr << "iinfo: " << err << "\n"; continue; } ImageSpec spec = in->spec(); print_info (s, longestname, in, spec, verbose, sum, totalsize); in->close (); delete in; }