int CStatsUtil::DoExportGameScripts() { //Validate output + input paths Poco::Path inpath(m_inputPath); Poco::Path outpath; if( m_outputPath.empty() ) outpath = inpath.absolute().makeParent().append(DefExportScriptsDir); else outpath = Poco::Path(m_outputPath).makeAbsolute(); Poco::File fTestOut = outpath; if( ! fTestOut.exists() ) { cout << "Created output directory \"" << fTestOut.path() <<"\"!\n"; fTestOut.createDirectory(); } else if( ! fTestOut.isDirectory() ) throw runtime_error("CStatsUtil::DoExportGameScripts(): Output path is not a directory!"); //Setup the script handler GameScripts scripts( inpath.absolute().toString() ); //Convert to XML scripts.ExportScriptsToXML( outpath.toString() ); return 0; }
Solver::Solver(const Decomposition& decomposition, const Application& app, const std::vector<std::string>& encodingFiles, bool tableMode, bool cardinalityCost, bool printStatistics) : ::Solver(decomposition, app) , encodingFiles(encodingFiles) , tableMode(tableMode) , cardinalityCost(cardinalityCost) , printStatistics(printStatistics) { Gringo::message_printer()->disable(Gringo::W_ATOM_UNDEFINED); #ifndef DISABLE_CHECKS // TODO: Implement tables::EncodingChecker if(!tableMode) { // Check the encoding, but only in the decomposition root. // Otherwise we'd probably do checks redundantly. if(decomposition.isRoot()) { std::ofstream dummyStream; std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, dummyStream)); Gringo::Input::Program program; asp_utils::DummyGringoModule module; Gringo::Scripts scripts(module); Gringo::Defines defs; std::unique_ptr<EncodingChecker> encodingChecker{new trees::EncodingChecker(scripts, program, *out, defs)}; Gringo::Input::NonGroundParser parser(*encodingChecker); for(const auto& file : encodingFiles) parser.pushFile(std::string(file)); parser.parse(); encodingChecker->check(); } } #endif }
/* <% scripts(patterns); %> Where patterns may contain *, ** and !pattern for exclusion */ PUBLIC void scripts(cchar *patterns) { HttpStream *stream; HttpRx *rx; HttpRoute *route; EspRoute *eroute; MprList *files; MprJson *cscripts, *script; cchar *uri, *path, *version; int next, ci; stream = getStream(); rx = stream->rx; route = rx->route; eroute = route->eroute; patterns = httpExpandRouteVars(route, patterns); if (!patterns || !*patterns) { version = espGetConfig(route, "version", "1.0.0"); if (eroute->combineScript) { scripts(eroute->combineScript); } else if (espGetConfig(route, "http.content.combine[@=js]", 0)) { if (espGetConfig(route, "http.content.minify[@=js]", 0)) { eroute->combineScript = sfmt("all-%s.min.js", version); } else { eroute->combineScript = sfmt("all-%s.js", version); } scripts(eroute->combineScript); } else { if ((cscripts = mprGetJsonObj(route->config, "client.scripts")) != 0) { for (ITERATE_JSON(cscripts, script, ci)) { scripts(script->value); } } } return; }
vector < ustring > scripts_get_all() // Gets a list of available scripts. { // Read available scripts and clean them up. ReadFiles rf(Directories->get_scripts(), script_prefix(stEnd), ""); for (unsigned int i = 0; i < rf.files.size(); i++) { for (int scripttype = stSed; scripttype < stEnd; scripttype++) { ustring prefix = script_prefix((ScriptType) scripttype); ustring source_suffix = script_suffix((ScriptType) scripttype, false); ustring binary_suffix = script_suffix((ScriptType) scripttype, true); if (g_str_has_prefix(rf.files[i].c_str(), prefix.c_str())) { rf.files[i].erase(0, prefix.length()); } if (!source_suffix.empty()) { if (g_str_has_suffix(rf.files[i].c_str(), source_suffix.c_str())) { rf.files[i].erase(rf.files[i].length() - source_suffix.length(), source_suffix.length()); } } if (!binary_suffix.empty()) { if (g_str_has_suffix(rf.files[i].c_str(), binary_suffix.c_str())) { rf.files[i].erase(rf.files[i].length() - binary_suffix.length(), binary_suffix.length()); } } } } // In cases of TECkit, there is the .map script and the compiled .tec script. // These both have the same name, so we have two scripts of the same name. // Remove any double names. set < ustring > scriptset(rf.files.begin(), rf.files.end()); vector < ustring > scripts(scriptset.begin(), scriptset.end()); // Sort them. sort(scripts.begin(), scripts.end()); // Add the "straight through" script at the start. scripts.insert(scripts.begin(), scripts_straight_through()); // Return them. return scripts; }
int CStatsUtil::DoImportGameScripts() { //Validate output + input paths Poco::Path inpath(m_inputPath); Poco::Path outpath; if( m_outputPath.empty() ) throw runtime_error("CStatsUtil::DoImportGameScripts() : Output path is empty!"); if( !utils::isFolder( m_outputPath ) ) throw runtime_error("CStatsUtil::DoImportGameScripts() : Output path doesn't exist, or isn't a directory!"); outpath = Poco::Path(m_outputPath); //Setup the script handler GameScripts scripts( outpath.absolute().toString() ); //Import from XML scripts.ImportScriptsFromXML( inpath.absolute().toString() ); return 0; }
Solver::Solver(const Decomposition& decomposition, const Application& app, const std::vector<std::string>& encodingFiles, bool reground, BranchAndBoundLevel bbLevel) : ::LazySolver(decomposition, app, bbLevel) , reground(reground) , encodingFiles(encodingFiles) { Gringo::message_printer()->disable(Gringo::W_ATOM_UNDEFINED); if(!reground) { // Set up ASP solver config.solve.numModels = 0; Clasp::Asp::LogicProgram& claspProgramBuilder = static_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config, true)); // TODO In leaves updates might not be necessary. struct LazyGringoOutputProcessor : GringoOutputProcessor { LazyGringoOutputProcessor(Solver* s, Clasp::Asp::LogicProgram& prg) : GringoOutputProcessor(prg), self(s) { } void storeAtom(unsigned int atomUid, Gringo::Value v) override { const std::string& n = *v.name(); if(n == "childItem") { ASP_CHECK(v.args().size() == 1, "'childItem' predicate does not have arity 1"); std::ostringstream argument; v.args().front().print(argument); self->itemsToLitIndices.emplace(String(argument.str()), self->literals.size()); self->literals.push_back(Clasp::posLit(atomUid)); } else if(n == "childAuxItem") { ASP_CHECK(v.args().size() == 1, "'childAuxItem' predicate does not have arity 1"); std::ostringstream argument; v.args().front().print(argument); self->auxItemsToLitIndices.emplace(String(argument.str()), self->literals.size()); self->literals.push_back(Clasp::posLit(atomUid)); } GringoOutputProcessor::storeAtom(atomUid, v); } Solver* self; } gringoOutput(this, claspProgramBuilder); std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, gringoOutput)); Gringo::Input::Program program; asp_utils::DummyGringoModule module; Gringo::Scripts scripts(module); Gringo::Defines defs; Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs); Gringo::Input::NonGroundParser parser(gringoProgramBuilder); // Input: Induced subinstance std::unique_ptr<std::stringstream> instanceInput(new std::stringstream); asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag()); app.getPrinter().solverInvocationInput(decomposition, instanceInput->str()); // Input: Decomposition std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream); asp_utils::declareDecomposition(decomposition, *decompositionInput); app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str()); // Pass input to ASP solver for(const auto& file : encodingFiles) parser.pushFile(std::string(file)); parser.pushStream("<instance>", std::move(instanceInput)); parser.pushStream("<decomposition>", std::move(decompositionInput)); parser.parse(); // Ground program.rewrite(defs); program.check(); if(Gringo::message_printer()->hasError()) throw std::runtime_error("Grounding stopped because of errors"); auto gPrg = program.toGround(out->domains); Gringo::Ground::Parameters params; params.add("base", {}); gPrg.ground(params, scripts, *out); params.clear(); // Set value of external atoms to free for(const auto& p : literals) claspProgramBuilder.freeze(p.var(), Clasp::value_free); // Finalize ground program and create solver literals claspProgramBuilder.endProgram(); // Map externals to their solver literals for(auto& p : literals) { p = claspProgramBuilder.getLiteral(p.var()); assert(!p.watched()); // Literal must not be watched } for(const auto& atom : gringoOutput.getItemAtomInfos()) itemAtomInfos.emplace_back(ItemAtomInfo(atom, claspProgramBuilder)); for(const auto& atom : gringoOutput.getAuxItemAtomInfos()) auxItemAtomInfos.emplace_back(AuxItemAtomInfo(atom, claspProgramBuilder)); // for(const auto& atom : gringoOutput->getCurrentCostAtomInfos()) // currentCostAtomInfos.emplace_back(CurrentCostAtomInfo(atom, claspProgramBuilder)); // for(const auto& atom : gringoOutput->getCostAtomInfos()) // costAtomInfos.emplace_back(CostAtomInfo(atom, claspProgramBuilder))); // Prepare for solving. clasp.prepare(); } }
void Solver::startSolvingForCurrentRowCombination() { // ++solverSetups; asyncResult.reset(); if(reground) { // Set up ASP solver config.solve.numModels = 0; // TODO The last parameter of clasp.startAsp in the next line is "allowUpdate". Does setting it to false have benefits? // WORKAROUND for BUG in ClaspFacade::startAsp() // TODO remove on update to new version if(clasp.ctx.numVars() == 0 && clasp.ctx.frozen()) clasp.ctx.reset(); Clasp::Asp::LogicProgram& claspProgramBuilder = static_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config)); GringoOutputProcessor gringoOutput(claspProgramBuilder); std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, gringoOutput)); Gringo::Input::Program program; asp_utils::DummyGringoModule module; Gringo::Scripts scripts(module); Gringo::Defines defs; Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs); Gringo::Input::NonGroundParser parser(gringoProgramBuilder); // Input: Induced subinstance std::unique_ptr<std::stringstream> instanceInput(new std::stringstream); asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag()); app.getPrinter().solverInvocationInput(decomposition, instanceInput->str()); // Input: Decomposition std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream); asp_utils::declareDecomposition(decomposition, *decompositionInput); app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str()); // Input: Child rows std::unique_ptr<std::stringstream> childRowsInput(new std::stringstream); *childRowsInput << "% Child row facts" << std::endl; for(const auto& row : getCurrentRowCombination()) { for(const auto& item : row->getItems()) *childRowsInput << "childItem(" << item << ")." << std::endl; for(const auto& item : row->getAuxItems()) *childRowsInput << "childAuxItem(" << item << ")." << std::endl; // TODO costs, etc. } app.getPrinter().solverInvocationInput(decomposition, childRowsInput->str()); // Pass input to ASP solver for(const auto& file : encodingFiles) parser.pushFile(std::string(file)); parser.pushStream("<instance>", std::move(instanceInput)); parser.pushStream("<decomposition>", std::move(decompositionInput)); parser.pushStream("<child_rows>", std::move(childRowsInput)); parser.parse(); // Ground program.rewrite(defs); program.check(); if(Gringo::message_printer()->hasError()) throw std::runtime_error("Grounding stopped because of errors"); auto gPrg = program.toGround(out->domains); Gringo::Ground::Parameters params; params.add("base", {}); gPrg.ground(params, scripts, *out); params.clear(); claspProgramBuilder.endProgram(); itemAtomInfos.clear(); for(const auto& atom : gringoOutput.getItemAtomInfos()) itemAtomInfos.emplace_back(ItemAtomInfo(atom, claspProgramBuilder)); auxItemAtomInfos.clear(); for(const auto& atom : gringoOutput.getAuxItemAtomInfos()) auxItemAtomInfos.emplace_back(AuxItemAtomInfo(atom, claspProgramBuilder)); // TODO costs etc. clasp.prepare(); } else { // Set external variables to the values of the current child row combination clasp.update(false, false); clasp.prepare(); // Mark atoms corresponding to items from the currently extended rows for(const auto& row : getCurrentRowCombination()) { for(const auto& item : row->getItems()) { assert(itemsToLitIndices.find(item) != itemsToLitIndices.end()); assert(itemsToLitIndices.at(item) < literals.size()); #ifdef DISABLE_CHECKS literals[itemsToLitIndices.at(item)].watch(); #else try { literals[itemsToLitIndices.at(item)].watch(); } catch(const std::out_of_range&) { std::ostringstream msg; msg << "Unknown variable; atom childItem(" << *item << ") not shown or not declared as external?"; throw std::runtime_error(msg.str()); } #endif } for(const auto& item : row->getAuxItems()) { assert(auxItemsToLitIndices.find(item) != auxItemsToLitIndices.end()); assert(auxItemsToLitIndices.at(item) < literals.size()); #ifdef DISABLE_CHECKS literals[auxItemsToLitIndices.at(item)].watch(); #else try { literals[auxItemsToLitIndices.at(item)].watch(); } catch(const std::out_of_range&) { std::ostringstream msg; msg << "Unknown variable; atom childAuxItem(" << *item << ") not shown or not declared as external?"; throw std::runtime_error(msg.str()); } #endif } } // Set marked literals to true and all others to false for(auto& lit : literals) { if(lit.watched()) { lit.clearWatch(); clasp.assume(lit); } else clasp.assume(~lit); } } asyncResult.reset(new BasicSolveIter(clasp)); }
bool QtWebEnginePage::acceptNavigationRequest(const QUrl &url, QWebEnginePage::NavigationType type, bool isMainFrame) { if (m_isPopup) { emit aboutToNavigate(url, type); return false; } if (isMainFrame && url.scheme() == QLatin1String("javascript")) { runJavaScript(url.path()); return false; } if (url.scheme() == QLatin1String("mailto")) { QDesktopServices::openUrl(url); return false; } if (isMainFrame && type == QWebEnginePage::NavigationTypeReload && m_previousNavigationType == QWebEnginePage::NavigationTypeFormSubmitted && SettingsManager::getValue(QLatin1String("Choices/WarnFormResend")).toBool()) { bool cancel(false); bool warn(true); if (m_widget) { ContentsDialog dialog(ThemesManager::getIcon(QLatin1String("dialog-warning")), tr("Question"), tr("Are you sure that you want to send form data again?"), tr("Do you want to resend data?"), (QDialogButtonBox::Yes | QDialogButtonBox::Cancel), NULL, m_widget); dialog.setCheckBox(tr("Do not show this message again"), false); connect(m_widget, SIGNAL(aboutToReload()), &dialog, SLOT(close())); m_widget->showDialog(&dialog); cancel = !dialog.isAccepted(); warn = !dialog.getCheckBoxState(); } else { QMessageBox dialog; dialog.setWindowTitle(tr("Question")); dialog.setText(tr("Are you sure that you want to send form data again?")); dialog.setInformativeText(tr("Do you want to resend data?")); dialog.setIcon(QMessageBox::Question); dialog.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel); dialog.setDefaultButton(QMessageBox::Cancel); dialog.setCheckBox(new QCheckBox(tr("Do not show this message again"))); cancel = (dialog.exec() == QMessageBox::Cancel); warn = !dialog.checkBox()->isChecked(); } SettingsManager::setValue(QLatin1String("Choices/WarnFormResend"), warn); if (cancel) { return false; } } if (isMainFrame && type != QWebEnginePage::NavigationTypeReload) { m_previousNavigationType = type; } if (isMainFrame) { scripts().clear(); const QList<UserScript*> scripts(AddonsManager::getUserScriptsForUrl(url)); for (int i = 0; i < scripts.count(); ++i) { QWebEngineScript::InjectionPoint injectionPoint(QWebEngineScript::DocumentReady); if (scripts.at(i)->getInjectionTime() == UserScript::DocumentCreationTime) { injectionPoint = QWebEngineScript::DocumentCreation; } else if (scripts.at(i)->getInjectionTime() == UserScript::DeferredTime) { injectionPoint = QWebEngineScript::Deferred; } QWebEngineScript script; script.setSourceCode(scripts.at(i)->getSource()); script.setRunsOnSubFrames(scripts.at(i)->shouldRunOnSubFrames()); script.setInjectionPoint(injectionPoint); this->scripts().insert(script); } emit aboutToNavigate(url, type); } return true; }
ItemTreePtr Solver::compute() { const auto nodeStackElement = app.getPrinter().visitNode(decomposition); // Compute item trees of child nodes ChildItemTrees childItemTrees; for(const auto& child : decomposition.getChildren()) { ItemTreePtr itree = child->getSolver().compute(); if(!itree) return itree; childItemTrees.emplace(child->getNode().getGlobalId(), std::move(itree)); } // Input: Child item trees std::unique_ptr<std::stringstream> childItemTreesInput(new std::stringstream); *childItemTreesInput << "% Child item tree facts" << std::endl; for(const auto& childItemTree : childItemTrees) { std::ostringstream rootItemSetName; rootItemSetName << 'n' << childItemTree.first; asp_utils::declareItemTree(*childItemTreesInput, childItemTree.second.get(), tableMode, childItemTree.first, rootItemSetName.str()); } app.getPrinter().solverInvocationInput(decomposition, childItemTreesInput->str()); // Input: Induced subinstance std::unique_ptr<std::stringstream> instanceInput(new std::stringstream); asp_utils::induceSubinstance(*instanceInput, app.getInstance(), decomposition.getNode().getBag()); app.getPrinter().solverInvocationInput(decomposition, instanceInput->str()); // Input: Decomposition std::unique_ptr<std::stringstream> decompositionInput(new std::stringstream); asp_utils::declareDecomposition(decomposition, *decompositionInput); app.getPrinter().solverInvocationInput(decomposition, decompositionInput->str()); // Set up ASP solver Clasp::ClaspConfig config; config.solve.numModels = 0; Clasp::ClaspFacade clasp; // TODO The last parameter of clasp.startAsp in the next line is "allowUpdate". Does setting it to false have benefits? Clasp::Asp::LogicProgram& claspProgramBuilder = dynamic_cast<Clasp::Asp::LogicProgram&>(clasp.startAsp(config)); std::unique_ptr<Gringo::Output::LparseOutputter> lpOut(newGringoOutputProcessor(claspProgramBuilder, childItemTrees, tableMode)); std::unique_ptr<Gringo::Output::OutputBase> out(new Gringo::Output::OutputBase({}, *lpOut)); Gringo::Input::Program program; asp_utils::DummyGringoModule module; Gringo::Scripts scripts(module); Gringo::Defines defs; Gringo::Input::NongroundProgramBuilder gringoProgramBuilder(scripts, program, *out, defs); Gringo::Input::NonGroundParser parser(gringoProgramBuilder); // Pass input to ASP solver for(const auto& file : encodingFiles) parser.pushFile(std::string(file)); parser.pushStream("<instance>", std::move(instanceInput)); parser.pushStream("<decomposition>", std::move(decompositionInput)); parser.pushStream("<child_itrees>", std::move(childItemTreesInput)); parser.parse(); // Ground and solve program.rewrite(defs); program.check(); if(Gringo::message_printer()->hasError()) throw std::runtime_error("Grounding stopped because of errors"); auto gPrg = program.toGround(out->domains); Gringo::Ground::Parameters params; params.add("base", {}); gPrg.ground(params, scripts, *out); params.clear(); // Finalize ground program and create solver variables claspProgramBuilder.endProgram(); std::unique_ptr<asp_utils::ClaspCallback> cb(newClaspCallback(tableMode, *lpOut, childItemTrees, app, decomposition.isRoot(), decomposition, cardinalityCost)); cb->prepare(claspProgramBuilder); clasp.prepare(); clasp.solve(cb.get()); if(printStatistics) { std::cout << "Solver statistics for decomposition node " << decomposition.getNode().getGlobalId() << ':' << std::endl; Clasp::Cli::TextOutput{true, Clasp::Cli::TextOutput::format_asp}.printStatistics(clasp.summary(), true); } ItemTreePtr result = cb->finalize(decomposition.isRoot(), app.isPruningDisabled() == false || decomposition.isRoot()); app.getPrinter().solverInvocationResult(decomposition, result.get()); return result; }