bool Expr::parseUnaryExpression() { PARSER_FLOW_TRACER(); /* left associative */ switch (ahead().type()) { case T_AT_SIGN: emitError("addr-of-operator unsupported"); // ### @foo (addr-of operator) return false; case T_MINUS: case T_PLUS: case T_NOT: { Model::ExprUnary::Ptr result = new Model::ExprUnary; result->setUnaryOperator(tokenToUnary(ahead().type())); next(); FAIL_IF_NOT(parsePrimaryExpression()); result->setOperand(model()); setModel(result); return true; } default: return parsePrimaryExpression(); } }
bool Expr::parseRelationalExpression() { PARSER_FLOW_TRACER(); /* right associative */ FAIL_IF_NOT(parseAdditiveExpression()); switch(ahead().type()) { case T_LESS_THAN_EQUAL: case T_GREATER_THAN_EQUAL: case T_LEFT_ANGLE: case T_RIGHT_ANGLE: case T_EQUAL: case T_INEQUAL: { Model::ExprBinary::Ptr result = new Model::ExprBinary; result->setLeftOperand(model()); result->setBinaryOperator(tokenToBinary(ahead().type())); next(); FAIL_IF_NOT(parseAdditiveExpression()); result->setRightOperand(model()); setModel(result); } } return true; }
bool Expr::parsePrimaryExpression() { PARSER_FLOW_TRACER(); switch(ahead().type()) { case T_LEFT_PAREN: { REQUIRE_TOKEN(T_LEFT_PAREN); FAIL_IF_NOT(parseExpression()); REQUIRE_TOKEN(T_RIGHT_PAREN); return true; } case T__NUMBER: { next(); setModel(new Model::ExprConstNumber(current().number())); return true; } case T__STRING: { next(); setModel(new Model::ExprConstString(QString::fromUtf8(current().text().constData()))); return true; } case T__FLOAT: next(); setModel(new Model::ExprConstDouble(current().numberFloat())); return true; case T__IDENTIFIER: { Model::Decl::Ptr decl = curCtx()->lookup(ahead().identifier()); if (!decl) { emitError(QLatin1Literal("Unknown identifier: ") % Model::Identifier(ahead().identifier()).toString()); return false; } if (decl->type() == Model::oDeclConst) { next(); Model::ExprConstConst::Ptr ecc = new Model::ExprConstConst; ecc->setDecl(decl.scast<Model::DeclConst>()); setModel(ecc); return true; } LValue lvp(this); lvp.setOptions(LValue::AllowFunctionCall); FAIL_IF_NOT(lvp()); Model::ExprLValue::Ptr elv = new Model::ExprLValue; elv->setLValue(lvp.model()); setModel(elv); return true; } default: return false; } }
static bool scanFor(std::istream &in, const uint8_t * bytes, const unsigned len) { std::vector<uint8_t> ahead(len); // the bytes matched in.read((char*)&ahead.front(), len); unsigned count = in.gcount(); if (count < len) return false; unsigned offset=0; // the index mod len which we're in ahead do { bool found=true; for (unsigned i=0; i < len; i++) { if (ahead[(i+offset)%len] != bytes[i]) { found=false; break; } } if (found) return true; ahead[offset++%len] = in.get(); } while (!in.eof()); return false; }
void MSEdge::initialize(const std::vector<MSLane*>* lanes) { assert(lanes != 0); myLanes = lanes; if (!lanes->empty()) { recalcCache(); } if (myFunction == EDGEFUNCTION_DISTRICT) { myCombinedPermissions = SVCAll; } for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) { myWidth += (*i)->getWidth(); } if (MSGlobals::gLateralResolution > 0 || MSGlobals::gLaneChangeDuration > 0) { SUMOReal widthBefore = 0; for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) { (*i)->setRightSideOnEdge(widthBefore, (int)mySublaneSides.size()); MSLeaderInfo ahead(*i); for (int j = 0; j < ahead.numSublanes(); ++j) { mySublaneSides.push_back(widthBefore + j * MSGlobals::gLateralResolution); } widthBefore += (*i)->getWidth(); } } }
bool dfs(Node node, int step) { visited[node.x][node.y] = true; route[step] = mark[node.x][node.y]; if (step == SIZE - 1) { for (int i = 0; i < SIZE; i++) printf("%d%c", route[i], i == SIZE - 1 ? '\n' : ' '); return true; } else { std::vector<Node> v; for (int i = 0; i < NEIGHBOR; i++) { Node cur(node.x + dx[i], node.y + dy[i]); if (valid(cur)) { for (int j = 0; j < NEIGHBOR; j++) { Node ahead(cur.x + dx[j], cur.y + dy[j]); if (valid(ahead)) cur.next++; } v.push_back(cur); } } std::sort(v.begin(), v.end(), cmp); for (int i = 0; i < v.size(); i++) { visited[v[i].x][v[i].y] = true; if (dfs(v[i], step + 1)) return true; visited[v[i].x][v[i].y] = false; } return false; } }
bool Expr::parseMultiplicativeExpression() { PARSER_FLOW_TRACER(); /* right associative */ FAIL_IF_NOT(parseUnaryExpression()); while (IS_MULTI_EXPR_OPER(ahead().type())) { Model::ExprBinary::Ptr result = new Model::ExprBinary; result->setLeftOperand(model()); result->setBinaryOperator(tokenToBinary(ahead().type())); next(); FAIL_IF_NOT(parseUnaryExpression()); result->setRightOperand(model()); setModel(result); } return true; }
double_vector vavImage::GetRingB(double x, double y, double radius, int div) { double_vector ans; double step = 360.0 / div; Vector2 ahead(0, -radius); for (int i = 0; i < div; ++i) { Vector2 move = Quaternion::GetRotation(ahead, i * step); ans.push_back(GetBilinearB(x + move.x, y + move.y)); } return ans; }
int main() { int i; setup_movement(); ahead(); turn_right(); turn_left(); }
double_vector vavImage::GetLineB(double x1, double y1, double x2, double y2, int div) { double_vector ans; double step = 1.0 / (div - 1); Vector2 ahead(x2 - x1, y2 - y1); ahead *= step; for (int i = 0; i < div; ++i) { ans.push_back(GetBilinearB(x1 + ahead.x * i, y1 + ahead.y * i)); } return ans; }
// Apply the camera's transformations to the world: void Camera::applyTransform() { // Move world to match camera: GL::rotatePitch(-pitch); GL::rotateYaw(-yaw); GL::translate(-location); // Setup lighting: vec3 a = ahead(), l = location-40.*a-50.*vec3::Y(); a-=vec3(0,a.y*0.2,0); X_SPOT_LT(1, RGB(240,240,200), l.x, l.y, l.z, a.x, a.y*0.5, a.z, 57); X_SPOT_LT(2, RGB(40,50,60), l.x, l.y, l.z, a.x, a.y*0.5, a.z, 70); X_FOG(RGB(0,0,0), true, 0.00045, 0); }