void MainWindow::openUrl(const QString &text) { if (text.isEmpty()) { m_windowsManager->triggerAction(ActionsManager::NewTabAction); return; } else { InputInterpreter *interpreter(new InputInterpreter(this)); connect(interpreter, SIGNAL(requestedOpenBookmark(BookmarksItem*,WindowsManager::OpenHints)), m_windowsManager, SLOT(open(BookmarksItem*,WindowsManager::OpenHints))); connect(interpreter, SIGNAL(requestedOpenUrl(QUrl,WindowsManager::OpenHints)), m_windowsManager, SLOT(open(QUrl,WindowsManager::OpenHints))); connect(interpreter, SIGNAL(requestedSearch(QString,QString,WindowsManager::OpenHints)), m_windowsManager, SLOT(search(QString,QString,WindowsManager::OpenHints))); interpreter->interpret(text, ((!m_workspace->getActiveWindow() || Utils::isUrlEmpty(m_workspace->getActiveWindow()->getUrl())) ? WindowsManager::CurrentTabOpen : WindowsManager::NewTabOpen)); } }
static void executeCreateQuery( const String & query, Context & context, const String & database, const String & file_name, ThreadPool & pool, bool has_force_restore_data_flag) { ParserCreateQuery parser; ASTPtr ast = parseQuery(parser, query.data(), query.data() + query.size(), "in file " + file_name); ASTCreateQuery & ast_create_query = typeid_cast<ASTCreateQuery &>(*ast); ast_create_query.attach = true; ast_create_query.database = database; InterpreterCreateQuery interpreter(ast, context); interpreter.setDatabaseLoadingThreadpool(pool); interpreter.setForceRestoreData(has_force_restore_data_flag); interpreter.execute(); }
/* Filter hook procedure, called whenever a new filter is created. This performs preflight checks (checking for DCTDecode filter and calling mischook). */ Bool ps_filter_preflight(FILELIST *filter) { OBJECT *ocompress_jpeg = &get_core_context_interp()->mischookparams->CompressJPEG; HQASSERT(filter, "No filter in hook") ; /* part of the EP2000 preflight checks. Must be handled here rather than in * DCTDecode specific code in case an external JPEG input plugin is in use. */ if ( oType(*ocompress_jpeg) != ONULL && HqMemCmp(theICList(filter), theINLen(filter), NAME_AND_LENGTH("DCTDecode")) == 0 ) { if ( ! push( ocompress_jpeg, & executionstack ) ) return FALSE ; if ( ! interpreter( 1 , NULL )) return FALSE ; } return TRUE ; }
/* Compile the source code using the constructed Abstract Syntax Tree Arguments are the root nodes of - 1) Global declaration AST, 2) Function definitions AST 3) main() function definition AST */ void compile(Tnode *gdeclroot,Tnode *fdefroot,Tnode *mainroot) { error = 0; locpos = -1; labelcnt = 0; globalInstall(gdeclroot); if(fdefroot != NULL) { funcSemanticCheck(fdefroot); checkFuncDecl(fdefroot->LINE); funcSemanticCheck(mainroot); } printf("\nRUN - \n"); if(error == 0) { module = INTERPRET; Gallocate(); funcroot = fdefroot; mroot = mainroot; struct Lsymbol *Ltable; Ltable = NULL; interpreter(mainroot,&Ltable); get = 0; fre = 0; regcnt = -1; module = CODEGEN; fp = fopen("SIM_Simulator/SIMcode","w"); funcCodeGen(fdefroot); funcCodeGen(mainroot); callToMain(); fclose(fp); } }
Interpreter Interpreter::fromElement(XERCESC_NS::DOMElement* scxml, const std::string& baseURL) { URL absUrl = normalizeURL(baseURL); std::shared_ptr<InterpreterImpl> interpreterImpl(new InterpreterImpl()); Interpreter interpreter(interpreterImpl); // *copy* the given XERCESC_NS::DOM to get rid of event listeners XERCESC_NS::DOMImplementation* implementation = XERCESC_NS::DOMImplementationRegistry::getDOMImplementation(X("core")); interpreterImpl->_document = implementation->createDocument(); // we need to import the parent - to support xpath test150 XERCESC_NS::DOMNode* newNode = interpreterImpl->_document->importNode(scxml, true); // interpreterImpl->_document->adoptNode(newNode); interpreterImpl->_document->appendChild(newNode); // std::cerr << *(interpreterImpl->_document); interpreterImpl->_baseURL = absUrl; InterpreterImpl::addInstance(interpreterImpl); return interpreter; }
void input_controler (INPUT_DESC *input, int status) { char command[256]; if ((move_active == 1) && (input->mouse_button == GLUT_LEFT_BUTTON) && (input->mouse_state == GLUT_DOWN)) { sprintf (command, "move %s to %d, %d;", input->name, input->wxd, input->wyd); interpreter (command); } if ((move_active == 1) && (input->mouse_button == GLUT_LEFT_BUTTON) && (input->mouse_state == GLUT_DOWN)) { } input->mouse_button = -1; }
Interpreter Interpreter::fromURL(const std::string& url) { URL absUrl = normalizeURL(url); std::shared_ptr<InterpreterImpl> interpreterImpl(new InterpreterImpl()); Interpreter interpreter(interpreterImpl); std::unique_ptr<XERCESC_NS::XercesDOMParser> parser(new XERCESC_NS::XercesDOMParser()); parser->setValidationScheme(XERCESC_NS::XercesDOMParser::Val_Always); parser->setDoNamespaces(true); // we do not have a real schema anyway parser->useScanner(XERCESC_NS::XMLUni::fgWFXMLScanner); std::unique_ptr<XERCESC_NS::ErrorHandler> errHandler(new XERCESC_NS::HandlerBase()); parser->setErrorHandler(errHandler.get()); try { std::string tmp = absUrl; parser->parse(tmp.c_str()); interpreterImpl->_document = parser->adoptDocument(); interpreterImpl->_baseURL = absUrl; InterpreterImpl::addInstance(interpreterImpl); } catch (const XERCESC_NS::SAXParseException& toCatch) { LOGD(USCXML_ERROR) << X(toCatch.getMessage()); } catch (const XERCESC_NS::RuntimeException& toCatch) { LOGD(USCXML_ERROR) << X(toCatch.getMessage()); } catch (const XERCESC_NS::XMLException& toCatch) { LOGD(USCXML_ERROR) << X(toCatch.getMessage()); } catch (const XERCESC_NS::DOMException& toCatch) { LOGD(USCXML_ERROR) << X(toCatch.getMessage()); } return interpreter; }
bool run_test(std::string const &test_name, std::string const &source, ValuePredicate const &check_result, std::ostream &out) { source_range const source_range((source.data()), source.data() + source.size()); auto const program = compile_unit(source_range); run::default_garbage_collector gc; run::interpreter interpreter(gc, nullptr); run::value result; auto const duration = measure_running_duration([&result, &program, &interpreter, &gc]() { result = interpreter.call( intermediate::function_ref(program, program.functions().front()), {}); gc.sweep(run::sweep_mode::full); }); out << test_name << " \t"; bool const is_success = check_result(result); out << (is_success ? "succeeded" : "failed") << " in \t"; print_running_duration(out, duration); out << '\n'; return is_success; }
void xeq( void ) { cell * volatile savedlc = ((cell *) (intptr_t) *(lc+1)) + D_BODY - 1; int sig; sig = setjmp( rexeq ); switch( sig ) { /* here's where to have different actions for different aborts */ case 0 : /* first time through */ break; case 1 : put_c_string( "\nSoftware abort\n" ); break; case 2 : put_c_string( "\nUndefined instruction\n" ); break; case 3 : put_c_string( "\nSoftware interrupt\n" ); break; case 4 : put_c_string( "\nMemory access error\n" ); break; case 6 : put_c_string( "\nUncaught IRQ\n" ); break; case 7 : put_c_string( "\nUncaught FIQ\n" ); break; case 8 : put_c_string( "\nInterrupted\n" ); break; default: put_c_string( "\nUnknown condition\n" ); break; } if( sig ) primitive_io_abort(); /* reset input after restart */ sp = stack + STACK_DIM; rsp = rstack + RSTACK_DIM; lc = savedlc; fussy(); /* returns if fast interpreter requested */ interpreter(); /* Never returns */ }
int main(void) { printf("libc running\n"); /* inst p1[]={quit, emit, emit, emit, dup, dup, FIXNUM(42), lit}; */ /* inst p2[]={quit, emit, truefalse, 'f', blit ,'t', blit, FIXNUM(0), lit}; */ /* inst p3[]={quit, emit, truefalse, FIXNUM('f'), lit, FIXNUM('t'), lit, FIXNUM(1), lit}; */ /* inst twostar[]={qend,emit,emit,dup,FIXNUM(42),lit}; */ /* inst onestar[]={qend,emit,FIXNUM(42),lit}; */ /* inst p4[]={quit,CALL(ifquot),CALL(twostar), lit, CALL(onestar), lit, FIXNUM(0),lit}; */ /* inst loop[]={recurse,CALL(ifquot), qend,sub,one,emit,dup,qstart, qend,quit,drop,qstart, eql,'0',blit,dup}; */ /* inst p5[]={CALL(loop),'5',blit}; */ /* interpreter((inst*)TBEGIN(p2)); */ /* interpreter((inst*)TBEGIN(p3)); */ /* interpreter((inst*)TBEGIN(p4)); */ /* interpreter(&p1[sizeof(p1)/sizeof(inst)-1]); */ /* interpreter((inst*)TBEGIN(p5)); */ #if !STOP_ON_ERROR while (1) { #endif interpreter(START_WORD_OFFSET); #if !STOP_ON_ERROR } #endif }
Interpreter Interpreter::fromDocument(XERCESC_NS::DOMDocument* dom, const std::string& baseURL, bool copy) { URL absUrl = normalizeURL(baseURL); std::shared_ptr<InterpreterImpl> interpreterImpl(new InterpreterImpl()); Interpreter interpreter(interpreterImpl); if (copy) { // *copy* the given XERCESC_NS::DOM to get rid of event listeners XERCESC_NS::DOMImplementation* implementation = XERCESC_NS::DOMImplementationRegistry::getDOMImplementation(X("core")); interpreterImpl->_document = implementation->createDocument(); // we need to import the parent - to support xpath test150 XERCESC_NS::DOMNode* newNode = interpreterImpl->_document->importNode(dom->getDocumentElement(), true); interpreterImpl->_document->appendChild(newNode); } else { interpreterImpl->_document = dom; } interpreterImpl->_baseURL = absUrl; InterpreterImpl::addInstance(interpreterImpl); return interpreter; }
QVector<QObject *>* QSAEditor::interfaceObjects( const QSObject &o ) const { return interpreter()->wrapperClass()->objectVector( &o ); }
QSEnv *QSAEditor::env() const { return interpreter()->env(); }
Foam::SwakScriptableInjection<CloudType>::SwakScriptableInjection ( const dictionary& dict, CloudType& owner #ifdef FOAM_INJECT_CONSTRUCTOR_HAS_MODELNAME ,const word& modelName #endif ) : InjectionModel<CloudType>( dict, owner, typeName #ifdef FOAM_INJECT_CONSTRUCTOR_HAS_MODELNAME ,modelName #endif ), interpreter_( generalInterpreterWrapper::New( owner.mesh(), this->coeffDict() ) ), parameterStructName_( this->coeffDict().lookup("parameterStructName") ), resultStructName_( this->coeffDict().lookup("resultStructName") ), injectByEvent_( readBool( this->coeffDict().lookup("injectByEvent") ) ), isActive_(false), plannedDuration_(1e10) { interpreter().readCode( this->coeffDict(), "initInjector", initInjectorCode_ ); if(injectByEvent_) { interpreter().readCode( this->coeffDict(), "doStartInjection", doStartInjectionCode_ ); interpreter().readCode( this->coeffDict(), "doStopInjection", doStopInjectionCode_ ); } else { interpreter().readCode( this->coeffDict(), "injectionDuration", injectionDurationCode_ ); interpreter().readCode( this->coeffDict(), "startOfInjectionTime", startOfInjectionTimeCode_ ); } interpreter().readCode( this->coeffDict(), "parcelsToInject", parcelsToInjectCode_ ); interpreter().readCode( this->coeffDict(), "volumeToInject", volumeToInjectCode_ ); interpreter().readCode( this->coeffDict(), "prepareParcelData", prepareParcelDataCode_ ); interpreter().readCode( this->coeffDict(), "particleProperties", particlePropertiesCode_ ); Info << "Executing initialization code for " << this->owner().name() << endl; interpreter().executeCode( initInjectorCode_, true // set global variables if necessary ); }
/** * Main function for the cqpserver app. */ int main(int argc, char *argv[]) { int cmd; which_app = cqpserver; /* TODO: shouldn't these come AFTER initialize_cqp(), as that function may overwrite these values with defaults? * or maybe I've missed some subtlety here....*/ silent = 1; paging = autoshow = auto_save = 0; if (!initialize_cqp(argc, argv)) { Rprintf( "CQPserver: ERROR Couldn't initialise CQP engine.\n"); rcqp_receive_error(1); } cqiserver_welcome(); if (localhost) { add_host_to_list("127.0.0.1"); /* in -L mode, connections from localhost are automatically accepted */ } if (0 < accept_connection(server_port)) { if (server_log) Rprintf("CQPserver: Connected. Waiting for CONNECT request.\n"); } else { Rprintf( "CQPserver: ERROR Connection failed.\n"); rcqp_receive_error(1); } /* establish CQi connection: wait for CONNECT request */ cmd = cqi_read_command(); if (cmd != CQI_CTRL_CONNECT) { if (server_log) Rprintf("CQPserver: Connection refused.\n"); cqiserver_wrong_command_error(cmd); } user = cqi_read_string(); passwd = cqi_read_string(); if (server_log) Rprintf("CQPserver: CONNECT user = '******' passwd = '%s' pid = %d\n", user, passwd, (int)getpid()); /* check password here (always required !!) */ if (!authenticate_user(user, passwd)) { Rprintf("CQPserver: Wrong username or password. Connection refused.\n"); /* TODO shouldn't this be to stderr as it is not conditional on server_log? */ cqi_command(CQI_ERROR_CONNECT_REFUSED); } else { cqi_command(CQI_STATUS_CONNECT_OK); /* re-randomize for query lock key generation */ cl_randomize(); /* check which corpora the user is granted access to */ { CorpusList *cl = FirstCorpusFromList(); while (cl != NULL) { if (!check_grant(user, cl->name)) dropcorpus(cl); cl = NextCorpusFromList(cl); } } /* start command interpreter loop */ interpreter(); if (server_log) Rprintf("CQPserver: User '%s' has logged off.\n", user); } /* connection terminated; clean up and exit */ Rprintf("CQPserver: Exit. (pid = %d)\n", (int)getpid()); /* TODO should we check cqp_error_status as in the main cqp app? */ return 0; }
const Options& options() { return interpreter().options(); }
RegisterFile* CallFrame::registerFile() { return &interpreter()->registerFile(); }
void Befunge::interpret(std::istream& in, std::ostream& out) { interpreter(in, out); }
int evalBody(Tnode *root,struct Lsymbol **Lhead) { int t; struct Gsymbol *gnode; struct Lsymbol *lnode; if(root == NULL) return; switch(root->NODETYPE) { case CONTINUE : evalBody(root->Ptr1,Lhead); return evalBody(root->Ptr2,Lhead); case FUNCCALL : gnode = Glookup(root->NAME); Arghead = gnode->ARGLIST; struct Lsymbol *Ltable; Ltable = NULL; if(Arghead != NULL) funcParamInstall(root->Ptr1,Lhead,&Ltable); tempnode = searchFunc(root->NAME,funcroot); return interpreter(tempnode,&Ltable); case IDADDR : lnode = Llookup(root->NAME,Lhead); gnode = Glookup(root->NAME); if(lnode != NULL) binding = lnode->BINDING; else binding = gnode->BINDING; return *binding; case RET : return evalBody(root->Ptr1,Lhead); case ITERATIVE : while(evalBody(root->Ptr1,Lhead)) evalBody(root->Ptr2,Lhead); return; case CONDITIONAL : if(evalBody(root->Ptr1,Lhead)) evalBody(root->Ptr2,Lhead); else evalBody(root->Ptr3,Lhead); return; case ASSIGN : lnode = Llookup(root->NAME,Lhead); gnode = Glookup(root->NAME); if(lnode != NULL) *lnode->BINDING = evalBody(root->Ptr1,Lhead); else *gnode->BINDING = evalBody(root->Ptr1,Lhead); return; case ARRAYASSIGN : gnode = Glookup(root->NAME); gnode->BINDING[evalBody(root->Ptr1,Lhead)] = evalBody(root->Ptr2,Lhead); return; case RD : scanf("%d",&var); lnode = Llookup(root->NAME,Lhead); gnode = Glookup(root->NAME); if(lnode != NULL) *lnode->BINDING = var; else *gnode->BINDING = var; return; case ARRAYRD : scanf("%d",&var); gnode = Glookup(root->NAME); gnode->BINDING[evalBody(root->Ptr1,Lhead)] = var; return; case WRIT : printf("%d\n",evalBody(root->Ptr1,Lhead)); return; case ADD : return evalBody(root->Ptr1,Lhead) + evalBody(root->Ptr2,Lhead); case SUB : return evalBody(root->Ptr1,Lhead) - evalBody(root->Ptr2,Lhead); case MUL : return evalBody(root->Ptr1,Lhead) * evalBody(root->Ptr2,Lhead); case DIV : return evalBody(root->Ptr1,Lhead) / evalBody(root->Ptr2,Lhead); case MOD : return evalBody(root->Ptr1,Lhead) % evalBody(root->Ptr2,Lhead); case GT : return evalBody(root->Ptr1,Lhead) > evalBody(root->Ptr2,Lhead); case LT : return evalBody(root->Ptr1,Lhead) < evalBody(root->Ptr2,Lhead); case GTE : return evalBody(root->Ptr1,Lhead) >= evalBody(root->Ptr2,Lhead); case LTE : return evalBody(root->Ptr1,Lhead) <= evalBody(root->Ptr2,Lhead); case EQ : return evalBody(root->Ptr1,Lhead) == evalBody(root->Ptr2,Lhead); case NE : return evalBody(root->Ptr1,Lhead) != evalBody(root->Ptr2,Lhead); case And : return evalBody(root->Ptr1,Lhead) && evalBody(root->Ptr2,Lhead); case Or : return evalBody(root->Ptr1,Lhead) || evalBody(root->Ptr2,Lhead); case Not : return !evalBody(root->Ptr1,Lhead); case True : return 1; case False : return 0; case IDFR : lnode = Llookup(root->NAME,Lhead); gnode = Glookup(root->NAME); if(lnode != NULL) return *lnode->BINDING; else return *gnode->BINDING; case ARRAYIDFR : gnode = Glookup(root->NAME); return gnode->BINDING[evalBody(root->Ptr1,Lhead)]; case NUM : return root->VALUE; default : printf("How did flag get this value!"); } }
void Befunge::interpret(std::istream& in) { interpreter(in, std::cout); }
void Befunge::interpret() { interpreter(std::cin, std::cout); }
void MachineCode::init(STATE) { // Seed the instructions table interpreter(0, 0, 0); }
void QSAEditor::completeQMetaObject( const QMetaObject *meta, const QString &, QVector<CompletionEntry> &res, int flags, QSObject &obj ) { QMap<QString, bool> propMap; bool includeSuperClass = (flags & IncludeSuperClass) == IncludeSuperClass; // properties const QMetaObject *m = meta; int num = m->propertyCount(); for ( int j = 0; j < num; ++j ) { const QMetaProperty mp = m->property( j ); if ( propMap.find( QString::fromLatin1(mp.name()) ) != propMap.end() ) continue; CompletionEntry c; propMap[QLatin1String(mp.name())] = false; c.type = QLatin1String("property"); c.text = mp.name(); c.prefix = QString(); c.postfix2 = mp.typeName(); QuickInterpreter::cleanType( c.postfix2 ); if ( !c.postfix2.isEmpty() ) c.postfix2.prepend( QLatin1String(" : ") ); res.append( c ); } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList vars = interpreter()->variablesOf( obj, true ); QStringList::iterator it; for ( it = vars.begin(); it != vars.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("variable"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } // functions QList<Property> lst; QList<Property>::Iterator pit; getSlots( meta, lst, includeSuperClass, false, false ); for ( pit = lst.begin(); pit != lst.end(); ++pit ) { CompletionEntry c; c.type = QLatin1String("function"); c.text = (*pit).name; c.postfix = QLatin1String("()"); c.postfix2 = (*pit).type; if ( !c.postfix2.isEmpty() ) c.postfix2.prepend( QString::fromLatin1(" : ") ); res << c; } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList funcs = interpreter()->functionsOf( obj, true, true, true ); QStringList::Iterator it; for ( it = funcs.begin(); it != funcs.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("function"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } // enum values m = meta; for (int k=0; k<m->enumeratorCount(); ++k) { QMetaEnum me = m->enumerator(k); for (int l=0; l<me.keyCount(); ++l) { CompletionEntry c; c.type = QLatin1String("enum"); c.text = QLatin1String(me.key(l)); c.prefix = QString(); c.postfix2 = QLatin1String(me.name()); if (!c.postfix2.isEmpty()) c.postfix2.prepend( QString::fromLatin1(" : ") ); res << c; } } if ( includeSuperClass && obj.isValid() && !obj.isUndefined() ) { QStringList classes = interpreter()->classesOf( obj ); QStringList::Iterator it; for ( it = classes.begin(); it != classes.end(); ++it ) { CompletionEntry c; c.type = QLatin1String("class"); c.text = *it; c.prefix = QString(); c.postfix2 = QString(); res << c; } } }
Tcl_Interp* dfsch_tcl_interpreter(dfsch_object_t* obj){ return interpreter(obj)->interpreter; }
MainWindow::MainWindow(Manager *man, QWidget *parent) : QMainWindow(parent), manager(man), nbElementsAffichablesPile(1) { pile = manager->getPile(); QXmlStreamReader xmlReader3; QFile filePile3("parametres.xml"); filePile3.open(QFile::ReadOnly); xmlReader3.setDevice(&filePile3); xmlReader3.readNext(); QString valeur; while(!xmlReader3.atEnd() && !xmlReader3.hasError()) { QXmlStreamReader::TokenType token = xmlReader3.readNext(); if(token == QXmlStreamReader::StartDocument) { continue; } if(token == QXmlStreamReader::StartElement) { if(xmlReader3.name() == "clavierVisible") { xmlReader3.readElementText(); } if(xmlReader3.name() == "valeur") { valeur= xmlReader3.readElementText(); if(valeur=="1") clavierVisible=true; else clavierVisible=false; } if(xmlReader3.name() == "nbElementsVisiblesPile") { xmlReader3.readElementText(); } if(xmlReader3.name() == "valeur") { valeur = xmlReader3.readElementText(); nbElementsAffichablesPile = valeur.toInt(); } } } //paramètres d'affichage QMenu *menuAfficher = menuBar()->addMenu("&Afficher"); actionAfficherClavier = new QAction("&Afficher le clavier", this); actionAfficherClavier->setCheckable(true); actionAfficherClavier->setChecked(true); QAction* actionNbElementsPile = new QAction("&Modifier le nombre d'élements affichables dans la pile", this); menuAfficher->addAction(actionAfficherClavier); menuAfficher->addAction(actionNbElementsPile); QObject::connect(actionAfficherClavier, SIGNAL(toggled(bool)), this, SLOT(afficherClavier(bool))); QObject::connect(actionNbElementsPile, SIGNAL(triggered(bool)), this, SLOT(modifierNbElementsAffichesPile())); // Général QHBoxLayout *mainLayout= new QHBoxLayout(); tabWidget = new QTabWidget(); QVBoxLayout *verticalLayout = new QVBoxLayout(); layoutClavier = new QGridLayout; //Vue de la pile (gauche) QListView *vuePile = new QListView(); vuePile->setGeometry(0,0,100,300); //Vue de l'historique de commandes (droite) QTextEdit *vueHistoriqueCommandes = new QTextEdit(); inputLine = new QLineEdit(); //Clavier numérique QSignalMapper *signalMapper = new QSignalMapper(this); QPushButton *bouton1= new QPushButton(); bouton1->setText("1"); connect(bouton1, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton1, "1"); QPushButton *bouton2= new QPushButton(); bouton2->setText("2"); connect(bouton2, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton2, "2"); QPushButton *bouton3= new QPushButton(); bouton3->setText("3"); connect(bouton3, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton3, "3"); QPushButton *bouton4= new QPushButton(); bouton4->setText("4"); connect(bouton4, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton4, "4"); QPushButton *bouton5= new QPushButton(); bouton5->setText("5"); connect(bouton5, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton5, "5"); QPushButton *bouton6= new QPushButton(); bouton6->setText("6"); connect(bouton6, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton6, "6"); QPushButton *bouton7= new QPushButton(); bouton7->setText("7"); connect(bouton7, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton7, "7"); QPushButton *bouton8= new QPushButton(); bouton8->setText("8"); connect(bouton8, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton8, "8"); QPushButton *bouton9= new QPushButton(); bouton9->setText("9"); connect(bouton9, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(bouton9, "9"); QPushButton *boutonEspace= new QPushButton(); boutonEspace->setText(""); connect(boutonEspace, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(boutonEspace, " "); QPushButton *boutonAddition= new QPushButton(); boutonAddition->setText("+"); connect(boutonAddition, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(boutonAddition, "+"); QPushButton *boutonSoustraction= new QPushButton(); boutonSoustraction->setText("-"); connect(boutonSoustraction, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(boutonSoustraction, "-"); QPushButton *boutonMulitplication= new QPushButton(); boutonMulitplication->setText("*"); connect(boutonMulitplication, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(boutonMulitplication, "*"); QPushButton *boutonDivision= new QPushButton(); boutonDivision->setText("/"); connect(boutonDivision, SIGNAL(clicked()), signalMapper, SLOT(map())); signalMapper->setMapping(boutonDivision, "/"); connect(signalMapper, SIGNAL(mapped(QString)), this, SLOT(appendInputKeyboard(QString))); QPushButton *boutonEntree= new QPushButton(); boutonEntree->setText("Entrée"); connect(boutonEntree, SIGNAL(clicked()), this, SLOT(returnPressedStr())); QVBoxLayout *layoutOperateurs = new QVBoxLayout(); layoutOperateurs->addWidget(boutonAddition); layoutOperateurs->addWidget(boutonSoustraction); layoutOperateurs->addWidget(boutonMulitplication); layoutOperateurs->addWidget(boutonDivision); layoutOperateurs->addWidget(boutonEntree); //Crée un layout contenant le clavier numérique layoutClavier->addWidget(bouton1, 0,0); layoutClavier->addWidget(bouton2, 0,1); layoutClavier->addWidget(bouton3, 0,2); layoutClavier->addWidget(bouton4, 1,0); layoutClavier->addWidget(bouton5, 1,1); layoutClavier->addWidget(bouton6, 1,2); layoutClavier->addWidget(bouton7, 2,0); layoutClavier->addWidget(bouton8, 2,1); layoutClavier->addWidget(bouton9, 2,2); layoutClavier->addWidget(boutonEspace,3,0,1,3); layoutClavier->addLayout(layoutOperateurs, 0,3,4,1); conteneurClavier = new QWidget(); conteneurClavier->setLayout(layoutClavier); //Crée un layout avec l'historique de commandes, la zone d'entrée et le clavier verticalLayout->addWidget(vueHistoriqueCommandes); verticalLayout->addWidget(inputLine); verticalLayout->addWidget(conteneurClavier); //Assemble les layouts mainLayout->addWidget(vuePile); mainLayout->addLayout(verticalLayout); QWidget* tab1 = new QWidget(); tab1->setLayout(mainLayout); tabWidget->addTab(tab1, "Principal"); QObject::connect(inputLine, SIGNAL(textChanged(QString)), this, SLOT(interpreter(QString))) ; QObject::connect(inputLine,SIGNAL(returnPressed()), this, SLOT(returnPressedStr())); pile->setView(vuePile); //---------------------------------TAB2-------------------------------------------- QHBoxLayout *layoutProgramme = new QHBoxLayout(); QVBoxLayout *layoutEditionProgramme = new QVBoxLayout(); QHBoxLayout *layoutBoutonsProgramme = new QHBoxLayout(); listeProgrammes = new QListView(); zoneProgramme = new QTextEdit(); zoneIdentifiant = new QLineEdit(); boutonValider = new QPushButton("Ajouter"); boutonEffacer = new QPushButton("Effacer"); boutonModifier = new QPushButton("Modifier"); boutonSupprimer = new QPushButton("Supprimer"); boutonSupprimer->setEnabled(false); boutonModifier->setEnabled(false); layoutBoutonsProgramme->addWidget(boutonValider); layoutBoutonsProgramme->addWidget(boutonEffacer); layoutBoutonsProgramme->addWidget(boutonModifier); layoutBoutonsProgramme->addWidget(boutonSupprimer); layoutEditionProgramme->addWidget(zoneProgramme); layoutEditionProgramme->addWidget(zoneIdentifiant); layoutEditionProgramme->addLayout(layoutBoutonsProgramme); layoutProgramme->addLayout(layoutEditionProgramme); layoutProgramme->addWidget(listeProgrammes); QWidget* tab2 = new QWidget(); tab2->setLayout(layoutProgramme); tabWidget->addTab(tab2, "Programmes"); QXmlStreamReader xmlReader; QFile fileProgramme("programmes.xml"); fileProgramme.open(QFile::ReadOnly); xmlReader.setDevice(&fileProgramme); xmlReader.readNext(); QString strIdentifiant; QString str; while(!xmlReader.atEnd() && !xmlReader.hasError()) { QXmlStreamReader::TokenType token = xmlReader.readNext(); if(token == QXmlStreamReader::StartDocument) { continue; } if(token == QXmlStreamReader::StartElement) { if(xmlReader.name() == "identifiant") { strIdentifiant= xmlReader.readElementText(); } if(xmlReader.name() == "string") { str= xmlReader.readElementText(); manager->insererProgramme(strIdentifiant, str); } } } QStringList* listeProgrammesStr = manager->getListProgrammes(); modeleProgrammes = new QStringListModel(*listeProgrammesStr, this); listeProgrammes->setEditTriggers(QAbstractItemView::NoEditTriggers); listeProgrammes->setModel(modeleProgrammes); fileProgramme.close(); QObject::connect(boutonValider, SIGNAL(clicked(bool)), this, SLOT(ajouterProgramme())); QObject::connect(listeProgrammes, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(afficherProgrammeListe(QModelIndex))); QObject::connect(boutonEffacer, SIGNAL(clicked(bool)), this, SLOT(effacerChampsProgramme())); QObject::connect(boutonSupprimer, SIGNAL(clicked(bool)), this, SLOT(supprimerProgramme())); QObject::connect(boutonModifier, SIGNAL(clicked(bool)), this, SLOT(modifierProgramme())); //---------------------------------TAB3-------------------------------------------- QHBoxLayout *layoutVariable = new QHBoxLayout(); QVBoxLayout *layoutEditionVariable = new QVBoxLayout(); QHBoxLayout *layoutBoutonsVariable = new QHBoxLayout(); listeVariables = new QListView(); zoneVariable = new QTextEdit(); zoneIdentifiantVariable = new QLineEdit(); boutonValiderVariable = new QPushButton("Ajouter"); boutonEffacerVariable = new QPushButton("Effacer"); boutonModifierVariable = new QPushButton("Modifier"); boutonSupprimerVariable = new QPushButton("Supprimer"); boutonSupprimerVariable->setEnabled(false); boutonModifierVariable->setEnabled(false); layoutBoutonsVariable->addWidget(boutonValiderVariable); layoutBoutonsVariable->addWidget(boutonEffacerVariable); layoutBoutonsVariable->addWidget(boutonModifierVariable); layoutBoutonsVariable->addWidget(boutonSupprimerVariable); layoutEditionVariable->addWidget(zoneVariable); layoutEditionVariable->addWidget(zoneIdentifiantVariable); layoutEditionVariable->addLayout(layoutBoutonsVariable); layoutVariable->addLayout(layoutEditionVariable); layoutVariable->addWidget(listeVariables); QWidget* tab3 = new QWidget(); tab3->setLayout(layoutVariable); tabWidget->addTab(tab3, "Variables"); QXmlStreamReader xmlReader2; QFile fileVariable("variables.xml"); fileVariable.open(QFile::ReadOnly); xmlReader2.setDevice(&fileVariable); xmlReader2.readNext(); while(!xmlReader2.atEnd() && !xmlReader2.hasError()) { QXmlStreamReader::TokenType token = xmlReader2.readNext(); if(token == QXmlStreamReader::StartDocument) { continue; } if(token == QXmlStreamReader::StartElement) { if(xmlReader2.name() == "identifiant") { strIdentifiant= xmlReader2.readElementText(); } if(xmlReader2.name() == "string") { str= xmlReader2.readElementText(); manager->insererVariable(strIdentifiant, str); } } } QStringList* listeVariablesStr = manager->getListVariables(); modeleVariables = new QStringListModel(*listeVariablesStr, this); listeVariables->setEditTriggers(QAbstractItemView::NoEditTriggers); listeVariables->setModel(modeleVariables); fileVariable.close(); QObject::connect(boutonValiderVariable, SIGNAL(clicked(bool)), this, SLOT(ajouterVariable())); QObject::connect(listeVariables, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(afficherVariableListe(QModelIndex))); QObject::connect(boutonEffacerVariable, SIGNAL(clicked(bool)), this, SLOT(effacerChampsVariable())); QObject::connect(boutonSupprimerVariable, SIGNAL(clicked(bool)), this, SLOT(supprimerVariable())); QObject::connect(boutonModifierVariable, SIGNAL(clicked(bool)), this, SLOT(modifierVariable())); QObject::connect(tabWidget, SIGNAL(currentChanged(int)), this, SLOT(updateTab(int))); setCentralWidget(tabWidget); }
// Task odbioru i analizy znakow z konsoli void vConsoleRxTask (void *pvparameters) { char special=0; char i = 0; char command_buffer[CMD_MAX_LEN]; char *ptr_cmd_buf = command_buffer; char onechar; //utworz kolejke znakow RxQueue = xQueueCreate(100, sizeof( portCHAR ) ); for (;;) { //vTaskDelay(10 / portTICK_RATE_MS); while(xQueueReceive(RxQueue,&onechar,portMAX_DELAY)) { // sprawdzamy wstepnie czy to znak specjalny (wszelkie strzalki, delete) if (onechar == 0x5b ||onechar == 0x1b) { special = 1; } //sprawdz czy to byla strzalka w gore else if (special && onechar == 0x41 ) { //skasuj wyswietlona z historii komende i przygotuj dla poprzedniej clean_term(ptr_cmd_buf); //wczytaj poprzednia komende przewinwtyl(com_cmd_hist, ptr_cmd_buf); //wyswietla te komnde na rs print_console(ptr_cmd_buf); //print_char(0, user.prom(&user)); i= (char)strlen(ptr_cmd_buf); // deaktywacja sekwencji sterujacej special = 0; } //przyjmuj tylko znaki z przedzialu a-z 0-9 spacja, enter, backspace,itd. //uwaga na strzalki, wysylaja po 2 znaki: A+costam oraz B+costam else if(( (onechar >= 'a' && onechar <= 'z') || (onechar >= 'A' && onechar <= 'Z') || (onechar >= '0' && onechar <= '9') || onechar == ' ' || onechar == '.' || onechar == '-' || onechar == '_' || onechar == '+' || onechar == '?' || onechar == '@' )&&(!special) ) { //echo dla wpisanego znaku usart_put_char(onechar); //zabezpieczenie przed przekroczeniem tablicy if(i < CMD_MAX_LEN) { *(ptr_cmd_buf + i) = onechar; i++; } } //sprawdz czy to byl backspace else if (onechar == BS) //backspace { //sprawdz czy index jest jeszcze w dopuszczlnym obszarze, //z lewej i z prawej strony if(i > 0 && i < CMD_MAX_LEN) { usart_put_char(BS); //wyczysc ostatni znak *(ptr_cmd_buf + i) = 0x0; //przesun o 1 do tylu aktualny indeks bufora i--; } } //jesli jakikolwiek inny klawisz ze znakow specjalnych else if(special) special = 0; //sprawdz czy to byl enter lub koniec transmisji else if (onechar == EOT || onechar ==LF || onechar ==CR_CM || onechar==ETB) { //usart_put_string("\r\n"); //usart_put_char((char*)LF); //usart_put_char((char*)CMD_PRMT); //zakoncz c-stringa znakiem konca= '\0' *(ptr_cmd_buf + i) = '\0'; //skopiuj te komende do kolejki przyjetych komend //add_to_history_cmd(com_cmd_hist, ptr_cmd_buf); //interpretacja komend interpreter(ptr_cmd_buf, i, NULL,ptr_cmd_buf); //przygotuj indeks pod nastepna komende na poczatek bufora i= 0; //byl ENTER, wiec ustaw ze nie kasuje nic STRZALKA W GORE wypisujaca z historii was_hist = 0; } } } }
/*! \internal */ QSWrapperFactory::~QSWrapperFactory() { if( interpreter() ) interpreter()->removeWrapperFactory( this ); delete d; }
JSStack* CallFrame::stack() { return &interpreter()->stack(); }
bool AutoScheduleTransformer::autotune(AstTranslationUnit& translationUnit, std::ostream* report) { const QueryExecutionStrategy& strategy = ScheduledExecution; bool verbose = Global::config().has("verbose"); // start with status message if (verbose) { std::cout << "\n"; } if (verbose) { std::cout << "----------------- Auto-Scheduling Started -----------------\n"; } // step 1 - translate to RAM program if (verbose) { std::cout << "[ Converting to RAM Program ... ]\n"; } std::unique_ptr<RamStatement> stmt = RamTranslator().translateProgram(translationUnit); // check whether there is something to tune if (!stmt) { if (verbose) { std::cout << "[ No Rules in Program ]\n"; std::cout << "---------------- Auto-Scheduling Completed ----------------\n"; } return false; } if (verbose) { std::cout << "[ Done ]\n"; } // step 2 - run in interpreted mode, collect decisions if (verbose) { std::cout << "[ Profiling RAM Program ... ]\n"; } Profiler::Data data; Profiler profiler(strategy, data); // create a copy of the symbol table souffle::SymbolTable table = translationUnit.getSymbolTable(); // create interpreter instance RamGuidedInterpreter interpreter(profiler); if (report && verbose) { SplitStream splitStream(report, &std::cout); interpreter.setReportTarget(splitStream); } else if (report) { interpreter.setReportTarget(*report); } else if (verbose) { interpreter.setReportTarget(std::cout); } // run interpreter interpreter.execute(table, *stmt); if (verbose) { std::cout << "[ Done ]\n"; } if (verbose) { std::cout << "Data:\n"; for (const auto& cur : data) { std::cout << "Clause @ " << cur.first << "\n"; for (const ExecutionSummary& instance : cur.second) { std::cout << "\t" << instance.order << " in " << instance.time << "ms\n"; } } } // step 3 - process collected data .. if (verbose) { std::cout << "[ Selecting most significant schedules ... ]\n"; } std::map<AstSrcLocation, const AstClause*> clauses; visitDepthFirst(*translationUnit.getProgram(), [&](const AstClause& clause) { clauses[clause.getSrcLoc()] = &clause; }); std::map<const AstClause*, long> longestTime; std::map<const AstClause*, Order> bestOrders; // extract best order for each clause for (const auto& cur : data) { const AstClause* clause = clauses[cur.first]; assert(clause && "Unknown clause discovered!"); for (const ExecutionSummary& instance : cur.second) { if (longestTime[clause] < instance.time) { longestTime[clause] = instance.time; bestOrders[clause] = instance.order; } } } if (verbose) { for (const auto& cur : bestOrders) { std::cout << *cur.first << "\n Best Order: " << cur.second << "\n Time: " << longestTime[cur.first] << "\n\n"; } } if (verbose) { std::cout << "[ Done ]\n"; } // step 4 - apply transformations if (verbose) { std::cout << "[ Re-scheduling rules ... ]\n"; } bool changed = false; for (const auto& cur : bestOrders) { AstClause* clause = const_cast<AstClause*>(cur.first); bool orderChanged = false; const std::vector<unsigned>& newOrder = cur.second.getOrder(); // Check whether best order is different to the original order for (unsigned int i = 0; i < clause->getAtoms().size(); i++) { if (newOrder[i] != i) { orderChanged = true; break; } } if (orderChanged) { clause->reorderAtoms(newOrder); changed = true; } } if (verbose) { std::cout << "[ Done ]\n"; } // end with status message if (verbose) { std::cout << "---------------- Auto-Scheduling Completed -----------------\n"; } return changed; }
void dfsch_tcl_destroy_interpreter(dfsch_object_t* obj){ interpreter_t* i = interpreter(obj); i->active = 0; Tcl_DeleteInterp(i->interpreter); }