/* The function converts the given value depending on the requested unit and its source unit. */ double transline::convertProperty (const char * prop, double value, int type, int srcunit) { int dstunit = translateUnit (getUnit (prop)); if (type == UNIT_LENGTH) value *= conv_length[srcunit][dstunit]; else if (type == UNIT_RES) value *= conv_res[srcunit][dstunit]; else if (type == UNIT_ANG) value *= conv_ang[srcunit][dstunit]; else if (type == UNIT_FREQ) value *= conv_freq[srcunit][dstunit]; return value; }
void DebugDraw::DrawLine(const sf::Vector2f& p1, const sf::Vector2f& p2, float thick, const sf::Color& c) { float distance = getDistance(p1, p2); sf::Vector2f dir = getUnit(p2 - p1); sf::RectangleShape line(sf::Vector2f(distance, thick)); line.setOrigin(0, thick/2.f); line.setPosition(p1); line.setRotation(atan2(dir.y, dir.x) * (180/3.14159f)); line.setFillColor(c); window->draw(line); }
/** * Fits drawing on page. Affects DXF variable $PINSBASE. */ bool RS_Graphic::fitToPage() { bool ret(true); double border = RS_Units::convert(25.0, RS2::Millimeter, getUnit()); RS_Vector ps = getPaperSize(); if(ps.x>border && ps.y>border) ps -= RS_Vector(border, border); RS_Vector s = getSize(); /** avoid zero size, bug#3573158 */ if(fabs(s.x)<RS_TOLERANCE) s.x=10.; if(fabs(s.y)<RS_TOLERANCE) s.y=10.; double fx = RS_MAXDOUBLE; double fy = RS_MAXDOUBLE; double fxy; //ps = RS_Units::convert(ps, getUnit(), RS2::Millimeter); // tin-pot 2011-12-30: TODO: can s.x < 0.0 (==> fx < 0.0) happen? if (fabs(s.x) > 1.0e-10) { fx = ps.x / s.x; ret=false; } if (fabs(s.y) > 1.0e-10) { fy = ps.y / s.y; ret=false; } fxy = std::min(fx, fy); if (fxy >= RS_MAXDOUBLE || fxy <= 1.0e-10) { setPaperSize( RS_Units::convert(RS_Vector(210.,297.) , RS2::Millimeter , getUnit() ) ); ret=fitToPage(); } setPaperScale(fxy); centerToPage(); return ret; }
Action GameState::makeAttack(int attId, int defId, int aMoveTgt) const { const auto &attacker = getUnit(attId); const auto &defender = getUnit(defId); if (!attacker.isAlive() || !defender.isAlive()) return {}; Action action; action.attacker = attId; action.defender = defId; action.aTgt = defender.aHex; bool attMoved = (aMoveTgt != attacker.aHex); if (!attMoved && isRangedAttackAllowed(attId, defId)) { action.type = ActionType::RANGED; return action; } if (!attMoved && isSpellAllowed(attId, defId)) { action.type = ActionType::EFFECT; action.damage = attacker.num * attacker.type->spell->damage; action.effect = Effect(*this, action, attacker.type->spell->effect); action.manaCost = attacker.type->spell->cost; return action; } bool isAdjacent = contains(grid_.aryNeighbors(aMoveTgt), defender.aHex); if (!isAdjacent || !isMeleeAttackAllowed(attId, defId)) { return {}; } auto path = getPath(attacker, aMoveTgt); if (path.empty() || path.size() > attacker.getMaxPathSize()) { return {}; } action.type = ActionType::ATTACK; action.path = path; return action; }
IProperty * Property :: getFlagConstant(int32_t position) { IProperty *retval = 0; try { if (getType() != IProperty::PROPERTY_FLAGS) throw std::runtime_error("flag is not of type PROPERTY_FLAGS"); // now, iterate through all options, counting all CONSTS that belong // to the same unit as this option const char* unit = getUnit(); if (!unit || !*unit) throw std::runtime_error("flag doesn't have a unit setting, so can't tell what constants"); // Create a fake class AVClass fakeClass; fakeClass.class_name="XuggleFakeClass"; fakeClass.item_name = fakeContextToName; fakeClass.option = mOptionStart; AVClass *fakeClassPtr = &fakeClass; const AVOption* last = 0; int32_t constNo = -1; do { last = av_opt_next(&fakeClassPtr, last); if (last && last->unit && last->type == AV_OPT_TYPE_CONST && strcmp(unit, last->unit)==0) { // count in the same was as getNumFlagSettings, // and then return if the position is equal ++constNo; if (constNo == position) { retval = Property::make(av_opt_next(&fakeClassPtr, 0), last); } } } while(last); } catch (std::exception & e) { VS_LOG_DEBUG("Error: %s", e.what()); VS_REF_RELEASE(retval); } return retval; }
/** * Get the number of time units a certain action takes. * @param actionType * @param item * @return TUs */ int BattleUnit::getActionTUs(BattleActionType actionType, BattleItem *item) const { if (item == 0) { return 0; } switch (actionType) { case BA_PRIME: return (int)floor(getUnit()->getTimeUnits() * 0.50); case BA_THROW: return (int)floor(getUnit()->getTimeUnits() * 0.25); case BA_AUTOSHOT: return (int)(getUnit()->getTimeUnits() * item->getRules()->getTUAuto() / 100); case BA_SNAPSHOT: return (int)(getUnit()->getTimeUnits() * item->getRules()->getTUSnap() / 100); case BA_AIMEDSHOT: return (int)(getUnit()->getTimeUnits() * item->getRules()->getTUAimed() / 100); default: return 0; } }
void getData(ifstream& input,vector<Bus>& vecBus,vector<ACline>& vecACLine, vector<TopoNode>& vecTopoNode,vector<Unit>& vecUnit, vector<Transformer>& vecTransformer,vector<Load>& vecLoad) {//调用其他get函数,一次性读取 //有必要了解input的getline是怎么工作的。 //使用过一次,然后再次使用是有影响的 //所有在使用输入流时应该注意顺序,否则会导致无法跳出 getBusData(input,vecBus); getAClineData(input,vecACLine); getUnit(input,vecUnit); getTransData(input,vecTransformer); //load函数位置 getLoadData(input,vecLoad); getTopoNode(input,vecTopoNode); }
void Fight::socketFightMove() { attalFightData dataFight; dataFight.cla = _socket->readChar(); dataFight.num = _socket->readChar(); dataFight.row = _socket->readInt(); dataFight.col = _socket->readInt(); dataFight.dataType = FIGHT_DATA_MOVE; dataFight.unit = getUnit( dataFight.num, (CLASS_FIGHTER)dataFight.cla) ; manageData( dataFight ); }
std::vector<int> GameState::getAllEnemies(int id) const { const auto &unit = getUnit(id); if (!unit.isAlive()) return {}; std::vector<int> enemies; for (const auto &u : units_) { if (u.isAlive() && unit.isEnemy(u)) { enemies.push_back(u.entityId); } } return enemies; }
int GameState::assignDamage(int id, int damage) { auto &unit = getUnit(id); assert(unit.isValid()); int numKilled = unit.takeDamage(damage); if (!unit.isAlive()) { unitAtPos_[unit.aHex] = -1; } if (numKilled > 0) { drawTimer_ = ROUNDS_TO_DRAW; } return numKilled; }
void UnitMoveAction::activate() { Action::activate(); UnitInput i = UNIT_UNKNOWN; if ( m_input == "LEFT" ) i = UNIT_MOVE_LEFT; else if ( m_input == "RIGHT" ) i = UNIT_MOVE_RIGHT; else if ( m_input == "UP" ) i = UNIT_MOVE_UP; else if ( m_input == "DOWN" ) i = UNIT_MOVE_DOWN; else throw std::runtime_error( "Unknown UnitInput value" ); getUnit()->setForcedMove( i ); m_activateElapsedTime = 0; }
bool actualizeMembers(test_suite& suite, const std::deque<test_unit_id>& members) { const std::size_t suiteSize = suite.size(); const std::size_t memSize = members.size(); if (suiteSize != memSize) { //diff size DEPENDENCY_LOG_ERROR( "Members size[" << memSize << "] differs from sute size[" << suiteSize << "]" ); return false; } else { //obtain all pointers std::vector<test_unit*> units(memSize); bool gotAllUnits = true; //std::deque<test_unit_id>::const_iterator iter = members.begin(); //std::deque<test_unit_id>::const_iterator eiter = members.end(); for(std::size_t i =0; i<memSize; i++) { DependencyId unitId = members[i]; test_unit* unit = getUnit(unitId); if (unit!=NULL) { units[i] = unit; } else { DEPENDENCY_LOG_ERROR( "Could not get member[" << unitId << "]" ); gotAllUnits = false; } } if (gotAllUnits==false) { DEPENDENCY_LOG_ERROR( "Could not get all members" ); return false; } else { //remove old tests for(std::size_t i=0; i<suiteSize; i++) { suite.remove( members[i] ); } const std::size_t newSuiteSize = suite.size(); if (newSuiteSize>0) { DEPENDENCY_LOG_ERROR( "Could not clear the suite" ); return false; } else { //add tests in correct order for(std::size_t i=0; i<memSize; i++) { test_unit* unit = units[i]; suite.add(unit, unit->p_expected_failures, unit->p_timeout); } } } return true; } }
void UnitMng::generateInputs() { BWAPI::Unit *enemyUnit=0; BWAPI::Unit *tempUnit=getUnit(); //Units position //mapWidth() is in TilePosition Units which is 32 pixels inputs[0]=((tempUnit->getPosition().x())/(BWAPI::Broodwar->mapWidth()*32.0)); inputs[1]=(tempUnit->getPosition().y())/(BWAPI::Broodwar->mapHeight()*32.0); //Group leader position inputs[2]=(UnitGroup->getPosition().x())/(BWAPI::Broodwar->mapWidth()*32.0); inputs[3]=(UnitGroup->getPosition().y())/(BWAPI::Broodwar->mapHeight()*32.0); //How many hit points? inputs[4]=getHitPoints(); // Is there an enemy within the unit's seek range? enemyUnit=enemyExists(tempUnit); inputs[5]=enemyUnit?1.0:0; // Find closest enemy enemyUnit=closestEnemy(); inputs[6]=enemyUnit?(UnitGroup->getPosition().x())/(BWAPI::Broodwar->mapWidth()*32.0):1.0; inputs[7]=enemyUnit?(UnitGroup->getPosition().y())/(BWAPI::Broodwar->mapHeight()*32.0):1.0; inputs[8]=underAttack(); //check surroundings //east inputs[9]=getBlocked(0,1); //north-east inputs[10]=getBlocked(1,1); //north inputs[11]=getBlocked(1,0); //north-west inputs[12]=getBlocked(1,-1); //west inputs[13]=getBlocked(0,-1); //south-west inputs[14]=getBlocked(-1,-1); //south inputs[15]=getBlocked(-1,0); //south-east inputs[16]=getBlocked(-1,1); //Get Group Command; inputs[17]=GroupCommand(); //get last Command or not maybe useless inputs[18]=getLastCommand(); //bias inputs[19]=1.0; //return inputs; }
Action GameState::makeMove(int id, int aTgt) const { const auto &unit = getUnit(id); if (!unit.isAlive()) return {}; auto path = getPath(unit, aTgt); if (path.size() <= 1 || path.size() > unit.getMaxPathSize()) { return {}; } Action action; action.type = ActionType::MOVE; action.attacker = id; action.path = path; return action; }
std::vector<int> GameState::getAdjEnemies(int id, int aIndex) const { const auto &unit = getUnit(id); if (!unit.isAlive()) return {}; std::vector<int> enemies; for (auto n : grid_.aryNeighbors(aIndex)) { const auto &adjUnit = getUnitAt(n); if (adjUnit.isAlive() && unit.isEnemy(adjUnit)) { enemies.push_back(adjUnit.entityId); } } return enemies; }
double UnitMenu::getConversion(Glib::ustring const &new_unit_abbr, Glib::ustring const &old_unit_abbr) const { double old_factor = getUnit()->factor; if (old_unit_abbr != "no_unit") { old_factor = unit_table.getUnit(old_unit_abbr)->factor; } Unit const * new_unit = unit_table.getUnit(new_unit_abbr); // Catch the case of zero or negative unit factors (error!) if (old_factor < 0.0000001 || new_unit->factor < 0.0000001) { // TODO: Should we assert here? return 0.00; } return old_factor / new_unit->factor; }
void UnitInterface::unitOpcodeMessage(const NetMessage *net_message, size_t size) { UnitOpcodeDecoder decoder; decoder.setMessage(net_message, size); UnitOpcode* opcode; while(decoder.decode(&opcode)) { UnitBase* unit = getUnit(opcode->getUnitID()); if(!unit) { LOGGER.debug("Update for non-existant unit: %d", opcode->getUnitID()); continue; } unit->evalCommandOpcode(opcode); } }
void batchWindow::addImage(QString url, int batch, float size) { m_urls.append(url); QTableWidgetItem *id = new QTableWidgetItem(QString::number(m_items+1)); id->setIcon(QIcon(":/images/colors/black.png")); ui->tableWidget->setItem(m_items, 0, id); ui->tableWidget->setItem(m_items, 1, new QTableWidgetItem(QString::number(batch))); ui->tableWidget->setItem(m_items, 2, new QTableWidgetItem(url)); QString unit = getUnit(&size); ui->tableWidget->setItem(m_items, 3, new QTableWidgetItem(size != 0 ? QLocale::system().toString(size, 'f', size < 10 ? 2 : 0)+" "+unit : "")); ui->tableWidget->setItem(m_items, 4, new QTableWidgetItem()); ui->tableWidget->setItem(m_items, 5, new QTableWidgetItem("0 %")); /* QProgressBar *prog = new QProgressBar(this); prog->setTextVisible(false); m_progressBars.append(prog); ui->tableWidget->setCellWidget(m_items, 5, prog); */ m_items++; }
void UnitInterface::unitKilled(const UnitBase* unit, const UnitID killer) { UnitBase* unit2 = getUnit(killer); if ( ! unit2 ) { LOGGER.warning( "Killer Unit in EndLifeCycle message doesn't exist anymore(u1: %u u2: %u)", unit->id, killer); return; } PlayerState* player1 = PlayerInterface::getPlayer(unit->player_id); PlayerState* player2 = PlayerInterface::getPlayer(unit2->player_id); int unittype1 = unit->unit_state.unit_type; const std::string& unitname1 = UnitProfileInterface::getUnitProfile(unittype1)->unitname; int unittype2 = unit2->unit_state.unit_type; const std::string& unitname2 = UnitProfileInterface::getUnitProfile(unittype2)->unitname; if(Console::server) { *Console::server << "'" << player1->getName() << "' killed a '" << unitname2 << "' from '" << player2->getName() << "' with his '" << unitname1 << "'." << std::endl; } // killing team own units doesn't give score if (GameConfig::game_teammode && (player1->getTeamID() == player2->getTeamID())) { return; } // killing own units doesn't give score if( player1 != player2 ) { PlayerInterface::setKill(player1, player2, (UnitType) unittype1); PlayerScoreUpdate score_update; score_update.set(player1->getID(), player2->getID(), (UnitType) unittype1); SERVER->broadcastMessage(&score_update, sizeof(PlayerScoreUpdate)); } }
void Fight::socketFightModify() { TRACE("socket modify"); GenericFightUnit * unit; uchar cla = _socket->readChar(); uchar num = _socket->readChar(); uchar race = _socket->readChar(); uchar level = _socket->readChar(); int number = _socket->readInt(); uchar move =_socket->readChar(); int health =_socket->readInt(); unit = getUnit ( num, (CLASS_FIGHTER)cla); unit->setCreature( race, level ); unit->setNumber( number ); unit->setMove( move ); unit->setHealth( health ); }
bool DependencySolver::normalizeDepenencies(DependencyId unitId, const DependencyIdSet& depSet) { bool ret = true; //framework::get(unit); test_unit* unit = getUnit(unitId); //DependencyId unitParentId = unit->parent_id_t; DependencyLevel unitLevel = levels.at(unitId); DependencyIdSet::iterator iter = depSet.begin(); DependencyIdSet::iterator eiter = depSet.end(); for(; iter!=eiter; iter++) { //LogInfo << *iter << ", "; //check_dep(levels, unitId, *iter); DependencyId currId = *iter; DependencyLevel currLevel = levels.at(currId); DependencyLevel levelDiff = unitLevel - currLevel; if (levelDiff>0) { //unit is deeper DependencyId unitAncestorId = getAncestorId(unitId, levelDiff); bool valid = checkAncestor(currLevel, unitAncestorId, currId); if (valid==false) { DEPENDENCY_LOG_ERROR( "Unit test [" << unit->p_name << "] depends on his sub-tree (not registered) #1" ); ret = false; } } else { //current is deeper or on the same level DependencyId currAncestorId = getAncestorId(currId, -levelDiff); bool valid = checkAncestor(unitLevel, unitId, currAncestorId); if (valid==false) { if (levelDiff==0) { DEPENDENCY_LOG_ERROR( "Unit test [" << unit->p_name << "] depends on himself (not registered)" ); } else { DEPENDENCY_LOG_ERROR( "Unit test [" << unit->p_name << "] depends on his sub-tree (not registered) #2" ); } ret = false; } } } return ret; }
MEventList::MEventList(IPackage&p) { list.setAutoDelete(true); p.pos(0); QString n=p.name(),c;p>>c; //Unit Events if((n=="get"&&c=="unit")|| (n=="set"&&(c=="create unit"||c=="modify unit"))){ //unit manipulation events //load nums uint32 net;uint16 nou; p>>net>>nou; SUnit u; //load units for(;nou>0;nou--){ u.mask=0; getUnit(u,p); list.append(new MUnitEvent(net,u)); } }else
/** * Fits drawing on page. Affects DXF variable $PINSBASE. */ void RS_Graphic::fitToPage() { double border = RS_Units::convert(25.0, RS2::Millimeter, getUnit()); RS_Vector ps = getPaperSize() - RS_Vector(border, border); RS_Vector s = getSize(); double fx = RS_MAXDOUBLE; double fy = RS_MAXDOUBLE; //double factor = 1.0; //ps = RS_Units::convert(ps, getUnit(), RS2::Millimeter); if (fabs(s.x)>1.0e-6) { fx = ps.x / s.x; } if (fabs(s.y)>1.0e-6) { fy = ps.y / s.y; } setPaperScale(std::min(fx, fy)); centerToPage(); }
QVariant RMemoryStorage::getKnownVariable(RS::KnownVariable key) const { if (key==RS::INSUNITS) { return getUnit(); } else if (key==RS::LTSCALE) { return getLinetypeScale(); } // if DIMADEC is -1, DIMDEC is used: else if (key==RS::DIMADEC && knownVariables.contains(RS::DIMDEC) && knownVariables.value(RS::DIMDEC).toInt()==-1) { return getKnownVariable(RS::DIMDEC); } else if (key==RS::DWGCODEPAGE) { return "ANSI_1252"; } else { return knownVariables.value(key); } }
QString Image::tooltip() const { if (m_isGallery) return QStringLiteral("%1%2") .arg(m_id == 0 ? " " : tr("<b>ID:</b> %1<br/>").arg(m_id)) .arg(m_name.isEmpty() ? " " : tr("<b>Name:</b> %1<br/>").arg(m_name)); double size = m_fileSize; QString unit = getUnit(&size); return QStringLiteral("%1%2%3%4%5%6%7%8") .arg(m_tags.isEmpty() ? " " : tr("<b>Tags:</b> %1<br/><br/>").arg(stylishedTags(m_profile).join(" "))) .arg(m_id == 0 ? " " : tr("<b>ID:</b> %1<br/>").arg(m_id)) .arg(m_rating.isEmpty() ? " " : tr("<b>Rating:</b> %1<br/>").arg(m_rating)) .arg(m_hasScore ? tr("<b>Score:</b> %1<br/>").arg(m_score) : " ") .arg(m_author.isEmpty() ? " " : tr("<b>User:</b> %1<br/><br/>").arg(m_author)) .arg(m_size.width() == 0 || m_size.height() == 0 ? " " : tr("<b>Size:</b> %1 x %2<br/>").arg(QString::number(m_size.width()), QString::number(m_size.height()))) .arg(m_fileSize == 0 ? " " : tr("<b>Filesize:</b> %1 %2<br/>").arg(QString::number(size), unit)) .arg(!m_createdAt.isValid() ? " " : tr("<b>Date:</b> %1").arg(m_createdAt.toString(tr("'the 'MM/dd/yyyy' at 'hh:mm")))); }
/** * Default constructor. */ RS_Graphic::RS_Graphic(RS_EntityContainer* parent) : RS_Document(parent), layerList(), blockList(true),paperScaleFixed(false) { RS_SETTINGS->beginGroup("/Defaults"); setUnit(RS_Units::stringToUnit(RS_SETTINGS->readEntry("/Unit", "None"))); RS_SETTINGS->endGroup(); RS_SETTINGS->beginGroup("/Appearance"); //$ISOMETRICGRID == $SNAPSTYLE addVariable("$SNAPSTYLE",static_cast<int>(RS_SETTINGS->readNumEntry("/IsometricGrid", 0)),70); crosshairType=static_cast<RS2::CrosshairType>(RS_SETTINGS->readNumEntry("/CrosshairType",0)); RS_SETTINGS->endGroup(); RS2::Unit unit = getUnit(); if (unit==RS2::Inch) { addVariable("$DIMASZ", 0.1, 40); addVariable("$DIMEXE", 0.05, 40); addVariable("$DIMEXO", 0.025, 40); addVariable("$DIMGAP", 0.025, 40); addVariable("$DIMTXT", 0.1, 40); } else { addVariable("$DIMASZ", RS_Units::convert(2.5, RS2::Millimeter, unit), 40); addVariable("$DIMEXE", RS_Units::convert(1.25, RS2::Millimeter, unit), 40); addVariable("$DIMEXO", RS_Units::convert(0.625, RS2::Millimeter, unit), 40); addVariable("$DIMGAP", RS_Units::convert(0.625, RS2::Millimeter, unit), 40); addVariable("$DIMTXT", RS_Units::convert(2.5, RS2::Millimeter, unit), 40); } addVariable("$DIMTIH", 0, 70); //initialize printer vars bug #3602444 setPaperScale(getPaperScale()); setPaperInsertionBase(getPaperInsertionBase()); setModified(false); }
void GameState::nextTurn() { if (roundNum_ == 0) { nextRound(); return; } if (turnOrder_.empty()) return; ++curTurn_; int endOfRound = turnOrder_.size(); while (curTurn_ < endOfRound && !getUnit(turnOrder_[curTurn_]).isAlive()) { ++curTurn_; } if (curTurn_ == endOfRound) { nextRound(); } onStartTurn(); }
bool Army::deleteUnit(int id) { Unit* unit = getUnit(id); if (unit != nullptr) { std::cout << "Erase unit " << unit->getId() << std::endl; std::vector<Unit*>::iterator it; it = find(_units.begin(), _units.end(), unit); _units.erase(it); _unitFactory->removeInstances(unit->getName()); _currentId = 1; for (unsigned int i = 0; i < _units.size(); i++) { _units[i]->setId(_currentId); _currentId++; } return true; } std::cout << "L'id n'existe pas" << std::endl; return false; }
int32_t Property :: getNumFlagSettings() { int32_t retval = 0; try { if (getType() != IProperty::PROPERTY_FLAGS) throw std::runtime_error("flag is not of type PROPERTY_FLAGS"); // now, iterate through all options, counting all CONSTS that belong // to the same unit as this option const char* unit = getUnit(); if (!unit || !*unit) throw std::runtime_error("flag doesn't have a unit setting, so can't tell what constants"); // Create a fake class AVClass fakeClass; fakeClass.class_name="XuggleFakeClass"; fakeClass.item_name = fakeContextToName; fakeClass.option = mOptionStart; AVClass *fakeClassPtr = &fakeClass; const AVOption* last = 0; do { last = av_opt_next(&fakeClassPtr, last); if (last && last->unit && last->type == AV_OPT_TYPE_CONST && strcmp(unit, last->unit)==0) ++retval; } while(last); } catch (std::exception & e) { VS_LOG_DEBUG("Error: %s", e.what()); retval = -1; } return retval; }
CompilableUnit& Comp::compile(std::string filename) { if ( boost::optional<CompilableUnit&> mu = getUnit(filename) ) return *mu; CompilableUnit unit(filename); auto root = FileHelper::parse((filename + ".txt").c_str()); unit.module_symbol = std::make_shared<ModuleSymbol>(unit.module_name, BuiltIns::global_scope.get()); root -> scope = unit.module_symbol; root -> build_scope(); DefineTypesVisitor define_types_visitor; root -> accept(define_types_visitor); ExpandTemplatesVisitor expand_visitor; root -> accept(expand_visitor); DefineVisitor define_visitor; root -> accept(define_visitor); unit.module_globals = unit.module_symbol -> allSymbols(); CheckVisitor check_visitor; root -> accept(check_visitor); InlineCallVisitor inline_call_visitor; root -> accept(inline_call_visitor); GenSSAVisitor visitor(Comp::code); root -> accept(visitor); unit.root = std::move(root); Comp::units.push_back(std::move(unit)); return Comp::units.back(); }