bool Uri::Private::parsePchar() { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (!currValue) { return false; } if (currValue < 128 && isUnreserved[currValue]) { m_parserAux += curr; ++m_parserPos; return true; } const size_t parserOldPos = m_parserPos; if (parsePctEncoded()) { return true; } m_parserPos = parserOldPos; if (currValue < 128 && isSubdelim[currValue]) { m_parserAux += curr; ++m_parserPos; return true; } if (curr == ':' || curr == '@') { m_parserAux += curr; ++m_parserPos; return true; } return false; }
bool Uri::Private::parseSegmentNzNc() { bool res = false; while (true) { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (currValue < 128 && isUnreserved[currValue]) { m_parserAux += curr; ++m_parserPos; res = true; continue; } const size_t parserOldPos = m_parserPos; if (parsePctEncoded()) { res = true; continue; } m_parserPos = parserOldPos; if (currValue < 128 && isSubdelim[currValue]) { m_parserAux += curr; ++m_parserPos; res = true; continue; } if (curr == '@') { m_parserAux += '@'; ++m_parserPos; res = true; continue; } return res; } }
TEST(VersionTest, SelfAssignmentAfterOperations) { Int a = 3; Int b = any_int("B"); Char c = 'c'; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); // some operations a = a + b + c; b = a + b + c; b = 5; c = c + 'x'; c = 'y'; c = 'z' + c; EXPECT_EQ(1, a.get_version()); EXPECT_EQ(2, b.get_version()); EXPECT_EQ(3, c.get_version()); a = a; b = b; c = c; EXPECT_EQ(1, a.get_version()); EXPECT_EQ(2, b.get_version()); EXPECT_EQ(3, c.get_version()); }
bool Uri::Private::parseDecOctet() { String decOctet; for (size_t i = 0; i < 3; ++i) { const Char currChar = m_uri[m_parserPos]; const iuint32 currValue = currChar.value(); if (currValue && currValue < 128 && isDigit[currValue]) { decOctet += currChar; ++m_parserPos; } else { break; } } if (decOctet.empty()) { return false; } else { const size_t retValue = decOctet.toInt(); if (retValue < 256) { m_parserAux += decOctet; return true; } else { return false; } } }
bool Uri::Private::parseIPvFuture() { if (!expectChar('v') && !expectChar('V')) { return false; } m_parserAux.clear(); Char curr = m_uri[m_parserPos]; size_t currValue = curr.value(); if (currValue > 127 || !isHexdig[currValue]) { return false; } ++m_parserPos; if (!expectChar('.')) { return false; } curr = m_uri[m_parserPos]; currValue = curr.value(); if (currValue < 128 && isUnreserved[currValue]) { ++m_parserPos; return true; } if (currValue < 128 && isSubdelim[currValue]) { ++m_parserPos; return true; } if (curr == ':') { ++m_parserPos; return true; } return false; }
bool JsonParser::JsonStringParser::advance(Char ch) { switch (_state) { case state_0: if (ch == '\\') _state = state_esc; else if (ch == '"') return true; else _str += ch; break; case state_esc: _state = state_0; if (ch == '"' || ch == '\\' || ch == '/') _str += ch; else if (ch == 'b') _str += '\b'; else if (ch == 'f') _str += '\f'; else if (ch == 'n') _str += '\n'; else if (ch == 'r') _str += '\r'; else if (ch == 't') _str += '\t'; else if (ch == 'u') { _value = 0; _count = 4; _state = state_hex; } else _jsonParser->doThrow(std::string("invalid character '") + ch.narrow() + "' in string"); break; case state_hex: if (ch >= '0' && ch <= '9') _value = (_value << 4) | (ch.value() - '0'); else if (ch >= 'a' && ch <= 'f') _value = (_value << 4) | (ch.value() - 'a' + 10); else if (ch >= 'A' && ch <= 'F') _value = (_value << 4) | (ch.value() - 'A' + 10); else _jsonParser->doThrow(std::string("invalid character '") + ch.narrow() + "' in hex sequence"); if (--_count == 0) { _str += Char(static_cast<wchar_t>(_value)); _state = state_0; } break; } return false; }
TEST(VersionTest, InitWithVarRequiringCast) { Bool a = any_bool("A"); Char b = any_char("B"); Int c = b; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); }
TEST(VersionTest, InitWithAny) { Bool a = any_bool("A"); Char b = any_char("B"); Int c = any_int("C"); EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); }
void Line::SetText( string _character ) { Char * character = new Char(); vector<Char *>::iterator it = characters.begin() + active; character->SetText( _character ); characters.insert( it, character ); IncrementParams( 1 ); }
Char* Line::Delete(int x) { if ((size_t)x >= m_chars.size()) { throw ISError("Cannot insert; x out of bounds"); } Char* c = m_chars.at(x); c->Unlink(); m_charpool.Unlink(*c); m_chars.erase(m_chars.begin() + x); return c; }
bool Uri::Private::expectChar(Char c) { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (!currValue || currValue > 127 || curr != c) { return false; } ++m_parserPos; return true; }
TEST(VersionTest, InitWithConcrete) { Bool a = true; Bool b = true; Char c = 'a'; Int d = 3; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); EXPECT_EQ(0, d.get_version()); }
bool Uri::Private::parseReserved() { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (currValue < 128 && (isGendelim[currValue] || isSubdelim[currValue])) { m_parserAux += curr; ++m_parserPos; return true; } return false; }
bool Uri::Private::parseH16() { for (size_t i = 0; i < 4; ++i) { const Char curr = m_uri[m_parserPos]; const size_t currValue = curr.value(); if (!currValue || currValue > 127 || !isHexdig[currValue]) { return i; } m_parserAux += curr; ++m_parserPos; } return true; }
void Uri::Private::parsePort() { m_parserAux.clear(); Char curr = m_uri[m_parserPos]; iuint32 currValue = curr.value(); while (currValue && currValue < 128 && isDigit[currValue]) { m_parserAux += curr; m_parserPos++; curr = m_uri[m_parserPos]; currValue = curr.value(); } m_port = m_parserAux.empty() ? -1 : m_parserAux.toInt(); }
String Uri::Private::getHex(Char ch) const { String res; union { iuint32 value; ichar v[4]; } fragmentedValue; fragmentedValue.value = ch.value(); const iint32 octetsRequired = ch.octetsRequired(); for (iint32 i = 0; i < octetsRequired; ++i) { res += '%'; res += uri_hex[(fragmentedValue.v[octetsRequired - i - 1] >> 4) & 0xf]; res += uri_hex[fragmentedValue.v[octetsRequired - i - 1] & 0xf]; } return res; }
void EpsilonNFA::NFAGenerator::visit(Char& node) { _pool.push_back(std::make_unique<Node>()); auto newNode = _pool.back().get(); start->edges.push_back(Edge{ node.ch(), newNode }); end = newNode; end->stateInfo = _info; }
TEST(VersionTest, SelfAssignmentAfterInit) { Int a = 3; Int b = any_int("B"); Char c = 'c'; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); a = a; b = b; c = c; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); }
void EntityResolver::getEntity(std::basic_ostream<Char>& os, Char ch) const { unsigned u = 0; unsigned o = sizeof(rent)/sizeof(Ent) - 1; while (o - u > 1) { unsigned m = (o + u) / 2; if (rent[m].charValue == ch.value()) { printEntity(os, rent[m].entity); return; } if (ch.value() < rent[m].charValue) o = m; else u = m; } if (rent[u].charValue == ch.value()) printEntity(os, rent[u].entity); else if (rent[o].charValue == ch.value()) printEntity(os, rent[o].entity); else if (ch.value() >= ' ' && ch.value() <= 0x7F) os << ch; else os << Char('&') << Char('#') << static_cast<uint32_t>(ch.value()) << Char(';'); }
bool Uri::Private::parseScheme() { m_parserAux.clear(); Char curr = m_uri[m_parserPos]; iuint32 currValue = curr.value(); if (!currValue || currValue > 127 || !isAlpha[currValue]) { return false; } while (currValue && currValue < 128 && (isAlpha[currValue] || isDigit[currValue] || curr == '+' || curr == '-' || curr == '.')) { m_parserAux += curr; ++m_parserPos; curr = m_uri[m_parserPos]; currValue = curr.value(); } m_scheme = m_parserAux; return true; }
void Uri::Private::parseUserinfo() { m_parserAux.clear(); bool usernameFound = false; while (true) { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (!currValue) { return; } if (currValue < 128 && isUnreserved[currValue]) { if (!usernameFound && curr == ':') { usernameFound = true; } else if (!usernameFound) { m_username += curr; } else { m_password += curr; } m_parserAux += curr; ++m_parserPos; continue; } const size_t parserOldPos = m_parserPos; if (parsePctEncoded()) { continue; } m_parserPos = parserOldPos; if (currValue < 128 && (isSubdelim[currValue] || curr == ':')) { if (!usernameFound && curr == ':') { usernameFound = true; } else if (!usernameFound) { m_username += curr; } else { m_password += curr; } m_parserAux += curr; ++m_parserPos; continue; } m_userInfo = m_parserAux; return; } }
void DocState::Deserialize(std::ifstream & ifs){ // Dummy objects Char ch(logger); Graph g(logger); Table t(logger); Eof e(logger); uint32 magic; while(!ifs.eof()){ DESER_OBJ(magic); if(magic == offset_magic){ // offset is placed at the end of the serialized record DESER_OBJ(glyphAttrib); DESER_OBJ(lineAttrib); return; } else if (magic == e.GetMagic()){ Eof * pe = new Eof(logger); buffer.push_back(pe); pe->Deserialize(ifs); } else if (magic == ch.GetMagic()){ Char* pch = new Char(logger); buffer.push_back(pch); pch->Deserialize(ifs); } else if (magic == g.GetMagic()){ Graph* pg = new Graph(logger); buffer.push_back(pg); pg->Deserialize(ifs); } else if (magic == t.GetMagic()){ Table* pt = new Table(logger); buffer.push_back(pt); pt->Deserialize(ifs); } else{ LOG_ERROR("Unsupported class magic."); } } }
bool Uri::Private::parsePctEncoded() { if (expectChar('%')) { Char curr = m_uri[m_parserPos]; size_t currValue = curr.value(); if (!currValue || currValue > 127 || !isHexdig[currValue]) { return false; } m_parserAux += curr; ++m_parserPos; curr = m_uri[m_parserPos]; currValue = curr.value(); if (!currValue || currValue > 127 || !isHexdig[currValue]) { return false; } m_parserAux += curr; ++m_parserPos; } else { const Char curr = m_uri[m_parserPos]; const iuint32 currValue = curr.value(); if (curr.octetsRequired() > 1) { m_parserAux += curr; ++m_parserPos; } else if (currValue && currValue < 128 && (!isUnreserved[currValue] && !isGendelim[currValue] && !isSubdelim[currValue] && curr != ':' && curr != '@')) { m_parserTrick = true; m_parserAux += getHex(curr); ++m_parserPos; } else { return false; } } return true; }
void ByLevelUseEffect::apply(Char& target) const { if (effects.empty()) return; uint16_t level = target.get_level(); auto iter = effects.begin(); for (; iter != effects.end() && level > iter->first; ++iter) {} if (iter != effects.begin()) iter--; iter->second.apply(target); }
void Uri::Private::parseRegName() { m_parserAux.clear(); while (true) { const Char curr = m_uri[m_parserPos]; const size_t currValue = curr.value(); if (currValue < 128 && isUnreserved[currValue]) { m_parserAux += curr; ++m_parserPos; continue; } const size_t parserOldPos = m_parserPos; if (parsePctEncoded()) { continue; } m_parserPos = parserOldPos; if (currValue < 128 && isSubdelim[currValue]) { m_parserAux += curr; ++m_parserPos; continue; } return; } }
TEST(VersionTest, GetVersion) { Int a = 3; Int b = any_int("B"); Char c = 'c'; EXPECT_EQ(0, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); a = b + 2 + c; EXPECT_EQ(1, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); a = 4 + b + c; EXPECT_EQ(2, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(0, c.get_version()); c = a + b; EXPECT_EQ(2, a.get_version()); EXPECT_EQ(0, b.get_version()); EXPECT_EQ(1, c.get_version()); b = 5; EXPECT_EQ(2, a.get_version()); EXPECT_EQ(1, b.get_version()); EXPECT_EQ(1, c.get_version()); b = a; EXPECT_EQ(2, a.get_version()); EXPECT_EQ(2, b.get_version()); EXPECT_EQ(1, c.get_version()); b = c; EXPECT_EQ(2, a.get_version()); EXPECT_EQ(3, b.get_version()); EXPECT_EQ(1, c.get_version()); }
WindowResponse LineBuf::Insert(int y, int x, int ch) { WindowResponse response; if ((size_t)y > m_lines.size()) { throw ISError(string("Cannot insert ") + (char)ch + "; y out of bounds"); } else if (m_lines.size() == (size_t)y) { g_log.info() << "LineBuf creating line for y=" << y; m_lines.push_back(new Line(y)); } else if (m_lines.at(y).Size() == m_maxcols-2) { // Line too long; input ignored return response; } g_log.info() << "LineBuf inserting (" << y << "," << x << "):" << (char)ch; Char* prev = FindBefore(y, x); Char* next = FindAtOrAfter(y, x); Char* c = m_lines.at(y).Insert(x, ch); int x0 = x+1; int y0 = y; // Re-draw the window starting at the newly-entered character do { string s = m_lines.at(y).GetString(x); for (size_t i = 0; i < s.size(); ++i) { response.actions.push_back(WindowAction(WindowAction::INSERT, y, x + i, s[i])); } x = 0; ++y; } while ((size_t)y < m_lines.size()); response.hotlist.Insert(c->inode); if (prev) { g_log.info() << " found before: " << *prev; prev->SetNext(c); c->SetPrevious(prev); } if (next) { g_log.info() << " found next: " << *next; next->SetPrevious(c); c->SetNext(next); } statik::IList* istart = &c->inode; while (istart->left) { istart = istart->left; } response.actions.push_back(WindowAction(WindowAction::MOVE, y0, x0)); g_log.info() << "window0 olist: " << istart->Print(); g_log.info() << "window0 hotlist: " << response.hotlist.Print(); return response; }
bool Beam::charPoll( double dt ) { // Shifter tile bends beam Cell *c = g_fld->get(loc); if( c->gt == GT_SHIFTER && c->st == ST_NONE && c->bt == BT_AIR ) { Vec2 dv = dirToVec2(c->dir) * PPC* SHIFTER_ACCEL; v += dv * dt; if( v.len() > BEAM_NORMAL_VEL ) { v = v.normalize(BEAM_NORMAL_VEL); } setRot( atan2(v.y,v.x)); // print("v:%f %f dv:%f %f d:%d",v.x,v.y, dv.x, dv.y, c->dir ); } loc += v * dt; // Stronger is bigger float s = PPC; if( ene >= 64 ) s *= 3; else if( ene >= 16 ) s *= 2; else if( ene >= 4 ) s *= 1.5; setScl(s); // Shoot on blocks Vec2 rt,lt,rb,lb; Cell *rtc = g_fld->get( rt = loc + Vec2(hitsz,hitsz)); Cell *ltc = g_fld->get( lt = loc + Vec2(-hitsz,hitsz)); Cell *rbc = g_fld->get( rb = loc + Vec2(hitsz,-hitsz)); Cell *lbc = g_fld->get( lb = loc + Vec2(-hitsz,-hitsz)); Cell *tgtc = NULL; Vec2 tgtat; Vec2 candat[4]; Cell *cands[4]; int candi=0; // if(rtc&&rtc->isBeamHit() && rtc->isImmutableAgainstBeam()==false ) { cands[candi] = rtc; candat[candi] = rt; candi++; } if(rbc&&rbc->isBeamHit() && rbc->isImmutableAgainstBeam()==false ) { cands[candi] = rbc; candat[candi] = rb; candi++; } if(ltc&<c->isBeamHit() && ltc->isImmutableAgainstBeam()==false ) { cands[candi] = ltc; candat[candi] = lt; candi++; } if(lbc&&lbc->isBeamHit() && lbc->isImmutableAgainstBeam()==false ) { cands[candi] = lbc; candat[candi] = lb; candi++; } if( candi > 0 ) { int ind = irange(0,candi); tgtc = cands[ind]; tgtat = candat[ind]; } // Out of the world if(!rtc)return false; if( rtc && rtc->gt == GT_JUNGLE && range(0,100) < 1 ) { createLeafEffect(loc); } updateIndex(); if( isRemote() ) return true; if(tgtc) { int consumed; BLOCKTYPE orig_bt = tgtc->bt; if( g_fld->damage(tgtat,ene,&consumed,this) ) { createSparkEffect(); if( orig_bt == BT_CELL || orig_bt == BT_FLYGEN ) { soundPlayAt(g_wormdamage_sound,loc,1); } else if( orig_bt != BT_SNOW && orig_bt != BT_IVY && orig_bt != BT_TREE && orig_bt != BT_BOMBFLOWER ) { soundPlayAt(g_beamhithard_sound,loc,1); } if( orig_bt == BT_BARRIER && tgtc->hyper_count > 0 ) { Vec2 tgt; if( g_fld->findEnemyAttackTarget(loc,&tgt, MACHINE_SHOOT_DISTANCE ) ) { int n = irange(1,4); for(int i=0;i<n;i++) Bullet::shootAt( BLT_SPARIO, loc, tgt ); } } ene -= consumed; if( ene <= 0 ) return false; else return true; } } else { // Immutable cells Cell *cells[4]; g_fld->getCorner4( loc, 1, &cells[0], &cells[1], &cells[2], &cells[3] ); for(int i=0;i<4;i++) { if(cells[i] && cells[i]->isImmutableAgainstBeam()) { soundPlayAt(g_beamhithard_sound,loc,1); createSparkEffect(); return false; } } } if( type == BEAMTYPE_BLASTER ) { float s = PPC; g_fld->meltSnow(loc + Vec2(-s,-s) ); g_fld->meltSnow(loc + Vec2(-s,s) ); g_fld->meltSnow(loc + Vec2(s,-s) ); g_fld->meltSnow(loc + Vec2(s,s) ); } else { if( range(0,100) < (float)(ene)/2.0 ) { g_fld->meltSnow(loc); } } // Shoot on enemies Char *cur = (Char*) g_char_layer->prop_top; while(cur) { if( cur->isEnemyCategory() ) { Enemy *e = (Enemy*) cur; if( e->hitWithFlyHeight(this,PPC/2) && e->beam_hits ) { int dmg = ene; if( dmg > e->hp ) dmg = e->hp; e->notifyHitBeam(this, dmg); createSparkEffect(); // ene -= dmg; if(ene<=0) to_clean = true; g_fld->meltSnow(loc); } } else if( cur->category == CAT_PC ) { // recharging other player characters PC *pc = (PC*) cur; if( pc->hit(this,PPC/2)) { // print("pcid:%d shooter:%d ene:%d/%d", pc->id, shooter_id, pc->ene, pc->maxene ); if( pc->id != shooter_id && shooter_id == g_pc->id ) { // print("PC:E:%d id:%d max:%d", pc->ene, pc->id, pc->maxene ); int charged = pc->charge(ene); if(charged>0) { pc->energy_chain_heat_count ++; // print("sending E-chain e:%d(%d>%d) to: %d-%d heat:%d", // ene, charged, pc->ene, pc->client_id, pc->internal_id ,pc->energy_chain_heat_count ); realtimeEnergyChainSend(pc,charged); return false; } } } } cur = (Char*) cur->next; } return true; }
Pt::String RegexSMatch::format(const Pt::String& str) const { enum state_type { state_0, state_esc, state_var0, state_var1, state_1 } state; state = state_0; Pt::String ret; for (Pt::String::const_iterator it = str.begin(); it != str.end(); ++it) { Char ch = *it; switch (state) { case state_0: if (ch == '$') state = state_var0; else if (ch == '\\') state = state_esc; break; case state_esc: ret += ch; state = state_1; break; case state_var0: if( isdigit(ch) ) { ret = Pt::String(str.begin(), it - 1); unsigned n = ch.value() - '0'; if(n < _size) { const Pt::Char* s = _match->startp[n]; const Pt::Char* e = _match->endp[n]; assert(s && e); ret.append(s, e-s); } state = state_1; } else state = state_0; break; case state_1: if (ch == '$') state = state_var1; else if (ch == '\\') state = state_esc; else ret += ch; break; case state_var1: if( isdigit(ch) ) { unsigned n = ch.value() - '0'; if(n < _size) { const Pt::Char* s = _match->startp[n]; const Pt::Char* e = _match->endp[n]; assert(s && e); ret.append(s, e-s); } state = state_1; } else if (ch == '$') ret += '$'; else { ret += '$'; ret += ch; } break; } } switch (state) { case state_0: case state_var0: return str; case state_esc: return ret + '\\'; case state_var1: return ret + '$'; case state_1: return ret; } return ret; }
void Font::setChar(const Char& character) { allCharacters[character.getId()] = character; }