ArgList::iterator Engine::parse(ArgList& list, ArgList::iterator begin) { rebuild(); bool foundNonSwitches = false; ArgList::iterator firstNonSwitch; while (begin != list.end()) { // Parse a row of switches begin = parseConsecutiveSwitches(list, begin); // End of switches? if (begin == list.end()) break; // If the end is the "--" marker, take it out of the list as well if (*begin == "--") { list.eraseAndAdvance(begin); break; } if (!foundNonSwitches) { // Mark the start of non-switches if we haven't done it already firstNonSwitch = begin; foundNonSwitches = true; } // Skip past the non switches while (begin != list.end() && !list.isSwitch(begin)) ++begin; } return foundNonSwitches ? firstNonSwitch : begin; }
/*---------------------------------------------------------------------------*/ void LstringMatcher::update_returned_args(boost::python::dict& args, const std::vector<std::string>& varnames, const ArgList& values) const { std::vector<std::string>::const_iterator itVar = varnames.begin(); ArgList::const_iterator itValue = values.begin(); for(;itVar != varnames.end() && itValue != values.end(); ++itVar, ++itValue) args[*itVar] = *itValue; }
ScheduledAction::ScheduledAction(JSValue function, const ArgList& args) : m_function(function) { ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it) m_args.append(*it); }
UserDialog::UserDialog(int cols, char* caption, const ArgList& args) // TODO: get this to be a child of the main window. :P : wxDialog(0, -1, caption, wxDefaultPosition, wxDefaultSize) , _args(args) { cols += cols; // double cols because we attach a caption to each element wxSizer* sizer = new wxFlexGridSizer(cols, 3, 3); // 3 pix padding on each axis for (ArgList::const_iterator iter = args.begin(); iter != args.end(); iter++) { const std::string name = iter->first; const std::string type = ::toLower(iter->second); if (type == "edit") { wxTextCtrl* t = new wxTextCtrl(this, -1, "", wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator, name.c_str()); t->SetName(name.c_str()); sizer->Add(new wxStaticText(this, -1, name.c_str())); sizer->Add(t); } else { throw std::runtime_error(va("Unknown control type %s", type.c_str())); } } sizer->Add(new wxButton(this, wxID_OK, "Ok")); SetSizer(sizer); sizer->Fit(this); }
JSArray::JSArray(ExecState* exec, PassRefPtr<Structure> structure, const ArgList& list) : JSObject(structure) { unsigned length = list.size(); m_fastAccessCutoff = length; ArrayStorage* storage = static_cast<ArrayStorage*>(fastMalloc(storageSize(length))); storage->m_vectorLength = length; storage->m_numValuesInVector = length; storage->m_sparseValueMap = 0; storage->m_length = length; size_t i = 0; ArgList::const_iterator end = list.end(); for (ArgList::const_iterator it = list.begin(); it != end; ++it, ++i) storage->m_vector[i] = (*it).jsValue(exec); m_storage = storage; // When the array is created non-empty, its cells are filled, so it's really no worse than // a property map. Therefore don't report extra memory cost. checkConsistency(); }
ScheduledAction::ScheduledAction(JSValue function, const ArgList& args, DOMWrapperWorld* isolatedWorld) : m_function(function) , m_isolatedWorld(isolatedWorld) { ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it) m_args.append(*it); }
JSValue JSC_HOST_CALL stringProtoFuncConcat(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) { UString s = thisValue.toThisString(exec); ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it) s += (*it).toString(exec); return jsString(exec, s); }
IndexToNameMap::IndexToNameMap(JSFunction* func, const ArgList& args) { _map = new Identifier[args.size()]; this->size = args.size(); unsigned i = 0; ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++i, ++it) _map[i] = func->getParameterName(i); // null if there is no corresponding parameter }
Analysis::RetType Analysis_AutoCorr::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { const char* calctype; std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = DFLin->AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); lagmax_ = analyzeArgs.getKeyInt("lagmax",-1); calc_covar_ = !analyzeArgs.hasKey("nocovar"); usefft_ = !analyzeArgs.hasKey("direct"); // Select datasets from remaining args ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) dsets_ += datasetlist->GetMultipleSets( *dsa ); if (dsets_.empty()) { mprinterr("Error: autocorr: No data sets selected.\n"); return Analysis::ERR; } // If setname is empty generate a default name if (setname.empty()) setname = datasetlist->GenerateDefaultName( "autocorr" ); // Setup output datasets int idx = 0; MetaData md( setname ); for (DataSetList::const_iterator DS = dsets_.begin(); DS != dsets_.end(); ++DS) { md.SetIdx( idx++ ); DataSet* dsout = datasetlist->AddSet( DataSet::DOUBLE, md ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( (*DS)->Meta().Legend() ); outputData_.push_back( dsout ); // Add set to output file if (outfile != 0) outfile->AddDataSet( outputData_.back() ); } if (calc_covar_) calctype = "covariance"; else calctype = "correlation"; mprintf(" AUTOCORR: Calculating auto-%s for %i data sets:\n", calctype, dsets_.size()); dsets_.List(); if (lagmax_!=-1) mprintf("\tLag max= %i\n", lagmax_); if ( !setname.empty() ) mprintf("\tSet name: %s\n", setname.c_str() ); if ( outfile != 0 ) mprintf("\tOutfile name: %s\n", outfile->DataFilename().base()); if (usefft_) mprintf("\tUsing FFT to calculate %s.\n", calctype); else mprintf("\tUsing direct method to calculate %s.\n", calctype); return Analysis::OK; }
void ArgList::markLists(ListSet& markSet) { ListSet::iterator end = markSet.end(); for (ListSet::iterator it = markSet.begin(); it != end; ++it) { ArgList* list = *it; iterator end2 = list->end(); for (iterator it2 = list->begin(); it2 != end2; ++it2) if (!(*it2).marked()) (*it2).mark(); } }
ArgList::iterator Engine::parseKnownSwitches(ArgList& list, ArgList::iterator begin) { // Parse the first items, chopping them off the list, until it works while (1) { if (begin == list.end()) return begin; if (!list.isSwitch(begin)) break; pair<ArgList::iterator, bool> res = parseFirstIfKnown(list, begin); if (!res.second) break; begin = res.first; } // If requested, stop here if (no_switches_after_first_arg) return begin; // Parse the next items, chopping off the list only those that we know for (ArgList::iterator cur = begin; cur != list.end(); ) { // Skip non-switches if (!list.isSwitch(cur)) { ++cur; continue; } pair<ArgList::iterator, bool> res = parseFirstIfKnown(list, cur); if (!res.second) // If the switch is not handled, move past it ++cur; else cur = res.first; } return begin; }
void ArgList::markLists(ListSet& markSet) { ListSet::iterator end = markSet.end(); for (ListSet::iterator it = markSet.begin(); it != end; ++it) { ArgList* list = *it; iterator end2 = list->end(); for (iterator it2 = list->begin(); it2 != end2; ++it2) { JSValue* v = *it2; if (!v->marked()) v->mark(); } } }
StringType CommandLine::GetArgvStringWithoutProgram() const { ArgList argv = GetArgv(); // Skipt program part. ArgList quoted_args; std::move(std::next(argv.begin()), argv.end(), std::back_inserter(quoted_args)); // Quotes each part only if necessary. std::transform(quoted_args.begin(), quoted_args.end(), quoted_args.begin(), QuoteArg); return JoinString(quoted_args, L" "); }
// Array1D::AddSetsFromArgs() int Array1D::AddSetsFromArgs(ArgList const& dsetArgs, DataSetList const& DSLin) { DataSetList input_dsl; for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) input_dsl += DSLin.GetMultipleSets( *dsa ); if (input_dsl.empty()) { mprinterr("Error: No data sets selected.\n"); return 1; } // Add to main list array_.clear(); if (AddDataSets( input_dsl )) return 1; return 0; }
// ECMA 10.1.8 Arguments::Arguments(ExecState* exec, JSFunction* func, const ArgList& args, JSActivation* act) : JSObject(exec->lexicalGlobalObject()->objectPrototype()) , _activationObject(act) , indexToNameMap(func, args) { putDirect(exec->propertyNames().callee, func, DontEnum); putDirect(exec, exec->propertyNames().length, args.size(), DontEnum); int i = 0; ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it, ++i) { Identifier name = Identifier::from(exec, i); if (!indexToNameMap.isMapped(name)) putDirect(name, *it, DontEnum); } }
void Driver::PrintOptions(const ArgList &Args) const { unsigned i = 0; for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it, ++i) { Arg *A = *it; llvm::errs() << "Option " << i << " - " << "Name: \"" << A->getOption().getName() << "\", " << "Values: {"; for (unsigned j = 0; j < A->getNumValues(); ++j) { if (j) llvm::errs() << ", "; llvm::errs() << '"' << A->getValue(Args, j) << '"'; } llvm::errs() << "}\n"; } }
// ECMA 10.1.8 Arguments::Arguments(ExecState* exec, JSFunction* function, const ArgList& args, JSActivation* activation) : JSObject(exec->lexicalGlobalObject()->objectPrototype()) , d(new ArgumentsData(activation, function, args)) { ASSERT(activation); putDirect(exec->propertyNames().callee, function, DontEnum); putDirect(exec->propertyNames().length, jsNumber(exec, args.size()), DontEnum); int i = 0; ArgList::const_iterator end = args.end(); for (ArgList::const_iterator it = args.begin(); it != end; ++it, ++i) { Identifier name = Identifier::from(exec, i); if (!d->indexToNameMap.isMapped(name)) putDirect(name, (*it).jsValue(exec), DontEnum); } }
bool FuncDef::ListArgDef::ValidateArgs(ExpressionEvaluator evaluator, ArgList &args, string &error) const { if (CheckArgCount(Types.size(), args, error)) { int argNum = 0; auto currExpectedArg = Types.begin(); auto currActualArg = args.begin(); while (currExpectedArg != Types.end() && currActualArg != args.end()) { ++argNum; if (!CheckArg(evaluator, *currActualArg, **currExpectedArg, argNum, error)) return false; ++currExpectedArg; ++currActualArg; } return true; } return false; }
ArgList::iterator OptionEngine::parseConsecutiveSwitches(ArgList& list, ArgList::iterator begin) { while (begin != list.end() && list.isSwitch(*begin)) { pair<ArgList::iterator, bool> res = parseFirstIfKnown(list, begin); if (!res.second) { if ((*begin)[1] != '-') throw exception::BadOption(string("unknown short option ") + *begin); else throw exception::BadOption(string("unknown long option ") + *begin); } begin = res.first; } return begin; }
JSArray::JSArray(NonNullPassRefPtr<Structure> structure, const ArgList& list) : JSObject(structure) { unsigned initialCapacity = list.size(); m_storage = static_cast<ArrayStorage*>(fastMalloc(storageSize(initialCapacity))); m_storage->m_length = initialCapacity; m_vectorLength = initialCapacity; m_storage->m_numValuesInVector = initialCapacity; m_storage->m_sparseValueMap = 0; m_storage->lazyCreationData = 0; m_storage->reportedMapCapacity = 0; size_t i = 0; ArgList::const_iterator end = list.end(); for (ArgList::const_iterator it = list.begin(); it != end; ++it, ++i) m_storage->m_vector[i] = *it; checkConsistency(); Heap::heap(this)->reportExtraMemoryCost(storageSize(initialCapacity)); }
/** Set up histogram with specified data sets. */ Analysis::RetType Analysis_Hist::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { debug_ = debugIn; // Keywords std::string histname = analyzeArgs.GetStringKey("name"); outfilename_ = analyzeArgs.GetStringKey("out"); if (outfilename_.empty()) { mprinterr("Error: Hist: No output filename specified.\n"); return Analysis::ERR; } traj3dName_ = analyzeArgs.GetStringKey("traj3d"); traj3dFmt_ = TrajectoryFile::WriteFormatFromString( analyzeArgs.GetStringKey("trajfmt"), TrajectoryFile::AMBERTRAJ ); parmoutName_ = analyzeArgs.GetStringKey("parmout"); // Create a DataFile here so any DataFile arguments can be processed. If it // turns out later that native output is needed the DataFile will be removed. outfile_ = setup.DFL().AddDataFile(outfilename_, analyzeArgs); if (outfile_==0) return Analysis::ERR; Temp_ = analyzeArgs.getKeyDouble("free",-1.0); if (Temp_!=-1.0) calcFreeE_ = true; else calcFreeE_ = false; gnuplot_ = analyzeArgs.hasKey("gnu"); if (analyzeArgs.hasKey("norm")) normalize_ = NORM_SUM; else if (analyzeArgs.hasKey("normint")) normalize_ = NORM_INT; else normalize_ = NO_NORM; circular_ = analyzeArgs.hasKey("circular"); nativeOut_ = analyzeArgs.hasKey("nativeout"); if ( analyzeArgs.Contains("min") ) { default_min_ = analyzeArgs.getKeyDouble("min", 0.0); minArgSet_ = true; } if ( analyzeArgs.Contains("max") ) { default_max_ = analyzeArgs.getKeyDouble("max", 0.0); maxArgSet_ = true; } default_step_ = analyzeArgs.getKeyDouble("step", 0.0) ; default_bins_ = analyzeArgs.getKeyInt("bins", -1); calcAMD_ = false; std::string amdname = analyzeArgs.GetStringKey("amd"); if (!amdname.empty()) { DataSet* ds = setup.DSL().GetDataSet( amdname ); if (ds == 0) { mprinterr("Error: AMD data set %s not found.\n", amdname.c_str()); return Analysis::ERR; } if (ds->Ndim() != 1) { mprinterr("Error: AMD data set must be 1D.\n"); return Analysis::ERR; } amddata_ = (DataSet_1D*)ds; calcAMD_ = true; } // Treat all remaining arguments as dataset names. Do not set up dimensions // yet since the data sets may not be fully populated. ArgList dsetNames = analyzeArgs.RemainingArgs(); for ( ArgList::const_iterator setname = dsetNames.begin(); setname != dsetNames.end(); ++setname) { if (CheckDimension( *setname, setup.DSL() )) return Analysis::ERR; } // histdata contains the DataSets to be histogrammed if (histdata_.empty()) { mprinterr("Error: Hist: No datasets specified.\n"); return Analysis::ERR; } // Total # of dimensions for the histogram is the number of sets to be binned. N_dimensions_ = histdata_.size(); if (!nativeOut_) { switch ( N_dimensions_ ) { case 1: hist_ = setup.DSL().AddSet( DataSet::DOUBLE, histname, "Hist"); break; case 2: hist_ = setup.DSL().AddSet( DataSet::MATRIX_DBL, histname, "Hist"); break; // TODO: GRID_DBL case 3: hist_ = setup.DSL().AddSet( DataSet::GRID_FLT, histname, "Hist"); break; default: // FIXME: GET N DIMENSION CASE! mprintf("Warning: Histogram dimension > 3. DataSet/DataFile output not supported.\n"); nativeOut_ = true; } } // traj3d only supported with 3D histograms if (!traj3dName_.empty() && N_dimensions_ != 3) { mprintf("Warning: 'traj3d' only supported with 3D histograms.\n"); traj3dName_.clear(); parmoutName_.clear(); } if (!nativeOut_) { // DataFile output. Add DataSet to DataFile. if (hist_ == 0) { mprinterr("Error: Could not set up histogram data set.\n"); return Analysis::ERR; } outfile_->AddDataSet( hist_ ); } else { // Native output. Remove DataFile from DataFileList outfile_ = setup.DFL().RemoveDataFile( outfile_ ); native_ = setup.DFL().AddCpptrajFile( outfilename_, "Histogram output" ); if (native_ == 0) return Analysis::ERR; } mprintf("\tHist: %s: Set up for %zu dimensions using the following datasets:\n", outfilename_.c_str(), N_dimensions_); mprintf("\t[ "); for (std::vector<DataSet_1D*>::iterator ds=histdata_.begin(); ds!=histdata_.end(); ++ds) mprintf("%s ",(*ds)->legend()); mprintf("]\n"); if (calcAMD_) mprintf("\tPopulating bins using AMD boost from data set %s\n", amddata_->legend()); if (calcFreeE_) mprintf("\tFree energy in kcal/mol will be calculated from bin populations at %f K.\n",Temp_); if (nativeOut_) mprintf("\tUsing internal routine for output. Data will not be stored on the data set list.\n"); //if (circular_ || gnuplot_) { // mprintf("\tWarning: gnuplot and/or circular specified; advanced grace/gnuplot\n"); // mprintf("\t formatting disabled.\n");*/ if (circular_) mprintf("\tcircular: Output coordinates will be wrapped.\n"); if (gnuplot_ && outfile_ == 0) mprintf("\tgnuplot: Output will be in gnuplot-readable format.\n"); //} if (normalize_ == NORM_SUM) mprintf("\tnorm: Sum over bins will be normalized to 1.0.\n"); else if (normalize_ == NORM_INT) mprintf("\tnormint: Integral over bins will be normalized to 1.0.\n"); if (!traj3dName_.empty()) { mprintf("\tPseudo-trajectory will be written to '%s' with format %s\n", traj3dName_.c_str(), TrajectoryFile::FormatString(traj3dFmt_)); if (!parmoutName_.empty()) mprintf("\tCorresponding pseudo-topology will be written to '%s'\n", parmoutName_.c_str()); } return Analysis::OK; }
/*! This is called by parseSourceFile() to do the actual parsing and tree building. It only processes qdoc comments. It skips everything else. */ bool PureDocParser::processQdocComments() { QSet<QString> topicCommandsAllowed = topicCommands(); QSet<QString> otherMetacommandsAllowed = otherMetaCommands(); QSet<QString> metacommandsAllowed = topicCommandsAllowed + otherMetacommandsAllowed; while (tok != Tok_Eoi) { if (tok == Tok_Doc) { /* lexeme() returns an entire qdoc comment. */ QString comment = lexeme(); Location start_loc(location()); readToken(); Doc::trimCStyleComment(start_loc,comment); Location end_loc(location()); /* Doc parses the comment. */ Doc doc(start_loc,end_loc,comment,metacommandsAllowed); QString topic; ArgList args; QSet<QString> topicCommandsUsed = topicCommandsAllowed & doc.metaCommandsUsed(); /* There should be one topic command in the set, or none. If the set is empty, then the comment should be a function description. */ if (topicCommandsUsed.count() > 0) { topic = *topicCommandsUsed.begin(); args = doc.metaCommandArgs(topic); } NodeList nodes; QList<Doc> docs; if (topic.isEmpty()) { doc.location().warning(tr("This qdoc comment contains no topic command " "(e.g., '\\%1', '\\%2').") .arg(COMMAND_MODULE).arg(COMMAND_PAGE)); } else { /* There is a topic command. Process it. */ if ((topic == COMMAND_QMLPROPERTY) || (topic == COMMAND_QMLATTACHEDPROPERTY)) { Doc nodeDoc = doc; Node* node = processTopicCommandGroup(nodeDoc,topic,args); if (node != 0) { nodes.append(node); docs.append(nodeDoc); } } else { ArgList::ConstIterator a = args.begin(); while (a != args.end()) { Doc nodeDoc = doc; Node* node = processTopicCommand(nodeDoc,topic,*a); if (node != 0) { nodes.append(node); docs.append(nodeDoc); } ++a; } } } Node* treeRoot = QDocDatabase::qdocDB()->treeRoot(); NodeList::Iterator n = nodes.begin(); QList<Doc>::Iterator d = docs.begin(); while (n != nodes.end()) { processOtherMetaCommands(*d, *n); (*n)->setDoc(*d); checkModuleInclusion(*n); if ((*n)->isInnerNode() && ((InnerNode *)*n)->includes().isEmpty()) { InnerNode *m = static_cast<InnerNode *>(*n); while (m->parent() && m->parent() != treeRoot) m = m->parent(); if (m == *n) ((InnerNode *)*n)->addInclude((*n)->name()); else ((InnerNode *)*n)->setIncludes(m->includes()); } ++d; ++n; } } else { readToken(); } } return true; }
static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args, DiagnosticEngine &Diags, const FrontendOptions &FrontendOpts, StringRef SDKPath, StringRef ResourceDir) { using namespace options; if (const Arg *A = Args.getLastArg(OPT_g_Group)) { if (A->getOption().matches(OPT_g)) Opts.DebugInfoKind = IRGenDebugInfoKind::Normal; else if (A->getOption().matches(options::OPT_gline_tables_only)) Opts.DebugInfoKind = IRGenDebugInfoKind::LineTables; else assert(A->getOption().matches(options::OPT_gnone) && "unknown -g<kind> option"); if (Opts.DebugInfoKind == IRGenDebugInfoKind::Normal) { ArgStringList RenderedArgs; for (auto A : Args) A->render(Args, RenderedArgs); CompilerInvocation::buildDWARFDebugFlags(Opts.DWARFDebugFlags, RenderedArgs, SDKPath, ResourceDir); // TODO: Should we support -fdebug-compilation-dir? llvm::SmallString<256> cwd; llvm::sys::fs::current_path(cwd); Opts.DebugCompilationDir = cwd.str(); } } for (const Arg *A : make_range(Args.filtered_begin(OPT_l, OPT_framework), Args.filtered_end())) { LibraryKind Kind; if (A->getOption().matches(OPT_l)) { Kind = LibraryKind::Library; } else if (A->getOption().matches(OPT_framework)) { Kind = LibraryKind::Framework; } else { llvm_unreachable("Unknown LinkLibrary option kind"); } Opts.LinkLibraries.push_back(LinkLibrary(A->getValue(), Kind)); } if (auto valueNames = Args.getLastArg(OPT_disable_llvm_value_names, OPT_enable_llvm_value_names)) { Opts.HasValueNamesSetting = true; Opts.ValueNames = valueNames->getOption().matches(OPT_enable_llvm_value_names); } Opts.DisableLLVMOptzns |= Args.hasArg(OPT_disable_llvm_optzns); Opts.DisableLLVMARCOpts |= Args.hasArg(OPT_disable_llvm_arc_opts); Opts.DisableLLVMSLPVectorizer |= Args.hasArg(OPT_disable_llvm_slp_vectorizer); if (Args.hasArg(OPT_disable_llvm_verify)) Opts.Verify = false; Opts.EmitStackPromotionChecks |= Args.hasArg(OPT_stack_promotion_checks); if (const Arg *A = Args.getLastArg(OPT_stack_promotion_limit)) { unsigned limit; if (StringRef(A->getValue()).getAsInteger(10, limit)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.StackPromotionSizeLimit = limit; } if (Args.hasArg(OPT_autolink_force_load)) Opts.ForceLoadSymbolName = Args.getLastArgValue(OPT_module_link_name); // TODO: investigate whether these should be removed, in favor of definitions // in other classes. if (FrontendOpts.PrimaryInput && FrontendOpts.PrimaryInput->isFilename()) { unsigned Index = FrontendOpts.PrimaryInput->Index; Opts.MainInputFilename = FrontendOpts.InputFilenames[Index]; } else if (FrontendOpts.InputFilenames.size() == 1) { Opts.MainInputFilename = FrontendOpts.InputFilenames.front(); } Opts.OutputFilenames = FrontendOpts.OutputFilenames; Opts.ModuleName = FrontendOpts.ModuleName; if (Args.hasArg(OPT_use_jit)) Opts.UseJIT = true; for (const Arg *A : make_range(Args.filtered_begin(OPT_verify_type_layout), Args.filtered_end())) { Opts.VerifyTypeLayoutNames.push_back(A->getValue()); } for (const Arg *A : make_range(Args.filtered_begin( OPT_disable_autolink_framework), Args.filtered_end())) { Opts.DisableAutolinkFrameworks.push_back(A->getValue()); } Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate); Opts.PrintInlineTree |= Args.hasArg(OPT_print_llvm_inline_tree); if (Args.hasArg(OPT_embed_bitcode)) Opts.EmbedMode = IRGenEmbedMode::EmbedBitcode; else if (Args.hasArg(OPT_embed_bitcode_marker)) Opts.EmbedMode = IRGenEmbedMode::EmbedMarker; if (Opts.EmbedMode == IRGenEmbedMode::EmbedBitcode) { // Keep track of backend options so we can embed them in a separate data // section and use them when building from the bitcode. This can be removed // when all the backend options are recorded in the IR. for (ArgList::const_iterator A = Args.begin(), AE = Args.end(); A != AE; ++ A) { // Do not encode output and input. if ((*A)->getOption().getID() == options::OPT_o || (*A)->getOption().getID() == options::OPT_INPUT || (*A)->getOption().getID() == options::OPT_primary_file || (*A)->getOption().getID() == options::OPT_embed_bitcode) continue; ArgStringList ASL; (*A)->render(Args, ASL); for (ArgStringList::iterator it = ASL.begin(), ie = ASL.end(); it != ie; ++ it) { StringRef ArgStr(*it); Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end()); // using \00 to terminate to avoid problem decoding. Opts.CmdArgs.push_back('\0'); } } } if (Args.hasArg(OPT_enable_reflection_metadata)) { Opts.StripReflectionMetadata = false; Opts.StripReflectionNames = false; } if (Args.hasArg(OPT_strip_reflection_names)) { Opts.StripReflectionNames = true; } if (Args.hasArg(OPT_strip_reflection_metadata)) { Opts.StripReflectionMetadata = true; Opts.StripReflectionNames = true; } return false; }
void Driver::BuildActions(const ArgList &Args, ActionList &Actions) const { llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); // Start by constructing the list of inputs and their types. // Track the current user specified (-x) input. We also explicitly // track the argument used to set the type; we only want to claim // the type when we actually use it, so we warn about unused -x // arguments. types::ID InputType = types::TY_Nothing; Arg *InputTypeArg = 0; llvm::SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs; for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) { Arg *A = *it; if (isa<InputOption>(A->getOption())) { const char *Value = A->getValue(Args); types::ID Ty = types::TY_INVALID; // Infer the input type if necessary. if (InputType == types::TY_Nothing) { // If there was an explicit arg for this, claim it. if (InputTypeArg) InputTypeArg->claim(); // stdin must be handled specially. if (memcmp(Value, "-", 2) == 0) { // If running with -E, treat as a C input (this changes the // builtin macros, for example). This may be overridden by // -ObjC below. // // Otherwise emit an error but still use a valid type to // avoid spurious errors (e.g., no inputs). if (!Args.hasArg(options::OPT_E, false)) Diag(clang::diag::err_drv_unknown_stdin_type); Ty = types::TY_C; } else { // Otherwise lookup by extension, and fallback to ObjectType // if not found. We use a host hook here because Darwin at // least has its own idea of what .s is. if (const char *Ext = strrchr(Value, '.')) Ty = Host->lookupTypeForExtension(Ext + 1); if (Ty == types::TY_INVALID) Ty = types::TY_Object; } // -ObjC and -ObjC++ override the default language, but only for "source // files". We just treat everything that isn't a linker input as a // source file. // // FIXME: Clean this up if we move the phase sequence into the type. if (Ty != types::TY_Object) { if (Args.hasArg(options::OPT_ObjC)) Ty = types::TY_ObjC; else if (Args.hasArg(options::OPT_ObjCXX)) Ty = types::TY_ObjCXX; } } else { assert(InputTypeArg && "InputType set w/o InputTypeArg"); InputTypeArg->claim(); Ty = InputType; } // Check that the file exists. It isn't clear this is worth // doing, since the tool presumably does this anyway, and this // just adds an extra stat to the equation, but this is gcc // compatible. if (memcmp(Value, "-", 2) != 0 && !llvm::sys::Path(Value).exists()) Diag(clang::diag::err_drv_no_such_file) << A->getValue(Args); else Inputs.push_back(std::make_pair(Ty, A)); } else if (A->getOption().isLinkerInput()) { // Just treat as object type, we could make a special type for // this if necessary. Inputs.push_back(std::make_pair(types::TY_Object, A)); } else if (A->getOption().getId() == options::OPT_x) { InputTypeArg = A; InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args)); // Follow gcc behavior and treat as linker input for invalid -x // options. Its not clear why we shouldn't just revert to // unknown; but this isn't very important, we might as well be // bug comatible. if (!InputType) { Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args); InputType = types::TY_Object; } } } if (!SuppressMissingInputWarning && Inputs.empty()) { Diag(clang::diag::err_drv_no_input_files); return; } // Determine which compilation mode we are in. We look for options // which affect the phase, starting with the earliest phases, and // record which option we used to determine the final phase. Arg *FinalPhaseArg = 0; phases::ID FinalPhase; // -{E,M,MM} only run the preprocessor. if ((FinalPhaseArg = Args.getLastArg(options::OPT_E)) || (FinalPhaseArg = Args.getLastArg(options::OPT_M)) || (FinalPhaseArg = Args.getLastArg(options::OPT_MM))) { FinalPhase = phases::Preprocess; // -{fsyntax-only,-analyze,emit-llvm,S} only run up to the compiler. } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) || (FinalPhaseArg = Args.getLastArg(options::OPT__analyze, options::OPT__analyze_auto)) || (FinalPhaseArg = Args.getLastArg(options::OPT_S))) { FinalPhase = phases::Compile; // -c only runs up to the assembler. } else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) { FinalPhase = phases::Assemble; // Otherwise do everything. } else FinalPhase = phases::Link; // Reject -Z* at the top level, these options should never have been // exposed by gcc. if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); // Construct the actions to perform. ActionList LinkerInputs; for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { types::ID InputType = Inputs[i].first; const Arg *InputArg = Inputs[i].second; unsigned NumSteps = types::getNumCompilationPhases(InputType); assert(NumSteps && "Invalid number of steps!"); // If the first step comes after the final phase we are doing as // part of this compilation, warn the user about it. phases::ID InitialPhase = types::getCompilationPhase(InputType, 0); if (InitialPhase > FinalPhase) { // Claim here to avoid the more general unused warning. InputArg->claim(); Diag(clang::diag::warn_drv_input_file_unused) << InputArg->getAsString(Args) << getPhaseName(InitialPhase) << FinalPhaseArg->getOption().getName(); continue; } // Build the pipeline for this file. Action *Current = new InputAction(*InputArg, InputType); for (unsigned i = 0; i != NumSteps; ++i) { phases::ID Phase = types::getCompilationPhase(InputType, i); // We are done if this step is past what the user requested. if (Phase > FinalPhase) break; // Queue linker inputs. if (Phase == phases::Link) { assert(i + 1 == NumSteps && "linking must be final compilation step."); LinkerInputs.push_back(Current); Current = 0; break; } // Some types skip the assembler phase (e.g., llvm-bc), but we // can't encode this in the steps because the intermediate type // depends on arguments. Just special case here. if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm) continue; // Otherwise construct the appropriate action. Current = ConstructPhaseAction(Args, Phase, Current); if (Current->getType() == types::TY_Nothing) break; } // If we ended with something, add to the output list. if (Current) Actions.push_back(Current); } // Add a link action if necessary. if (!LinkerInputs.empty()) Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image)); }
void Driver::BuildUniversalActions(const ArgList &Args, ActionList &Actions) const { llvm::PrettyStackTraceString CrashInfo("Building actions for universal build"); // Collect the list of architectures. Duplicates are allowed, but // should only be handled once (in the order seen). llvm::StringSet<> ArchNames; llvm::SmallVector<const char *, 4> Archs; for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) { Arg *A = *it; if (A->getOption().getId() == options::OPT_arch) { const char *Name = A->getValue(Args); // FIXME: We need to handle canonicalization of the specified // arch? A->claim(); if (ArchNames.insert(Name)) Archs.push_back(Name); } } // When there is no explicit arch for this platform, make sure we // still bind the architecture (to the default) so that -Xarch_ is // handled correctly. if (!Archs.size()) Archs.push_back(0); // FIXME: We killed off some others but these aren't yet detected in // a functional manner. If we added information to jobs about which // "auxiliary" files they wrote then we could detect the conflict // these cause downstream. if (Archs.size() > 1) { // No recovery needed, the point of this is just to prevent // overwriting the same files. if (const Arg *A = Args.getLastArg(options::OPT_save_temps)) Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs) << A->getAsString(Args); } ActionList SingleActions; BuildActions(Args, SingleActions); // Add in arch binding and lipo (if necessary) for every top level // action. for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { Action *Act = SingleActions[i]; // Make sure we can lipo this kind of output. If not (and it is an // actual output) then we disallow, since we can't create an // output file with the right name without overwriting it. We // could remove this oddity by just changing the output names to // include the arch, which would also fix // -save-temps. Compatibility wins for now. if (Archs.size() > 1 && !types::canLipoType(Act->getType())) Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) << types::getTypeName(Act->getType()); ActionList Inputs; for (unsigned i = 0, e = Archs.size(); i != e; ++i) Inputs.push_back(new BindArchAction(Act, Archs[i])); // Lipo if necessary, We do it this way because we need to set the // arch flag so that -Xarch_ gets overwritten. if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) Actions.append(Inputs.begin(), Inputs.end()); else Actions.push_back(new LipoJobAction(Inputs, Act->getType())); } }
Analysis::RetType Analysis_Lifetime::Setup(ArgList& analyzeArgs, DataSetList* datasetlist, TopologyList* PFLin, DataFileList* DFLin, int debugIn) { // Get Keywords DataFile* outfile = DFLin->AddDataFile(analyzeArgs.GetStringKey("out"), analyzeArgs); if (outfile != 0) outfile->ProcessArgs("noemptyframes"); DataFile* maxfile = 0; DataFile* avgfile = 0; std::string setname = analyzeArgs.GetStringKey("name"); windowSize_ = analyzeArgs.getKeyInt("window", -1); averageonly_ = analyzeArgs.hasKey("averageonly"); if (!averageonly_ && outfile != 0) { maxfile = DFLin->AddDataFile("max." + outfile->DataFilename().Full(), analyzeArgs); maxfile->ProcessArgs("noemptyframes"); avgfile = DFLin->AddDataFile("avg." + outfile->DataFilename().Full(), analyzeArgs); avgfile->ProcessArgs("noemptyframes"); } cumulative_ = analyzeArgs.hasKey("cumulative"); deltaAvg_ = analyzeArgs.hasKey("delta"); cut_ = analyzeArgs.getKeyDouble("cut", 0.5); // Select datasets from remaining args ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) inputDsets_ += datasetlist->GetMultipleSets( *dsa ); if (inputDsets_.empty()) { mprinterr("Error: lifetime: No data sets selected.\n"); return Analysis::ERR; } // Sort input datasets inputDsets_.sort(); // Create output datasets if ( windowSize_ != -1) { if (setname.empty()) setname = datasetlist->GenerateDefaultName( "lifetime" ); int didx = 0; for (DataSetList::const_iterator set = inputDsets_.begin(); set != inputDsets_.end(); ++set) { DataSet* outSet = datasetlist->AddSetIdx( DataSet::FLOAT, setname, didx ); if (outSet==0) { mprinterr("Error: lifetime: Could not allocate output set for %s\n", (*set)->Legend().c_str()); return Analysis::ERR; } outSet->SetLegend( (*set)->Legend() ); outputDsets_.push_back( outSet ); if (outfile != 0) outfile->AddSet( outSet ); if (!averageonly_) { // MAX // FIXME: CHeck for nullS outSet = datasetlist->AddSetIdxAspect( DataSet::INT, setname, didx, "max" ); outSet->SetLegend( (*set)->Legend() ); maxDsets_.push_back( outSet ); if (maxfile != 0) maxfile->AddSet( outSet ); // AVG outSet = datasetlist->AddSetIdxAspect( DataSet::FLOAT, setname, didx, "avg" ); outSet->SetLegend( (*set)->Legend() ); avgDsets_.push_back( outSet ); if (avgfile != 0) avgfile->AddSet( outSet ); } ++didx; } } else if (outfile != 0) { mprinterr("Error: Output file name specified but no window size given ('window <N>')\n"); return Analysis::ERR; } if (!averageonly_) mprintf(" LIFETIME: Calculating average lifetime using a cutoff of %f", cut_); else mprintf(" LIFETIME: Calculating only averages"); mprintf(" of data in %i sets\n", inputDsets_.size()); if (debugIn > 0) inputDsets_.List(); if (windowSize_ != -1) { mprintf("\tAverage of data over windows will be saved to sets named %s\n", setname.c_str()); mprintf("\tWindow size for averaging: %i\n", windowSize_); if (cumulative_) mprintf("\tCumulative averages will be saved.\n"); if (deltaAvg_) mprintf("\tChange of average from previous average will be saved.\n"); if (outfile != 0) { mprintf("\tOutfile: %s", outfile->DataFilename().base()); if (!averageonly_) mprintf(", %s, %s", maxfile->DataFilename().base(), avgfile->DataFilename().base()); mprintf("\n"); } } return Analysis::OK; }
Analysis::RetType Analysis_AutoCorr::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn) { const char* calctype; std::string setname = analyzeArgs.GetStringKey("name"); DataFile* outfile = setup.DFL().AddDataFile( analyzeArgs.GetStringKey("out"), analyzeArgs ); lagmax_ = analyzeArgs.getKeyInt("lagmax",-1); calc_covar_ = !analyzeArgs.hasKey("nocovar"); usefft_ = !analyzeArgs.hasKey("direct"); // Select datasets from remaining args dsets_.clear(); ArgList dsetArgs = analyzeArgs.RemainingArgs(); for (ArgList::const_iterator dsa = dsetArgs.begin(); dsa != dsetArgs.end(); ++dsa) { DataSetList setsIn = setup.DSL().GetMultipleSets( *dsa ); for (DataSetList::const_iterator ds = setsIn.begin(); ds != setsIn.end(); ++ds) { if ( (*ds)->Group() != DataSet::SCALAR_1D && (*ds)->Type() != DataSet::VECTOR ) mprintf("Warning: Set '%s' type not supported in AUTOCORR - skipping.\n", (*ds)->legend()); else dsets_.push_back( *ds ); } } if (dsets_.empty()) { mprinterr("Error: No data sets selected.\n"); return Analysis::ERR; } // If setname is empty generate a default name if (setname.empty()) setname = setup.DSL().GenerateDefaultName( "autocorr" ); // Setup output datasets MetaData md( setname ); for (unsigned int idx = 0; idx != dsets_.size(); idx++) { md.SetIdx( idx ); DataSet* dsout = setup.DSL().AddSet( DataSet::DOUBLE, md ); if (dsout==0) return Analysis::ERR; dsout->SetLegend( dsets_[idx]->Meta().Legend() ); outputData_.push_back( dsout ); // Add set to output file if (outfile != 0) outfile->AddDataSet( outputData_.back() ); } if (calc_covar_) calctype = "covariance"; else calctype = "correlation"; mprintf(" AUTOCORR: Calculating auto-%s for %i data sets:\n\t", calctype, dsets_.size()); for (unsigned int idx = 0; idx != dsets_.size(); ++idx) mprintf(" %s", dsets_[idx]->legend()); mprintf("\n"); if (lagmax_!=-1) mprintf("\tLag max= %i\n", lagmax_); if ( !setname.empty() ) mprintf("\tSet name: %s\n", setname.c_str() ); if ( outfile != 0 ) mprintf("\tOutfile name: %s\n", outfile->DataFilename().base()); if (usefft_) mprintf("\tUsing FFT to calculate %s.\n", calctype); else mprintf("\tUsing direct method to calculate %s.\n", calctype); return Analysis::OK; }
ArgList::iterator Engine::parse(ArgList& list, ArgList::iterator begin) { rebuild(); // Parse and remove known switches begin = parseKnownSwitches(list, begin); m_found_command = 0; // Check if we have to handle commands if (!m_commands.empty()) { // Look for the first non-switch in the list ArgList::iterator cmd = begin; while (cmd != list.end() && list.isSwitch(cmd)) ++cmd; if (cmd != list.end()) { // A command has been found, ensure that we can handle it map<string, Engine*>::iterator a = m_aliases.find(*cmd); if (a == m_aliases.end()) throw exception::BadOption("unknown command " + *cmd); // Remove the command from the list if (cmd == begin) ++begin; list.erase(cmd); // We found a valid command, let's enable subcommand parsing m_found_command = a->second; } } if (!m_found_command) { // If we don't have any more subcommands to parse, then ensure that // there are no switches left to process for (ArgList::iterator i = begin; i != list.end(); ++i) { if (*i == "--") { // Remove '--' and stop looking for switches if (begin == i) { begin++; list.erase(i); } break; } if (list.isSwitch(i)) throw exception::BadOption(string("unknown option ") + *i); else if (no_switches_after_first_arg) // If requested, stop looking for switches // after the first non-switch argument break; } m_found_command = 0; return begin; } else { // Else, invoke the subcommand engine on the list return m_found_command->parse(list, begin); } }