int AgiEngine::agiInit() { int ec, i; debug(2, "initializing"); debug(2, "game version = 0x%x", getVersion()); // initialize with adj.ego.move.to.x.y(0, 0) so to speak _game.adjMouseX = _game.adjMouseY = 0; // reset all flags to false and all variables to 0 for (i = 0; i < MAX_FLAGS; i++) _game.flags[i] = 0; for (i = 0; i < MAX_VARS; i++) _game.vars[i] = 0; // clear all resources and events for (i = 0; i < MAX_DIRS; i++) { memset(&_game.views[i], 0, sizeof(struct AgiView)); memset(&_game.pictures[i], 0, sizeof(struct AgiPicture)); memset(&_game.logics[i], 0, sizeof(struct AgiLogic)); memset(&_game.sounds[i], 0, sizeof(class AgiSound *)); // _game.sounds contains pointers now memset(&_game.dirView[i], 0, sizeof(struct AgiDir)); memset(&_game.dirPic[i], 0, sizeof(struct AgiDir)); memset(&_game.dirLogic[i], 0, sizeof(struct AgiDir)); memset(&_game.dirSound[i], 0, sizeof(struct AgiDir)); } // clear view table for (i = 0; i < MAX_VIEWTABLE; i++) memset(&_game.viewTable[i], 0, sizeof(struct VtEntry)); initWords(); if (!_menu) _menu = new Menu(this, _gfx, _picture); initPriTable(); // clear string buffer for (i = 0; i < MAX_STRINGS; i++) _game.strings[i][0] = 0; // setup emulation switch (getVersion() >> 12) { case 2: debug("Emulating Sierra AGI v%x.%03x\n", (int)(getVersion() >> 12) & 0xF, (int)(getVersion()) & 0xFFF); break; case 3: debug("Emulating Sierra AGI v%x.002.%03x\n", (int)(getVersion() >> 12) & 0xF, (int)(getVersion()) & 0xFFF); break; } if (getPlatform() == Common::kPlatformAmiga) _game.gameFlags |= ID_AMIGA; if (getFeatures() & GF_AGDS) _game.gameFlags |= ID_AGDS; // Make the 256 color AGI screen the default AGI screen when AGI256 or AGI256-2 is used if (getFeatures() & (GF_AGI256 | GF_AGI256_2)) _game.sbuf = _game.sbuf256c; if (_game.gameFlags & ID_AMIGA) debug(1, "Amiga padded game detected."); if (_game.gameFlags & ID_AGDS) debug(1, "AGDS mode enabled."); ec = _loader->init(); // load vol files, etc if (ec == errOK) ec = _loader->loadObjects(OBJECTS); // note: demogs has no words.tok if (ec == errOK) ec = _loader->loadWords(WORDS); // FIXME: load IIgs instruments and samples // load_instruments("kq.sys16"); // Load logic 0 into memory if (ec == errOK) ec = _loader->loadResource(rLOGIC, 0); #ifdef __DS__ // Normally, the engine loads the predictive text dictionary when the predictive dialog // is shown. On the DS version, the word completion feature needs the dictionary too. loadDict(); #endif _egoHoldKey = false; _game.mouseFence.setWidth(0); // Reset return ec; }
/** @cond doxygenLibsbmlInternal */ void TextGlyph::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); unsigned int numErrs; /* look to see whether an unknown attribute error was logged * during the read of the listOfTextGlyphs - which will have * happened immediately prior to this read */ bool loSubGlyphs = false; if (getParentSBMLObject() != NULL && getParentSBMLObject()->getElementName() == "listOfSubGlyphs") { loSubGlyphs = true; } if (getErrorLog() != NULL && static_cast<ListOfTextGlyphs*>(getParentSBMLObject())->size() < 2) { numErrs = getErrorLog()->getNumErrors(); for (int n = numErrs-1; n >= 0; n--) { if (getErrorLog()->getError(n)->getErrorId() == UnknownPackageAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownPackageAttribute); if (loSubGlyphs == true) { getErrorLog()->logPackageError("layout", LayoutLOSubGlyphAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details); } else { getErrorLog()->logPackageError("layout", LayoutLOTextGlyphAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details); } } else if (getErrorLog()->getError(n)->getErrorId() == UnknownCoreAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownCoreAttribute); if (loSubGlyphs == true) { getErrorLog()->logPackageError("layout", LayoutLOSubGlyphAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details); } else { getErrorLog()->logPackageError("layout", LayoutLOTextGlyphAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details); } } } } GraphicalObject::readAttributes(attributes, expectedAttributes); // look to see whether an unknown attribute error was logged if (getErrorLog() != NULL) { numErrs = getErrorLog()->getNumErrors(); for (int n = numErrs-1; n >= 0; n--) { if (getErrorLog()->getError(n)->getErrorId() == UnknownPackageAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownPackageAttribute); getErrorLog()->logPackageError("layout", LayoutTGAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details); } else if (getErrorLog()->getError(n)->getErrorId() == UnknownCoreAttribute) { const std::string details = getErrorLog()->getError(n)->getMessage(); getErrorLog()->remove(UnknownCoreAttribute); getErrorLog()->logPackageError("layout", LayoutTGAllowedCoreAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details); } } } bool assigned = false; // // graphicalObject SIdRef ( use = "optional" ) // assigned = attributes.readInto("graphicalObject", mGraphicalObject); if (assigned == true && getErrorLog() != NULL) { // check string is not empty and correct syntax if (mGraphicalObject.empty() == true) { logEmptyString(mGraphicalObject, getLevel(), getVersion(), "<TextGlyph>"); } else if (SyntaxChecker::isValidSBMLSId(mGraphicalObject) == false) { getErrorLog()->logPackageError("layout", LayoutTGGraphicalObjectSyntax, getPackageVersion(), sbmlLevel, sbmlVersion); } } // // text string ( use = "optional" ) // assigned = attributes.readInto("text", mText); if (assigned == true && getErrorLog() != NULL) { // check string is not empty if (mText.empty() == true) { logEmptyString(mText, getLevel(), getVersion(), "<TextGlyph>"); } } // // originOfText SIdRef ( use = "optional" ) // assigned = attributes.readInto("originOfText", mOriginOfText); if (assigned == true && getErrorLog() != NULL) { // check string is not empty and correct syntax if (mOriginOfText.empty() == true) { logEmptyString(mOriginOfText, getLevel(), getVersion(), "<TextGlyph>"); } else if (SyntaxChecker::isValidSBMLSId(mOriginOfText) == false) { getErrorLog()->logPackageError("layout", LayoutTGOriginOfTextSyntax, getPackageVersion(), sbmlLevel, sbmlVersion); } } }
//na lokacijo (x, y) izpise verzijo programa void drawVersion(int x, int y){ GrX = x; GrY = y; printf("%s", getVersion()); LCD_sendC(); }
/** @cond doxygenLibsbmlInternal */ void ReactionGlyph::readAttributes (const XMLAttributes& attributes, const ExpectedAttributes& expectedAttributes) { const unsigned int sbmlLevel = getLevel (); const unsigned int sbmlVersion = getVersion(); unsigned int numErrs; /* look to see whether an unknown attribute error was logged * during the read of the listOfReactionGlyphs - which will have * happened immediately prior to this read */ bool loSubGlyphs = false; if (getParentSBMLObject() != NULL && getParentSBMLObject()->getElementName() == "listOfSubGlyphs") { loSubGlyphs = true; } if (getErrorLog() != NULL && static_cast<ListOfReactionGlyphs*>(getParentSBMLObject())->size() < 2) { numErrs = getErrorLog()->getNumErrors(); for (int n = (int)numErrs-1; n >= 0; n--) { if (getErrorLog()->getError((unsigned int)n)->getErrorId() == UnknownPackageAttribute) { const std::string details = getErrorLog()->getError((unsigned int)n)->getMessage(); getErrorLog()->remove(UnknownPackageAttribute); if (loSubGlyphs == true) { getErrorLog()->logPackageError("layout", LayoutLOSubGlyphAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } else { getErrorLog()->logPackageError("layout", LayoutLORnGlyphAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } } else if (getErrorLog()->getError((unsigned int)n)->getErrorId() == UnknownCoreAttribute) { const std::string details = getErrorLog()->getError((unsigned int)n)->getMessage(); getErrorLog()->remove(UnknownCoreAttribute); if (loSubGlyphs == true) { getErrorLog()->logPackageError("layout", LayoutLOSubGlyphAllowedAttribs, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } else { getErrorLog()->logPackageError("layout", LayoutLORnGlyphAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } } } } GraphicalObject::readAttributes(attributes, expectedAttributes); // look to see whether an unknown attribute error was logged if (getErrorLog() != NULL) { numErrs = getErrorLog()->getNumErrors(); for (int n = (int)numErrs-1; n >= 0; n--) { if (getErrorLog()->getError((unsigned int)n)->getErrorId() == UnknownPackageAttribute) { const std::string details = getErrorLog()->getError((unsigned int)n)->getMessage(); getErrorLog()->remove(UnknownPackageAttribute); getErrorLog()->logPackageError("layout", LayoutRGAllowedAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } else if (getErrorLog()->getError((unsigned int)n)->getErrorId() == UnknownCoreAttribute) { const std::string details = getErrorLog()->getError((unsigned int)n)->getMessage(); getErrorLog()->remove(UnknownCoreAttribute); getErrorLog()->logPackageError("layout", LayoutRGAllowedCoreAttributes, getPackageVersion(), sbmlLevel, sbmlVersion, details, getLine(), getColumn()); } } } bool assigned = false; // // reaction SIdRef ( use = "optional" ) // assigned = attributes.readInto("reaction", mReaction); if (assigned == true && getErrorLog() != NULL) { // check string is not empty and correct syntax if (mReaction.empty() == true) { logEmptyString(mReaction, getLevel(), getVersion(), "<ReactionGlyph>"); } else if (SyntaxChecker::isValidSBMLSId(mReaction) == false) { getErrorLog()->logPackageError("layout", LayoutRGReactionSyntax, getPackageVersion(), sbmlLevel, sbmlVersion, "The reaction on the <" + getElementName() + "> is '" + mReaction + "', which does not conform to the syntax.", getLine(), getColumn()); } } }
void AgiEngine::initialize() { // TODO: Some sound emulation modes do not fit our current music // drivers, and I'm not sure what they are. For now, they might // as well be called "PC Speaker" and "Not PC Speaker". // If used platform is Apple IIGS then we must use Apple IIGS sound emulation // because Apple IIGS AGI games use only Apple IIGS specific sound resources. if (getPlatform() == Common::kPlatformApple2GS) { _soundemu = SOUND_EMU_APPLE2GS; } else if (getPlatform() == Common::kPlatformCoCo3) { _soundemu = SOUND_EMU_COCO3; } else if (ConfMan.get("music_driver") == "auto") { // Default sound is the proper PCJr emulation _soundemu = SOUND_EMU_PCJR; } else { switch (MidiDriver::getMusicType(MidiDriver::detectDevice(MDT_PCSPK | MDT_AMIGA | MDT_ADLIB | MDT_PCJR | MDT_MIDI))) { case MT_PCSPK: _soundemu = SOUND_EMU_PC; break; case MT_ADLIB: _soundemu = SOUND_EMU_NONE; break; case MT_PCJR: _soundemu = SOUND_EMU_PCJR; break; case MT_AMIGA: _soundemu = SOUND_EMU_AMIGA; break; default: debug(0, "DEF"); _soundemu = SOUND_EMU_MIDI; break; } } initRenderMode(); _console = new Console(this); _words = new Words(this); _font = new GfxFont(this); _gfx = new GfxMgr(this, _font); _sound = new SoundMgr(this, _mixer); _picture = new PictureMgr(this, _gfx); _sprites = new SpritesMgr(this, _gfx); _text = new TextMgr(this, _words, _gfx); _systemUI = new SystemUI(this, _gfx, _text); _inventory = new InventoryMgr(this, _gfx, _text, _systemUI); _font->init(); _gfx->initVideo(); _text->init(_systemUI); _game.gameFlags = 0; _text->charAttrib_Set(15, 0); _game.name[0] = '\0'; _lastSaveTime = 0; debugC(2, kDebugLevelMain, "Detect game"); if (agiDetectGame() == errOK) { debugC(2, kDebugLevelMain, "game loaded"); } else { warning("Could not open AGI game"); } // finally set up actual VM opcodes, because we should now have figured out the right AGI version setupOpCodes(getVersion()); debugC(2, kDebugLevelMain, "Init sound"); }
MainWindow::MainWindow( QWidget *parent ) : QMainWindow( parent ) { // QObject::connect( this, SIGNAL( finishedBuildFilelist( bool ) ), this, SLOT( doIt( bool ) ) ); // ********************************************************************************************** setWaitCursor(); // ********************************************************************************************** // init gi_ActionNumber = 1; gi_Extension = _TXT_; gs_Version = "unknown"; gsl_FilenameList.clear(); // ********************************************************************************************** #if defined(Q_OS_LINUX) gb_showProgressBar = true; #endif #if defined(Q_OS_MAC) gb_showProgressBar = false; #endif #if defined(Q_OS_WIN) gb_showProgressBar = true; #endif // ********************************************************************************************** Model = new QStringListModel( this ); ListView = new QListView; ListView->setModel( Model ); ListView->setEditTriggers( QAbstractItemView::NoEditTriggers ); setCentralWidget( ListView ); setAcceptDrops( true ); // ********************************************************************************************** loadPreferences(); if ( gi_NumOfProgramStarts++ < 1 ) savePreferences(); gs_Version = getVersion(); // ********************************************************************************************** createActions(); createMenus(); createStatusBar( gb_showProgressBar ); // ********************************************************************************************** this->resize( sizeWindow ); this->move( posWindow ); this->show(); // ********************************************************************************************** gsl_FilenameList = expandCommandline(); // ********************************************************************************************** setGeocodeRangeFlagAction->setChecked( gb_setGeocode ); setWTitle( gi_ActionNumber, gs_FilenameFormat, gi_Extension, gsl_FilenameList ); setStatusBar( tr( "Ready" ), 2 ); setNormalCursor(); }
return impl_->cm->sync( version ); } uint128_t Object::getHeadVersion() const { return impl_->cm->getHeadVersion(); } uint128_t Object::getVersion() const { return impl_->cm->getVersion(); } void Object::notifyNewHeadVersion( const uint128_t& version LB_UNUSED ) { LBASSERTINFO( getVersion() == VERSION_NONE || version < getVersion() + 100, lunchbox::className( this )); } CompressorInfo Object::chooseCompressor() const { return pression::data::Registry::getInstance().choose(); } uint32_t Object::getMasterInstanceID() const { return impl_->cm->getMasterInstanceID(); } NodePtr Object::getMasterNode()
void cmdPopScript(AgiGame *state, uint8 *p) { if (getVersion() >= 0x2915) { debug(0, "pop.script"); } }
void cmdHoldKey(AgiGame *state, uint8 *p) { if (getVersion() >= 0x3098) { state->_vm->_egoHoldKey = true; } }
bool run(const char *cmdns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool){ string configdb = cmdObj["configdb"].valuestrsafe(); { // configdb checking if ( configdb.size() == 0 ){ errmsg = "no configdb"; return false; } if ( shardConfigServer.size() == 0 ){ if ( ! cmdObj.getBoolField( "authoritative" ) ){ result.appendBool( "need_authoritative" , true ); errmsg = "first setShardVersion"; return false; } shardConfigServer = configdb; } else if ( shardConfigServer != configdb ){ errmsg = "specified a different configdb!"; return false; } } { // setting up ids if ( cmdObj["serverID"].type() != jstOID ){ // TODO: fix this //errmsg = "need serverID to be an OID"; //return 0; } else { OID clientId = cmdObj["serverID"].__oid(); if ( ! clientServerIds.get() ){ string s = clientId.str(); OID * nid = new OID(); nid->init( s ); clientServerIds.reset( nid ); if ( ! clientQueues[s] ) clientQueues[s] = new BlockingQueue<BSONObj>(); } else if ( clientId != *clientServerIds.get() ){ errmsg = "server id has changed!"; return 0; } } } unsigned long long version = getVersion( cmdObj["version"] , errmsg ); if ( ! version ) return false; NSVersions * versions = clientShardVersions.get(); if ( ! versions ){ log(1) << "entering shard mode for connection" << endl; versions = new NSVersions(); clientShardVersions.reset( versions ); } string ns = cmdObj["setShardVersion"].valuestrsafe(); if ( ns.size() == 0 ){ errmsg = "need to speciy fully namespace"; return false; } unsigned long long& oldVersion = (*versions)[ns]; if ( version < oldVersion ){ errmsg = "you already have a newer version"; result.appendTimestamp( "oldVersion" , oldVersion ); result.appendTimestamp( "newVersion" , version ); return false; } unsigned long long& myVersion = myVersions[ns]; if ( version < myVersion ){ errmsg = "going to older version for global"; return false; } if ( myVersion == 0 && ! cmdObj.getBoolField( "authoritative" ) ){ // need authoritative for first look result.appendBool( "need_authoritative" , true ); result.append( "ns" , ns ); errmsg = "first time for this ns"; return false; } result.appendTimestamp( "oldVersion" , oldVersion ); oldVersion = version; myVersion = version; result.append( "ok" , 1 ); return 1; }
bool run(const char *cmdns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool){ // see MoveShardStartCommand::run string ns = cmdObj["moveshard.finish"].valuestrsafe(); if ( ns.size() == 0 ){ errmsg = "need ns as cmd value"; return false; } string to = cmdObj["to"].valuestrsafe(); if ( to.size() == 0 ){ errmsg = "need to specify server to move shard to"; return false; } unsigned long long newVersion = getVersion( cmdObj["newVersion"] , errmsg ); if ( newVersion == 0 ){ errmsg = "have to specify new version number"; return false; } BSONObj finishToken = cmdObj.getObjectField( "finishToken" ); if ( finishToken.isEmpty() ){ errmsg = "need finishToken"; return false; } if ( ns != finishToken["collection"].valuestrsafe() ){ errmsg = "namespaced don't match"; return false; } // now we're locked myVersions[ns] = newVersion; NSVersions * versions = clientShardVersions.get(); if ( ! versions ){ versions = new NSVersions(); clientShardVersions.reset( versions ); } (*versions)[ns] = newVersion; BSONObj res; bool ok; { dbtemprelease unlock; ScopedDbConnection conn( to ); ok = conn->runCommand( "admin" , BSON( "finishCloneCollection" << finishToken ) , res ); conn.done(); } if ( ! ok ){ // uh oh errmsg = "finishCloneCollection failed!"; result << "finishError" << res; return false; } // wait until cursors are clean cerr << "WARNING: deleting data before ensuring no more cursors TODO" << endl; dbtemprelease unlock; DBDirectClient client; BSONObj removeFilter = finishToken.getObjectField( "query" ); client.remove( ns , removeFilter ); return true; }
/*********************************************************************** ************************************************************************ #cat: procargs - Process command line arguments, setting various #cat: static variables with file scope as appropriate. Input: argc - standard argument count argv - standard argument array Return Code: none - return on success no return - exit if invalid arguments are detected ************************************************************************/ static void procargs(int argc, char **argv) { int opt, output_images_flag = 0; const char *const option_spec = "vbc:rRf:i:n:q:"; const char *rest; REC_SEL *fgp_sel = NULL, *imp_sel = NULL, *idc_sel = NULL, *lrt_sel = NULL, *nqm_sel = NULL; if ((argc == 2) && (strcmp(argv[1], "-version") == 0)) { getVersion(); exit(0); } program = strrchr(argv[0], '/'); if (NULL == program) program = argv[0]; else ++program; if (argc < 2) usage(); /* The following section handles the deprecated old-style arguments. --jck */ old_style_args_flag = ((7 == argc) && ('-' != argv[1][0])); if (old_style_args_flag) { fgp = parse_num_arg(argv[1], "FGP"); bthr_adj = parse_num_arg(argv[2], "BTHR_ADJ"); rot_search = parse_num_arg(argv[3], "ROT_SEARCH"); comp = parse_num_arg(argv[4], "COMP_SEG"); rot_seg = parse_num_arg(argv[5], "ROT_SEG"); ifile = argv[6]; optind = 7; /* End of old-style deprecated argument handling. --jck */ } else { /* Processing exclusive to new-style argument handling... -- jck */ while (-1 != (opt = getopt(argc, argv, option_spec))) { switch(opt) { case 'v': verbose = 1; break; case 'b': bthr_adj = 1; break; case 'c': output_images_flag = 1; comp = parse_num_arg(optarg, "-c <COMP_SEG>"); break; case 'r': rot_search = 1; break; case 'R': rot_seg = 1; break; case 'f': if (parse_rec_sel_option(rs_fgp, optarg, &rest, &fgp_sel, verbose)) usage(); if (parse_rec_sel_option(rs_imp, rest, NULL, &imp_sel, verbose)) usage(); break; case 'i': if (parse_rec_sel_option(rs_imp, optarg, NULL, &imp_sel, verbose)) usage(); break; case 'n': if (parse_rec_sel_option(rs_idc, optarg, NULL, &idc_sel, verbose)) usage(); break; case 't': if (parse_rec_sel_option(rs_lrt, optarg, NULL, &lrt_sel, verbose)) usage(); break; case 'q': if (parse_rec_sel_option(rs_nqm, optarg, NULL, &nqm_sel, verbose)) usage(); break; case '?': usage(); break; default: fprintf(stderr, "Programming error: " "incompletely implemented option: '%c'\n", opt); exit(EXIT_FAILURE); } } /* ANSI/NIST input file, required */ if (optind < argc) ifile = argv[optind++]; else usage(); ansi_nist_flag = is_ANSI_NIST_file(ifile); if (ansi_nist_flag < 0) exit(EXIT_FAILURE); else if ( 0 == ansi_nist_flag ) { fprintf(stderr, "Input is not an ANSI/NIST file: '%s'.\n", ifile); usage(); } /* ANSI/NIST output file, optional */ if (optind < argc) ofile = argv[optind++]; if (new_rec_sel(&opt_rec_sel, rs_and, 5, fgp_sel, imp_sel, idc_sel, lrt_sel, nqm_sel) < 0) exit(EXIT_FAILURE); } /* This processing applies to both old- and new-style arguments. */ if (optind < argc) { fprintf(stderr, "WARNING : procargs : extra arguments ignored: %s", argv[optind++]); for (/* empty */; optind < argc; optind++) fprintf(stderr, ", %s", argv[optind]); fprintf(stderr, "\n"); } output_images = (ofile == NULL || output_images_flag); if (comp != UNSET && (comp < 0 || comp > 3)) { fprintf(stderr, "Invalid COMP (%d)\n", comp); fprintf(stderr, "0=JPEGL | 1=WSQ5:1 | 2=WSQ15:1 | 3=NONE\n"); exit(EXIT_FAILURE); } check_tristate_value(bthr_adj, "BTHR_ADJ"); check_tristate_value(rot_search, "ROT_SEARCH"); check_tristate_value(rot_seg, "ROT_SEG"); return; }
/* Start a new race. */ static void newrace(int index, tCarElt* car, tSituation *s) { total_tics[index]=0; /*********************************************************************************** ************************* UDP client identification ******************************** ***********************************************************************************/ bool identified=false; char line[UDP_MSGLEN]; // Set timeout if (getTimeout()>0) UDP_TIMEOUT = getTimeout(); //Set sensor range if (strcmp(getVersion(),"2009")==0) { __SENSORS_RANGE__ = 100; printf("*****2009*****\n"); } else if (strcmp(getVersion(),"2010")==0 || strcmp(getVersion(),"2011")==0) __SENSORS_RANGE__ = 200; else { printf("%s is not a recognized version",getVersion()); exit(0); } listenSocket[index] = socket(AF_INET, SOCK_DGRAM, 0); if (listenSocket[index] < 0) { std::cerr << "Error: cannot create listenSocket!"; exit(1); } srand(time(NULL)); // Bind listen socket to listen port. serverAddress[index].sin_family = AF_INET; serverAddress[index].sin_addr.s_addr = htonl(INADDR_ANY); serverAddress[index].sin_port = htons(getUDPListenPort()+index); if (bind(listenSocket[index], (struct sockaddr *) &serverAddress[index], sizeof(serverAddress[index])) < 0) { std::cerr << "cannot bind socket"; exit(1); } // Wait for connections from clients. listen(listenSocket[index], 5); std::cout << "Waiting for request on port " << getUDPListenPort()+index << "\n"; // Loop until a client identifies correctly while (!identified) { clientAddressLength[index] = sizeof(clientAddress[index]); // Set line to all zeroes memset(line, 0x0, UDP_MSGLEN); if (recvfrom(listenSocket[index], line, UDP_MSGLEN, 0, (struct sockaddr *) &clientAddress[index], &clientAddressLength[index]) < 0) { std::cerr << "Error: problem in receiving from the listen socket"; exit(1); } #ifdef __UDP_SERVER_VERBOSE__ // show the client's IP address std::cout << " from " << inet_ntoa(clientAddress[index].sin_addr); // show the client's port number. std::cout << ":" << ntohs(clientAddress[index].sin_port) << "\n"; // Show the line std::cout << " Received: " << line << "\n"; #endif // compare received string with the ID if (strncmp(line,UDP_ID,3)==0) { #ifdef __UDP_SERVER_VERBOSE__ std::cout << "IDENTIFIED" << std::endl; #endif std::string initStr(line); if (SimpleParser::parse(initStr,std::string("init"),trackSensAngle[index],19)==false) { for (int i = 0; i < 19; ++i) { trackSensAngle[index][i] =-90 + 10*i; } } // char line[UDP_MSGLEN]; sprintf(line,"***identified***"); // Sending the car state to the client if (sendto(listenSocket[index], line, strlen(line) + 1, 0, (struct sockaddr *) &clientAddress[index], sizeof(clientAddress[index])) < 0) std::cerr << "Error: cannot send identification message"; identified=true; } } focusSens[index] = new Sensors(car, 5);//ML for (int i = 0; i < 5; ++i) {//ML focusSens[index]->setSensor(i,(car->_focusCmd)+i-2,200);//ML }//ML // Initialization of track sensors trackSens[index] = new Sensors(car, 19); for (int i = 0; i < 19; ++i) { trackSens[index]->setSensor(i,trackSensAngle[index][i],__SENSORS_RANGE__); #ifdef __UDP_SERVER_VERBOSE__ std::cout << "Set Track Sensors " << i+1 << " at angle " << trackSensAngle[index][i] << std::endl; #endif } // Initialization of opponents sensors oppSens[index] = new ObstacleSensors(36, curTrack, car, s, __SENSORS_RANGE__); prevDist[index]=-1; }
void xml::lex::getXMLDecl(xml::token *tok) { static const char* s_version = "version"; static const char* s_encoding = "encoding"; static const char* s_standalone = "standalone"; static const char* s_endXMLDecl = "?>"; xmlDecl:; switch (m_sstate) { case _xml_decl_version : if (handleWhitespace() == false) { throw GException("XML Parser", 20, m_line, m_byte); } if (handleReserved(s_version) == false) { throw GException("XML Parser", 13, m_line, m_byte); } getEqual(); getQuote(); tok->m_type = xml::_version; if (getVersion(tok) == false) { throw GException("XML Parser", 13, m_line, m_byte); } getQuote(); m_sstate = xml::_xml_decl_encoding; break; case _xml_decl_encoding : handleWhitespace(); if (handleReserved(s_encoding) != false) { getEqual(); getQuote(); tok->m_type = xml::_encoding; if (getEncoding(tok) == false) { throw GException("XML Parser", 14, m_line, m_byte); } getQuote(); } else { m_sstate = xml::_xml_decl_standalone; goto xmlDecl; } m_sstate = xml::_xml_decl_standalone; break; case _xml_decl_standalone : handleWhitespace(); if (handleReserved(s_standalone) != false) { getEqual(); getQuote(); tok->m_type = xml::_standalone; if (getStandalone(tok) == false) { throw GException("XML Parser", 15, m_line, m_byte); } getQuote(); } handleWhitespace(); if (handleReserved(s_endXMLDecl) == false) { throw GException("XML Parser", 3, m_line, m_byte); } m_state = xml::_misc; } }
void rspfNitfFileHeaderV2_X::setDate(const rspfLocalTm& d) { memcpy(theDateTime, formatDate(getVersion(), d).c_str(), 14); }
void cmdDiscardSound(AgiGame *state, uint8 *p) { if (getVersion() >= 0x2936) { debug(0, "discard.sound"); } }
rspfRefPtr<rspfProperty> rspfNitfFileHeaderV2_X::getProperty(const rspfString& name)const { rspfRefPtr<rspfProperty> property = 0; if(name == FHDR_KW) { property = new rspfStringProperty(name, rspfString(theFileTypeVersion)); } else if(name == VERSION_KW) { property = new rspfStringProperty(name, rspfString(getVersion())); } else if(name == FILE_TYPE_KW) { property = new rspfStringProperty(name, "NITF"); } else if(name == CLEVEL_KW) { rspfNumericProperty* numericProperty = new rspfNumericProperty(name, getComplexityLevel(), 1, 99); numericProperty->setNumericType(rspfNumericProperty::rspfNumericPropertyType_INT); property = numericProperty; } else if(name == STYPE_KW) { property = new rspfStringProperty(name, getSystemType().trim()); } else if(name == OSTAID_KW) { property = new rspfStringProperty(name, getOriginatingStationId().trim()); } else if(name == FDT_KW) { property = new rspfStringProperty(name, getDate()); } else if(name == FTITLE_KW) { property = new rspfStringProperty(name, getTitle().trim()); } else if(name == FSCLAS_KW) { rspfStringProperty* stringProperty = new rspfStringProperty(name, getSecurityClassification().trim(), false); stringProperty->addConstraint(""); stringProperty->addConstraint("T"); stringProperty->addConstraint("S"); stringProperty->addConstraint("C"); stringProperty->addConstraint("R"); stringProperty->addConstraint("U"); property = stringProperty; } else if(name == FSCODE_KW) { property = new rspfStringProperty(name, getCodeWords().trim()); } else if(name == FSCTLH_KW) { property = new rspfStringProperty(name, getControlAndHandling().trim()); } else if(name == FSREL_KW) { property = new rspfStringProperty(name, getReleasingInstructions().trim()); } else if(name == FSCAUT_KW) { property = new rspfStringProperty(name, getClassificationAuthority().trim()); } else if(name == FSCTLN_KW) { property = new rspfStringProperty(name, getSecurityControlNumber().trim()); } else if(name == FSCOP_KW) { property = new rspfStringProperty(name, getCopyNumber().trim()); } else if(name == FSCPYS_KW) { property = new rspfStringProperty(name, getNumberOfCopies().trim()); } else if(name == ENCRYP_KW) { property = new rspfStringProperty(name, getEncryption().trim(), false); } else { property = rspfNitfFileHeader::getProperty(name).get(); } return property; }
void cmdAllowMenu(AgiGame *state, uint8 *p) { if (getVersion() >= 0x3098) { setflag(fMenusWork, ((p0 != 0) ? true : false)); } }
void Object::notifyNewHeadVersion( const uint128_t& version ) { EQASSERTINFO( getVersion() == VERSION_NONE || version < getVersion() + 100, base::className( this )); }
void cmdReleaseKey(AgiGame *state, uint8 *p) { if (getVersion() >= 0x3098) { state->_vm->_egoHoldKey = false; } }
uint128_t Object::sync( const uint128_t& version ) { if( version == VERSION_NONE ) return getVersion(); return impl_->cm->sync( version ); }
static int lua_msdk_getVersion(lua_State * L) { PUSHDELETESTRING(getVersion()); return 1; }
/*************************************************************************** Function: CheckFileVersion Purpose: Check the version information of a given file Input: File name File location (Windows dir, System dir, Current dir or none) Reference to Major number Reference to Minor number Reference to Build number Output: TRUE only if successful Remarks: Trashes original file name ****************************************************************************/ BOOL CDLLVersion::CheckFileVersion (LPSTR szFileName, int FileLoc, DWORD &dwMajor, DWORD &dwMinor, DWORD &dwBuildNumber) { LPSTR lpVersion; // String pointer to 'version' text //UINT uVersionLen; DWORD dwVerHnd=0; // An 'ignored' parameter, always '0' //VS_FIXEDFILEINFO vsFileInfo; FixFilePath (szFileName, FileLoc); // Add necessary path prefix to file name DWORD dwVerInfoSize = GetFileVersionInfoSize (szFileName, &dwVerHnd); if (!dwVerInfoSize) // Cannot reach the DLL file return FALSE; LPSTR lpstrVffInfo = (LPSTR) malloc (dwVerInfoSize); // Alloc memory for file info if (lpstrVffInfo == NULL) return FALSE; // Allocation failed // Try to get the info if (!GetFileVersionInfo(szFileName, dwVerHnd, dwVerInfoSize, lpstrVffInfo)) { free (lpstrVffInfo); return FALSE; // Cannot read the file information - // wierd, since we could read the information size } /* The below 'hex' value looks a little confusing, but essentially what it is, is the hexidecimal representation of a couple different values that represent the language and character set that we are wanting string values for. 040904E4 is a very common one, because it means: US English, Windows MultiLingual characterset Or to pull it all apart: 04------ = SUBLANG_ENGLISH_USA --09---- = LANG_ENGLISH ----04E4 = 1252 = Codepage for Windows:Multilingual */ /*static char fileVersion[256]; LPVOID version=NULL; DWORD vLen,langD; BOOL retVal; sprintf(fileVersion,"\\VarFileInfo\\Translation"); retVal = VerQueryValue ( lpstrVffInfo, fileVersion, &version, (UINT *)&uVersionLen); if (retVal && vLen==4) { memcpy(&langD,version,4); sprintf(fileVersion, "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion", (langD & 0xff00)>>8,langD & 0xff,(langD & 0xff000000)>>24, (langD & 0xff0000)>>16); } else sprintf(fileVersion,"\\StringFileInfo\\%04X04B0\\FileVersion",GetUserDefaultLangID()); if (!VerQueryValue ( lpstrVffInfo, fileVersion, (LPVOID *)&lpVersion, (UINT *)&uVersionLen)) { free (lpstrVffInfo); return FALSE; // Query was unsuccessful } */ // Now we have a string that looks like this : // "MajorVersion.MinorVersion.BuildNumber", so let's parse it lpVersion = getVersion(szFileName); m_stFullVersion = getVersion(szFileName); BOOL bRes = ParseVersionString (lpVersion, dwMajor, dwMinor, dwBuildNumber); if(!bRes) // Lets try for commas bRes = ParseVersionString1 (lpVersion, dwMajor, dwMinor, dwBuildNumber); free (lpstrVffInfo); return bRes; }
void EspNewIncomingConnectionStream::actOnReceive(IpcConnection *connection) { // check for OS errors if (getState() == ERROR_STATE) { ex_assert(FALSE,"Error while receiving first message from client"); } // check for protocol errors bool willPassTheAssertion = (getType() == IPC_MSG_SQLESP_DATA_REQUEST OR getType() == IPC_MSG_SQLESP_CANCEL_REQUEST) AND getVersion() == CurrEspRequestMessageVersion AND moreObjects(); if (!willPassTheAssertion) { char *doCatchBugCRx = getenv("ESP_BUGCATCHER_CR_NONUMBER"); if (!doCatchBugCRx || *doCatchBugCRx != '0') { connection->dumpAndStopOtherEnd(true, false); environment_->getControlConnection()-> castToGuaReceiveControlConnection()-> getConnection()->dumpAndStopOtherEnd(true, false); } } ex_assert((getType() == IPC_MSG_SQLESP_DATA_REQUEST OR getType() == IPC_MSG_SQLESP_CANCEL_REQUEST) AND getVersion() == CurrEspRequestMessageVersion AND moreObjects(), "Invalid first message from client"); // take a look at the type of the first object in the message IpcMessageObjType nextObjType = getNextObjType(); switch (nextObjType) { case ESP_OPEN_HDR: case ESP_LATE_CANCEL_HDR: { ExFragKey key; Lng32 remoteInstNum; NABoolean isParallelExtract = false; // peek at the message header to see for whom it is if (nextObjType == ESP_OPEN_HDR) { ExEspOpenReqHeader reqHdr((NAMemory *) NULL); *this >> reqHdr; key = reqHdr.key_; remoteInstNum = reqHdr.myInstanceNum_; if (reqHdr.getOpenType() == ExEspOpenReqHeader::PARALLEL_EXTRACT) { isParallelExtract = true; } } else { // note that the late cancel request may or may not // arrive as the first request (only in the former case // will we reach here) ExEspLateCancelReqHeader reqHdr((NAMemory *) NULL); *this >> reqHdr; key = reqHdr.key_; remoteInstNum = reqHdr.myInstanceNum_; } if (!isParallelExtract) { ExFragInstanceHandle handle = espFragInstanceDir_->findHandle(key); if (handle != NullFragInstanceHandle) { // the send bottom node # myInstanceNum of this downloaded fragment // is the true recipient of this open request ex_split_bottom_tcb * receivingTcb = espFragInstanceDir_->getTopTcb(handle); ex_send_bottom_tcb *receivingSendTcb = receivingTcb->getSendNode(remoteInstNum); // Check the connection for a co-located client, and if so, // tell the split bottom, because it may prefer this send // bottom when using skew buster uniform distribution. if (espFragInstanceDir_-> getEnvironment()-> getMyOwnProcessId(IPC_DOM_GUA_PHANDLE).match( connection->getOtherEnd().getNodeName(), connection->getOtherEnd().getCpuNum())) receivingTcb->setLocalSendBottom(remoteInstNum); // Portability note for the code above: we pass IPC_DOM_GUA_PHANDLE // for IpcEnvironment::getMyOwnProcessId, even though that method // can be called with the default param (IpcNetworkDomain // IPC_DOM_INVALID). In fact it would probably be better // to call the object without specifying the IpcNetworkDomain so // that it can decide for itself what domain it is using. // But there is a problem with the Windows implementation // of IpcEnvironment::getMyOwnProcessId, it seems to assume // that its domain is IPC_DOM_INTERNET and so this will // cause the botch of an assertion that its control connection // (which is type EspGuaControlConnection) can be cast to a // SockControlConnection. When this problem is fixed, the // IPC_DOM_GUA_PHANDLE param above can be removed. Also, // when this code is ported to run it a domain other than // "guardian", it will be necessary to fix this and to // fix IpcEnvironment::getMyOwnProcessId to work properly on // windows. receivingSendTcb->setClient(connection); receivingSendTcb->routeMsg(*this); } else { connection->dumpAndStopOtherEnd(true, false); ex_assert(FALSE,"entry not found, set diagnostics area and reply"); } } // normal case, not parallel extract else { // The OPEN request is from a parallel extract consumer. The // incoming request contains a user ID which we will compare // against the current user ID for this ESP. // NOTE: The user ID for the extract security check is // currently sent and compared as a C string. On Linux it is // possible to send and compare integers which would lead to // simpler code. The code to send/compare strings is still // used because it works on all platforms. char errorStr[150]; // check if next msg is of securityInfo type. ex_assert(moreObjects(), "expected object not received"); ex_assert(getNextObjType() == ESP_SECURITY_INFO, "received message for unknown message type"); // unpack security info ExMsgSecurityInfo secInfo(environment_->getHeap()); *this >> secInfo; // Get the auth ID of this ESP in text form and compare it // to the auth ID that arrived in the message. Skip this // step in the debug build if an environment variable is // set. NABoolean doAuthIdCheck = TRUE; Int32 status = 0; #ifdef _DEBUG const char *envvar = getenv("NO_EXTRACT_AUTHID_CHECK"); if (envvar && envvar[0]) doAuthIdCheck = FALSE; #endif if (doAuthIdCheck) { // Get user ID from ExMsgSecurityInfo -> (secUserID) // the user ID is the integer value made into a string // Convert it back into its integer value short userIDLen = (short) str_len(secInfo.getAuthID()); Int32 secUserID = str_atoi(secInfo.getAuthID(), userIDLen); // Get the current user ID Int32 curUserID = ComUser::getSessionUser(); // Report an error if the user ID is not valid if (curUserID == NA_UserIdDefault || secUserID == NA_UserIdDefault) { str_cpy_c(errorStr, "Producer ESP could not authenticate the consumer, " "no valid current user."); status = -1; } // Make sure user id passed in ExMsgSecurityInfo matches // the user id associated with the current session #if defined(_DEBUG) NABoolean doDebug = (getenv("DBUSER_DEBUG") ? TRUE : FALSE); if (doDebug) printf("[DBUSER:%d] ESP extract user ID: " "local [%d], msg [%d]\n", (int) getpid(), curUserID, secUserID); #endif // Compare user ID, Report an error, if comparison fails if (curUserID != secUserID) { str_cpy_c(errorStr, "Producer ESP could not authenticate the consumer, " "user named passed in ExMsgSecurityInfo is not the " "current user"); status = -1; } } // if (doAuthIdCheck) // get the split bottom TCB that matches the securityKey ex_split_bottom_tcb *receivingTcb = NULL; if (status == 0) { receivingTcb = espFragInstanceDir_->getExtractTop(secInfo.getSecurityKey()); if (receivingTcb == NULL) { str_cpy_c(errorStr, "Producer ESP could not locate extract node"); status = -1; } } // get the sendBottom TCB if not already connected to a client ex_send_bottom_tcb *receivingSendTcb = NULL; if (status == 0) { receivingSendTcb = receivingTcb->getConsumerSendBottom(); if (receivingSendTcb == NULL) { str_cpy_c(errorStr, "Producer ESP already connected to a client"); status = -1; } } // send the error message to the consumer if (status != 0) { clearAllObjects(); setType(IPC_MSG_SQLESP_DATA_REPLY); NAMemory *heap = environment_->getHeap(); IpcMessageObj* baseObj = new(heap)IpcMessageObj(IPC_SQL_DIAG_AREA, CurrEspReplyMessageVersion); *this << *baseObj; // prepare proper error message char phandle[100]; MyGuaProcessHandle myHandle; myHandle.toAscii(phandle, 100); ComDiagsArea *diags = ComDiagsArea::allocate(heap); *diags << DgSqlCode(-EXE_PARALLEL_EXTRACT_OPEN_ERROR) << DgString0(phandle) << DgString1(errorStr); *this << *diags; diags->decrRefCount(); send(TRUE /* TRUE indicates waited */); } // if everything okay, then make the connection if (status == 0) { receivingSendTcb->setClient(connection); receivingSendTcb->routeMsg(*this); } } // parallel extract case } // open or cancel header
int AgiEngine::agiInit() { int ec, i; debug(2, "initializing"); debug(2, "game version = 0x%x", getVersion()); // initialize with adj.ego.move.to.x.y(0, 0) so to speak _game.adjMouseX = _game.adjMouseY = 0; // reset all flags to false and all variables to 0 memset(_game.flags, 0, sizeof(_game.flags)); memset(_game.vars, 0, sizeof(_game.vars)); // clear all resources and events for (i = 0; i < MAX_DIRECTORY_ENTRIES; i++) { memset(&_game.views[i], 0, sizeof(struct AgiView)); memset(&_game.pictures[i], 0, sizeof(struct AgiPicture)); memset(&_game.logics[i], 0, sizeof(struct AgiLogic)); memset(&_game.sounds[i], 0, sizeof(class AgiSound *)); // _game.sounds contains pointers now memset(&_game.dirView[i], 0, sizeof(struct AgiDir)); memset(&_game.dirPic[i], 0, sizeof(struct AgiDir)); memset(&_game.dirLogic[i], 0, sizeof(struct AgiDir)); memset(&_game.dirSound[i], 0, sizeof(struct AgiDir)); } // clear view table for (i = 0; i < SCREENOBJECTS_MAX; i++) memset(&_game.screenObjTable[i], 0, sizeof(struct ScreenObjEntry)); memset(&_game.addToPicView, 0, sizeof(struct ScreenObjEntry)); _words->clearEgoWords(); if (!_menu) _menu = new GfxMenu(this, _gfx, _picture, _text); _gfx->initPriorityTable(); // Clear the string buffer on startup, but not when the game restarts, as // some scripts expect that the game strings remain unaffected after a // restart. An example is script 98 in SQ2, which is not invoked on restart // to ask Ego's name again. The name is supposed to be maintained in string 1. // Fixes bug #3292784. if (!_restartGame) { for (i = 0; i < MAX_STRINGS; i++) _game.strings[i][0] = 0; } // setup emulation switch (getVersion() >> 12) { case 2: debug("Emulating Sierra AGI v%x.%03x", (int)(getVersion() >> 12) & 0xF, (int)(getVersion()) & 0xFFF); break; case 3: debug("Emulating Sierra AGI v%x.002.%03x", (int)(getVersion() >> 12) & 0xF, (int)(getVersion()) & 0xFFF); break; } if (getPlatform() == Common::kPlatformAmiga) _game.gameFlags |= ID_AMIGA; if (getFeatures() & GF_AGDS) _game.gameFlags |= ID_AGDS; if (_game.gameFlags & ID_AMIGA) debug(1, "Amiga padded game detected."); if (_game.gameFlags & ID_AGDS) debug(1, "AGDS mode enabled."); ec = _loader->init(); // load vol files, etc if (ec == errOK) ec = _loader->loadObjects(OBJECTS); // note: demogs has no words.tok if (ec == errOK) ec = _loader->loadWords(WORDS); // Load logic 0 into memory if (ec == errOK) ec = _loader->loadResource(RESOURCETYPE_LOGIC, 0); #ifdef __DS__ // Normally, the engine loads the predictive text dictionary when the predictive dialog // is shown. On the DS version, the word completion feature needs the dictionary too. // FIXME - loadDict() no long exists in AGI as this has been moved to within the // GUI Predictive Dialog, but DS Word Completion is probably broken due to this... #endif _keyHoldMode = false; _keyHoldModeLastKey = Common::KEYCODE_INVALID; _game.mouseFence.setWidth(0); // Reset // Reset in-game timer inGameTimerReset(); // Sync volume settings from ScummVM system settings setVolumeViaSystemSetting(); return ec; }
/*---------------------------------------------------------------------------*/ int main(int argc, char**argv) { int i; int fd = 0; uint16_t trial = 0; char* portPath = NULL; char* rx_addressString = NULL; char* tx_addressString = NULL; printf("> Simple message listener for tea-bootloader compatible nodes\n"); /*-----------------------------------------------------------------------*/ if(argc == 4) { portPath = argv[1]; rx_addressString = argv[2]; sscanf(rx_addressString,"%X:%X:%X:%X:%X",rx_addressBuffer,rx_addressBuffer+1,rx_addressBuffer+2,rx_addressBuffer+3,rx_addressBuffer+4); tx_addressString = argv[3]; sscanf(tx_addressString,"%X:%X:%X:%X:%X",tx_addressBuffer,tx_addressBuffer+1,tx_addressBuffer+2,tx_addressBuffer+3,tx_addressBuffer+4); } else { printf("> Argument parsing error!\n"); printf("> Usage: [port path] [dongle RX address] [node RX address]\n"); printf("> Example: ./main /dev/tty.usbserial-A900cbrd 0xE7:0xE7:0xE7:0xE7:0x00 0xD7:0xD7:0xD7:0xD7:0xD7\n"); return 0; } /*-----------------------------------------------------------------------*/ fd = serialport_init(portPath,115200,'n'); if(fd < 0) { printf("[err]: Connection error.\n"); return 0; } else { printf("> Conection OK.\n"); serialport_flush(fd); printf("> Serial port flush OK.\n"); if(loopbackTest(fd) != 0) { printf("> Loopback test failed!\r\n"); return 0; } else { uint8_t version = getVersion(fd); printf("> Dongle version: %d.%d\r\n",(version>>4),(version&0x0F)); } } printf("> Setting the TX address ...\n"); setTXAddress(fd,tx_addressBuffer); printf("> Setting the RX address ...\n"); setRXAddress(fd,rx_addressBuffer); while(1) { uint8_t thisBuffer[1024]; char sendBuffer[256]; uint8_t len; int temp; float realval; if(getRxFifoCount(fd)) { len = getRxFifoCount(fd); printf("> ---------------------------------------------------------------------------\n"); printf("> New message!\n"); printf("> Length: %d\n",len); pullDataFromFifo(fd,len,thisBuffer); hexDump("> Dump",thisBuffer,len); temp = (thisBuffer[0]<<8)+thisBuffer[1]; realval = ((float)temp * 1100.0) / 1024.0; realval -= 500; realval /= 10.0; printf("> Raw: %d\n",temp); printf("> Readout: %f\n",realval); sprintf(sendBuffer,"./phant_client.rb %f",realval); system(sendBuffer); printf("> Phant.io send process done.\n"); } } }
void HTTPServerResponseImpl::sendContinue() { HTTPHeaderOutputStream hs(_session); hs << getVersion() << " 100 Continue\r\n\r\n"; }
TEST_F(PacksTests, test_version) { auto fpack = Pack("foobar", getPackWithDiscovery()); EXPECT_EQ(fpack.getVersion(), "1.5.0"); }
bool ChunkManager::compatibleWith(const ChunkManager& other, const string& shardName) const { // Return true if the shard version is the same in the two chunk managers // TODO: This doesn't need to be so strong, just major vs return other.getVersion(shardName).equals(getVersion(shardName)); }
Dictionary::Dictionary() { loadSemantixLib(SEMANTIX_LIB_PATH); if (!initialized) return; QString dictPath = Storage::getInstance()->getDataPartition()->getMountPoint() + QDir::separator() + "dictionaries" + QDir::separator(); QDir dirPrivateDictionaries(Storage::getInstance()->getPrivatePartition()->getMountPoint() + QDir::separator()); if(!dirPrivateDictionaries.exists( "dictionaries/")) dirPrivateDictionaries.mkdir( "dictionaries"); QString dictPrivatePath = dirPrivateDictionaries.absolutePath() + QDir::separator() + "dictionaries" + QDir::separator(); QString repositories = dictPath + QString(":") + dictPrivatePath; qDebug() << Q_FUNC_INFO << "repositories " << repositories; initialize(dictPath.toUtf8().constData(),repositories.toUtf8().constData()); qDebug() << Q_FUNC_INFO << "Dictionaires lib initialized. Version: " << QString::fromUtf8(getVersion().c_str()); }