void ModuleTestListenerLoaderImpl:: load( const StringList& searchingPaths , TestResultReporter* resultReporter , TestSuiteResultReporter* suiteResultReporter , TestCaseResultReporter* caseResultReporter) { loader->load(searchingPaths, getListenerSharedObjectName(name)); typedef TestListener* (*TestListenerCreater) \ ( TestResultReporter* \ , TestSuiteResultReporter* \ , TestCaseResultReporter* \ , int, char**); TestListenerCreater create = (TestListenerCreater) \ loader->findSymbol(getCreaterSymbolName(name)); listener = create( resultReporter , suiteResultReporter , caseResultReporter , args.first , args.second); if(listener == 0) { throw Error("Cannot create listener"); } }
void ModuleTestListenerLoaderImpl::destroyListener() { typedef void (*TestListenerDestroy)(TestListener*); TestListenerDestroy destroy = 0; __TESTNGPPST_TRY { destroy = (TestListenerDestroy) \ loader->findSymbol(getDestroySymbolName(name)); destroy(listener); } __TESTNGPPST_CATCH_ALL { delete listener; } __TESTNGPPST_FINALLY { listener = 0; loader->unload(); } __TESTNGPPST_DONE }
void AppFalcon::compileTLTable() { ModuleLoader ml; // the load path is not relevant, as we load by file name or stream // apply options ml.compileTemplate( m_options.parse_ftd ); ml.saveModules( false ); ml.alwaysRecomp( true ); // will throw Error* on failure Module* mod = loadInput( ml ); // try to open the oputput stream. Stream* out = 0; try { String ioEncoding = getIoEncoding(); out = AddSystemEOL( TranscoderFactory ( ioEncoding == "" ? "C" : ioEncoding, openOutputStream ( "temp.ftt" ), true ) ); // Ok, we have the output stream. if ( ! mod->saveTableTemplate( out, ioEncoding == "" ? "C" : ioEncoding ) ) throw String( "can't write on output stream." ); } catch( ... ) { delete out; mod->decref(); throw; } delete out; mod->decref(); }
RangeSensor::RangeSensor(const QString &port, const trikKernel::Configurer &configurer, ModuleLoader &moduleLoader , const trikHal::HardwareAbstractionInterface &hardwareAbstraction) : mState("Range Sensor on " + port) { if (!moduleLoader.load(configurer.attributeByPort(port, "module")) || !moduleLoader.load(configurer.attributeByDevice("rangeSensor", "commonModule"))) { QLOG_ERROR() << "Module loading failed"; mState.fail(); return; } mMinValue = ConfigurerHelper::configureInt(configurer, mState, port, "minValue"); mMaxValue = ConfigurerHelper::configureInt(configurer, mState, port, "maxValue"); mSensorWorker.reset(new RangeSensorWorker(configurer.attributeByPort(port, "eventFile"), mState , hardwareAbstraction)); if (!mState.isFailed()) { mSensorWorker->moveToThread(&mWorkerThread); connect(mSensorWorker.data(), SIGNAL(newData(int, int, trikKernel::TimeVal)) , this, SIGNAL(newData(int, int, trikKernel::TimeVal))); QLOG_INFO() << "Starting RangeSensor worker thread" << &mWorkerThread; mWorkerThread.start(); }
void MemChecker::start() { if (!needMemCheck()) { return; } ModuleLoader *loader = testcase->getLoader(); typedef void (*start_t)(mem_checker::Reporter *, mem_checker::Reporter *); start_t starter = (start_t)loader->findSymbol("startMemChecker"); TestFixture *fixture = testcase->getFixture(); info = mem_checker::createReporter(InfoReporter(fixture)); failure = mem_checker::createReporter(FailureReporter(fixture)); // Note: Reporter is new in runner.exe, and used in .dll. is this ok? starter(info, failure); }
void MemChecker::verify() { if (!needMemCheck()) { return; } ModuleLoader *loader = testcase->getLoader(); typedef void (*verify_t)(void); verify_t verifier = (verify_t)loader->findSymbol("verifyMemChecker"); verifier(); //delete info; // Note: this will cause linux run exception //delete failure; //info = 0; //failure = 0; }
RangeSensor::RangeSensor(QString const &port, trikKernel::Configurer const &configurer, ModuleLoader &moduleLoader) { if (!moduleLoader.load(configurer.attributeByPort(port, "module")) || !moduleLoader.load(configurer.attributeByDevice("rangeSensor", "commonModule"))) { QLOG_ERROR() << "Module loading failed"; mState.fail(); return; } mSensorWorker.reset(new RangeSensorWorker(configurer.attributeByPort(port, "eventFile"), mState)); if (!mState.isFailed()) { mSensorWorker->moveToThread(&mWorkerThread); connect(mSensorWorker.data(), SIGNAL(newData(int, int)), this, SIGNAL(newData(int, int))); mWorkerThread.start(); }
void AppFalcon::generateAssembly() { ModuleLoader ml; // the load path is not relevant, as we load by file name or stream // apply options ml.compileTemplate( m_options.parse_ftd ); ml.saveModules( false ); ml.alwaysRecomp( true ); // will throw Error* on failure Module* mod = loadInput( ml ); // try to open the oputput stream. Stream* out = 0; try { String ioEncoding = getIoEncoding(); out = AddSystemEOL( TranscoderFactory ( ioEncoding == "" ? "C" : ioEncoding, openOutputStream( "fas" ), true ) ); // Ok, we have the output stream. GenHAsm gasm(out); gasm.generatePrologue( mod ); gasm.generate( ml.compiler().sourceTree() ); if ( ! out->good() ) throw String( "can't write on output stream." ); } catch( const String & ) { delete out; mod->decref(); throw; } delete out; mod->decref(); }
void AppFalcon::buildModule() { ModuleLoader ml; // the load path is not relevant, as we load by file name or stream // apply options ml.compileTemplate( m_options.parse_ftd ); ml.saveModules( false ); ml.alwaysRecomp( true ); // will throw Error* on failure Module* mod = loadInput( ml ); // try to open the oputput stream. Stream* out = 0; try { // binary out = openOutputStream ( "fam" ); // Ok, we have the output stream. GenCode gcode(mod); gcode.generate( ml.compiler().sourceTree() ); if ( ! mod->save( out ) ) throw String( "can't write on output stream." ); } catch( const String & ) { delete out; mod->decref(); throw; } delete out; mod->decref(); }
// we have enough information. if (m_progressObserver) { m_progressObserver->initialize(Tr::tr("Resolving project for configuration %1") .arg(TopLevelProject::deriveId(parameters.finalBuildConfigurationTree())), 1); cancelationTimer.setSingleShot(false); QObject::connect(&cancelationTimer, &QTimer::timeout, [this]() { QBS_ASSERT(m_progressObserver, return); if (m_progressObserver->canceled()) m_engine->cancel(); }); cancelationTimer.start(1000); } const FileTime resolveTime = FileTime::currentTime(); Evaluator evaluator(m_engine, m_logger); ModuleLoader moduleLoader(&evaluator, m_logger); moduleLoader.setProgressObserver(m_progressObserver); moduleLoader.setSearchPaths(m_searchPaths); moduleLoader.setOldProjectProbes(m_oldProjectProbes); moduleLoader.setOldProductProbes(m_oldProductProbes); const ModuleLoaderResult loadResult = moduleLoader.load(parameters); ProjectResolver resolver(&evaluator, loadResult, parameters, m_logger); resolver.setProgressObserver(m_progressObserver); const TopLevelProjectPtr project = resolver.resolve(); project->lastResolveTime = resolveTime; // E.g. if the top-level project is disabled. if (m_progressObserver) m_progressObserver->setFinished(); return project;
void AppFalcon::runModule() { ModuleLoader ml; prepareLoader( ml ); // Create the runtime using the given module loader. Runtime runtime( &ml ); // now that we have the main module, inject other requested modules ListElement *pliter = m_options.preloaded.begin(); while ( pliter != 0 ) { Module *module = ml.loadName ( * ( ( String * ) pliter->data() ) ); runtime.addModule( module ); // abandon our reference to the injected module module->decref(); pliter = pliter->next(); } // then add the main module Module* mainMod = loadInput(ml); runtime.addModule( mainMod ); // abandon our reference to the main module mainMod->decref(); //=========================================== // Prepare the virtual machine // VMachineWrapper vmachine; //redirect the VM streams to ours. // The machine takes ownership of the streams, so they won't be useable anymore // after the machine destruction. readyStreams(); vmachine->stdIn( m_stdIn ); vmachine->stdOut( m_stdOut ); vmachine->stdErr( m_stdErr ); // I have given real process streams to the vm vmachine->hasProcessStreams( true ); // push the core module // we know we're not launching the core module. vmachine->launchAtLink( false ); Module* core = core_module_init(); #ifdef NDEBUG vmachine->link ( core ); #else LiveModule *res = vmachine->link ( core ); fassert ( res != 0 ); // should not fail #endif core->decref(); // prepare environment Item *item_args = vmachine->findGlobalItem ( "args" ); fassert ( item_args != 0 ); CoreArray *args = new CoreArray ( m_argc - m_script_pos ); String ioEncoding = getIoEncoding(); for ( int ap = m_script_pos; ap < m_argc; ap ++ ) { CoreString *cs = new CoreString; if ( ! TranscodeFromString ( m_argv[ap], ioEncoding, *cs ) ) { cs->bufferize ( m_argv[ap] ); } args->append ( cs ); } item_args->setArray ( args ); Item *script_name = vmachine->findGlobalItem ( "scriptName" ); fassert ( script_name != 0 ); *script_name = new CoreString ( mainMod->name() ); Item *script_path = vmachine->findGlobalItem ( "scriptPath" ); fassert ( script_path != 0 ); *script_path = new CoreString ( mainMod->path() ); // Link the runtime in the VM. // We'll be running the modules as we link them in. vmachine->launchAtLink( true ); if ( vmachine->link( &runtime ) ) { vmachine->launch(); if ( vmachine->regA().isInteger() ) exitval( ( int32 ) vmachine->regA().asInteger() ); } }
void AppFalcon::prepareLoader( ModuleLoader &ml ) { // 1. Ready the module loader ModuleLoader *modLoader = &ml; ml.setSearchPath( getLoadPath() ); // adds also the input path. if ( m_options.input != "" && m_options.input != "-" ) { URI in_uri( m_options.input ); in_uri.pathElement().setFilename(""); // empty path? -- add current directory (may be removed from defaults) if ( in_uri.get() == "" ) modLoader->addSearchPath ( "." ); else modLoader->addSearchPath ( in_uri.get() ); } // set the module preferred language; ok also if default ("") is used modLoader->setLanguage ( m_options.module_language ); applyDirectives( modLoader->compiler() ); applyConstants( modLoader->compiler() ); // save the main module also if compile only option is set modLoader->saveModules ( m_options.save_modules ); modLoader->compileInMemory ( m_options.comp_memory ); modLoader->alwaysRecomp ( m_options.force_recomp ); modLoader->sourceEncoding ( getSrcEncoding() ); // normally, save is not mandatory, unless we compile them our own // should be the default, but we reset it. modLoader->saveMandatory ( false ); // should we forcefully consider input as ftd? modLoader->compileTemplate ( m_options.parse_ftd ); Engine::setSearchPath( modLoader->getSearchPath() ); }
int main( int argc, char *argv[] ) { // Install a void ctrl-c handler (let ctrl-c to kill this app) Sys::_dummy_ctrl_c_handler(); Falcon::Engine::AutoInit autoInit; int script_pos = argc; char *input_file = 0; FileStream *bincode_stream; stdOut = stdOutputStream(); stdErr = stdErrorStream(); stdIn = stdInputStream(); // option decoding for ( int i = 1; i < argc; i++ ) { char *op = argv[i]; if (op[0] == '-' ) { switch ( op[1] ) { case 'e': if ( op[2] == 0 && i < argc + 1) { io_encoding = argv[++i]; } else { io_encoding = op + 2; } break; case 'h': usage(); return 0; case 'L': if ( op[2] == 0 && i < argc + 1) load_path = argv[++i]; else load_path = op + 2; break; break; case 'P': ignore_defpath = true; break; case 'l': if ( op[2] == 0 && i + 1 < argc ) module_language = argv[++i]; else module_language = op + 2; break; case 'p': if ( op[2] == 0 && i < argc + 1) preloaded.pushBack( argv[++i] ); else preloaded.pushBack( op + 2 ); break; case 'v': version(); return 0; default: stdOut->writeString( "falrun: unrecognized option '" ); stdOut->writeString( op ); stdOut->writeString( "'.\n\n" ); usage(); return 1; } } else { input_file = op; script_pos = i+1; break; } } // eventually change the encodings. io_encoding = get_io_encoding(); if ( io_encoding != "" ) { Transcoder *trans = TranscoderFactory( io_encoding, 0, true ); if ( trans == 0 ) { stdOut->writeString( "Fatal: unrecognized encoding '" + io_encoding + "'.\n\n" ); return 1; } delete stdIn ; delete stdOut; delete stdErr; trans->setUnderlying( new StdInStream ); stdIn = AddSystemEOL( trans, true ); stdOut = AddSystemEOL( TranscoderFactory( io_encoding, new StdOutStream, true ), true ); stdErr = AddSystemEOL( TranscoderFactory( io_encoding, new StdErrStream, true ), true ); } if ( input_file == 0 ) { stdOut->writeString( "falrun: missing script name.\n" ); usage(); return 1; } bincode_stream = new FileStream; bincode_stream->open( input_file ); if ( ! bincode_stream->good() ) { stdOut->writeString( "falrun: Can't open file " ); stdOut->writeString( input_file ); stdOut->writeString( "\n" ); stdOut->flush(); return 1; } String module_name; String source_path; findModuleName( input_file, module_name ); findModulepath( input_file, source_path ); //----------------------------------------- // execute the script. // if ( source_path != "" ) source_path += ";"; try { ModuleLoader *modloader = new ModuleLoader( source_path + get_load_path() ); Engine::setSearchPath( modloader->getSearchPath() ); // set the module preferred language; ok also if default ("") is used modloader->setLanguage( module_language ); Module *core = core_module_init(); Module *main_mod = modloader->loadModule( bincode_stream ); VMachine *vmachine = new VMachine(false); // change default machine streams. vmachine->stdIn( stdIn ); vmachine->stdOut( stdOut ); vmachine->stdErr( stdErr ); vmachine->init(); vmachine->link( core ); core->decref(); Runtime *runtime = new Runtime( modloader ); // preload required modules ListElement *pliter = preloaded.begin(); while( pliter != 0 ) { Module *module = modloader->loadName( * ((String *) pliter->data()) ); runtime->addModule( module ); pliter = pliter->next(); } Item *item_args = vmachine->findGlobalItem( "args" ); fassert( item_args != 0 ); CoreArray *args = new CoreArray( argc - script_pos ); for ( int ap = script_pos; ap < argc; ap ++ ) { args->append( new CoreString( argv[ap] ) ); } item_args->setArray( args ); Item *script_name = vmachine->findGlobalItem( "scriptName" ); fassert( script_name != 0 ); script_name->setString( new CoreString( module_name ) ); // the runtime will try to load the references. runtime->addModule( main_mod ); if( vmachine->link( runtime ) ) { vmachine->launch(); if ( vmachine->regA().type() == FLC_ITEM_INT ) return (int32) vmachine->regA().asInteger(); return 0; } vmachine->finalize(); } catch ( Error *err ) { String temp; err->toString( temp ); stdErr->writeString( "falcon: FATAL - Program terminated with error.\n" ); stdErr->writeString( temp + "\n" ); err->decref(); return 1; } return 255; }