void LessParser::handleMixin(BlockNode* blockNode) { //cerr << "MIXIN_START: " << blockNode->FullSelectors << endl; for(auto it = blockNode->Children.begin(); it != blockNode->Children.end(); ++it) { if((*it)->Type == ParseNodeType::Mixin) { MixinNode* mixin = (MixinNode*) *it; BlockNode* node = blockNode; while((node = (BlockNode*) node->Parent) != 0) { for(auto jt = node->Children.begin(); jt != node->Children.end(); ++jt) { if((*jt)->Type == ParseNodeType::Block) { BlockNode* block = (BlockNode*) *jt; if(block->Selectors == mixin->Anchor) { mixin->LinkedBlock = block->Copy(); mixin->LinkedBlock->Parent = node; string fullSelectors(mixin->LinkedBlock->Selectors); if(!node->IsRoot) fullSelectors.insert(0, " ").insert(0, node->FullSelectors); mixin->LinkedBlock->FullSelectors = fullSelectors; if(mixin->Arguments != "") mixin->LinkedBlock->FillArguments(mixin->Arguments); goto MIXIN_ONE_DONE; } } } } FATAL("ERROR_MIXIN_LINK_FAILED"); MIXIN_ONE_DONE: //cerr << "MIXIN_LINK: " << mixin->Anchor << " -> " << mixin->LinkedBlock->FullSelectors << endl; cout; } else if((*it)->Type == ParseNodeType::Block) { BlockNode* block = (BlockNode*) *it; handleMixin(block); } } //cerr << "MIXIN_END: " << blockNode->FullSelectors << endl; }
void CDisassembler::ParseProgram(Program *prog) { prog->EntryAddr = EntryAddr; int functioni; for( functioni = 1; functioni < FunctionList.GetNumEntries(); functioni++ ) { int section = FunctionList[functioni].Section; uint64_t func_start_offset = FunctionList[functioni].Start; uint64_t func_end_offset = FunctionList[functioni].End; uint64_t section_addr = Sections[section].SectionAddress; if((Sections[section].Type & 0xFF) == 1) { FunctionNode func; func.StartAddress = section_addr + func_start_offset; func.EndAddress = section_addr + func_end_offset; vector<Instruction> insns; uint64_t start_addr, end_addr; SetFunctionDescriptor(func.StartAddress); while( GetBlockInFunction( &insns, &start_addr, &end_addr ) != -1 ) { if(insns.size() == 0) fprintf(stderr, "[error] can't get block assembly\n"); BlockNode node; node.Init( insns, start_addr, end_addr ); func.Insert( node ); insns.clear(); } //flow_graph1.PrintAllPath(); prog->Insert(func); } } uint32_t sym_num = Symbols.GetNumEntries(); for(int i = 0; i < sym_num; i++) { if(Symbols[i].Name) { int section = Symbols[i].Section; uint64_t section_addr = Sections[section].SectionAddress; uint64_t sym_addr = section_addr + Symbols[i].Offset; const char *sym_name = Symbols.GetName(i); if(sym_name[0] != '?') prog->AddSymbol(sym_addr, sym_name); } } }
virtual void deleteAll() { ifStmt->deleteAll(); elifStmts->deleteAll(); if (elseStmt) { elseStmt->deleteAll(); } }
void XmlRenderer::renderNode(const BlockNode& node) { // StringBuffer attrs; // if (fShowNodeType && node.type().isDef()) // attrs << " ty='" << xmlEncode(node.type().typeId()) << "'"; // displayOpenTagAttrs("block", StrHelper(attrs.toString())); // displayNodeList(nullptr, node.children()); // displayCloseTag("block"); displayNodeList("block", node.children()); }
void AstPrinter::printFunction(AstFunction *function) { print("function "); print(typeToName(function->returnType())); print(" "); print(function->name()); print("("); for(uint32_t i = 0; i < function->parametersNumber(); i++) { if (i != 0) print(", "); print(typeToName(function->parameterType(i))); print(" "); print(function->parameterName(i)); } print(") "); BlockNode *block = function->node()->body(); if (block->nodeAt(0) && block->nodeAt(0)->isNativeCallNode()) { block->nodeAt(0)->visit(this); print("\n"); } else { function->node()->body()->visit(this); } }
ForNode* Parser::parseFor() { uint32_t token = _currentTokenIndex; ensureKeyword("for"); ensureToken(tLPAREN); if (currentToken() != tIDENT) { error("identifier expected"); } const string& varName = currentTokenValue(); consumeToken(); ensureKeyword("in"); AstNode* inExpr = parseExpression(); ensureToken(tRPAREN); BlockNode* forBody = parseBlock(true); AstVar* forVar = forBody->scope()->lookupVariable(varName); return new ForNode(token, forVar, inExpr, forBody); }
void BlockNode::render( OutputStream *stream, Context *c ) { QVariant &variant = c->renderContext()->data( BLOCK_CONTEXT_KEY ); BlockContext blockContext = variant.value<BlockContext>(); c->push(); if ( blockContext.isEmpty() ) { m_context = c; m_stream = stream; c->insert( QLatin1String( "block" ), QVariant::fromValue( static_cast<QObject *>( this ) ) ); m_list.render( stream, c ); m_stream = 0; } else { BlockNode *block = blockContext.pop( m_name ); variant.setValue( blockContext ); BlockNode *push = block; if ( !block ) block = this; // BIC Make const when render() is const. NodeList list = block->m_list; block = new BlockNode( block->m_name, 0 ); block->setNodeList( list ); block->m_context = c; block->m_stream = stream; c->insert( QLatin1String( "block" ), QVariant::fromValue( static_cast<QObject *>( block ) ) ); list.render( stream, c ); delete block; if ( push ) { blockContext.push( m_name, push ); variant.setValue( blockContext ); } } c->pop(); }
Node* BlockNodeFactory::getNode( const QString &tagContent, Parser *p ) const { const QStringList expr = smartSplit( tagContent ); if ( expr.size() != 2 ) { throw Grantlee::Exception( TagSyntaxError, QLatin1String( "block tag takes one argument" ) ); } const QString blockName = expr.at( 1 ); QVariant loadedBlocksVariant = p->property( __loadedBlocks ); QVariantList blockVariantList; if ( loadedBlocksVariant.isValid() && loadedBlocksVariant.type() == QVariant::List ) { blockVariantList = loadedBlocksVariant.toList(); QListIterator<QVariant> it( blockVariantList ); while ( it.hasNext() ) { const QString blockNodeName = it.next().toString(); if ( blockNodeName == blockName ) { throw Grantlee::Exception( TagSyntaxError, QString::fromLatin1( "%1 appears more than once." ).arg( blockName ) ); } } } // Block not already in list. blockVariantList.append( blockName ); loadedBlocksVariant = QVariant( blockVariantList ); p->setProperty( __loadedBlocks, loadedBlocksVariant ); BlockNode *n = new BlockNode( blockName, p ); const NodeList list = p->parse( n, QStringList() << QLatin1String( "endblock" ) << QLatin1String( "endblock " ) + blockName ); n->setNodeList( list ); p->removeNextToken(); return n; }
BlockNode* Parser::parseBlock(bool needBraces, const bool scoped/* = true */) { if (needBraces) { ensureToken(tLBRACE); } if (scoped) { pushScope(); } BlockNode* block = new BlockNode(_currentTokenIndex, _currentScope); TokenKind sentinel = needBraces ? tRBRACE : tEOF; while (currentToken() != sentinel) { if (currentToken() == tSEMICOLON) { consumeToken(); continue; } AstNode* statement = parseStatement(); // Ignore statements that doesn't result in AST nodes, such // as variable or function declaration. if (statement != 0) { block->add(statement); } } if (scoped) { popScope(); } if (needBraces) { ensureToken(tRBRACE); } return block; }
virtual void deleteAll() { block->deleteAll(); }
virtual void deleteAll() { args->deleteAll(); body->deleteAll(); }
virtual void deleteAll() { cond->deleteAll(); body->deleteAll(); }
virtual void deleteAll() { var->deleteAll(); cond->deleteAll(); body->deleteAll(); }
void ScheduleDialog::drawTimings(DrawProperties *p, BlockNode* node) { int line = blocks_.findIndex(node); int y = p->y + line * (BOX_HEIGHT + BOX_YSPACING) + RULER_HEIGHT; // if nameWidth is set the name should be drawn within the graph canvas if (p->nameWidth == 0) { // draw labels QCanvasText* text = new QCanvasText(node->model()->name(), labelCanvas); text->move(WIDGET_SPACING, y); text->show(); // resize canvas if label doesn't fit. if ((int)(text->boundingRect().width() + 2 * WIDGET_SPACING) > labelCanvas->width()) { labelCanvas->resize(text->boundingRect().width() + (2 * WIDGET_SPACING), labelCanvas->height()); labelCanvasView->setFixedWidth(labelCanvas->width() + 4); } } else { // draw labels QCanvasText* text = new QCanvasText(node->model()->name(), p->canvas); text->move(p->x, y); text->show(); } // check if block is configured correctly if (node->clock() <= 0) { // draw info and skip QCanvasRectangle *box = new QCanvasRectangle(p->canvas); box->setSize(p->width - p->nameWidth, BOX_HEIGHT + BOX_YSPACING); box->setBrush(white); box->setPen(lightGray); box->move(p->x + p->nameWidth, RULER_HEIGHT - BOX_YSPACING / 2 + line * (BOX_YSPACING + BOX_HEIGHT)); box->setZ(2); box->show(); QCanvasText *text = new QCanvasText(tr("Missing clock value."), p->canvas); text->move(p->x + p->nameWidth, y); text->setColor(black); text->setZ(3); text->show(); return; } // draw blocks int t = node->offset(); double X = t * p->pixPerNs; while (X < p->width - p->nameWidth) { // draw block QRect thisBlock = calcBlockPosition(p, node, t); QCanvasRectangle* box = new FancyRectangle(thisBlock, p->canvas); // box->setBrush(QBrush(white)); box->setBrush(QBrush(colormanager_->color(node->model()))); box->setZ(2); box->show(); // draw lines for all connected 'children' QPtrList<BlockNode> neighbours = node->neighbours(); for (QPtrListIterator<BlockNode> it(neighbours); it != 0; ++it) { BlockNode *target = *it; // skip if child has no clock if (target->clock() <= 0) { continue; } // find next start time for the target block unsigned int targetTime = target->offset(); while (targetTime <= t + node->runtime()) { targetTime += target->clock(); } // check if this block is the next source for the target block if (t + (2 * node->runtime()) + node->clock() < targetTime) { continue; } // calculate position of the target block QRect targetBlock = calcBlockPosition(p, target, targetTime); // draw a line with arrowhead between this block and the next // target block. QCanvasLine *line = new ArrowLine(p->canvas); int start = thisBlock.x() + (int)rint(node->runtime() * p->pixPerNs * zoom_); line->setPoints(start, thisBlock.y() + thisBlock.height(), targetBlock.x(), targetBlock.y()); line->setZ(1); line->show(); } t += node->clock(); X = rint(t * p->pixPerNs); } return; }
FunctionNode* Parser::parseFunction() { uint32_t tokenIndex = _currentTokenIndex; ensureKeyword("function"); if (currentToken() != tIDENT) { error("identifier expected"); } const string& returnTypeName = currentTokenValue(); VarType returnType = nameToType(returnTypeName); if (returnType == VT_INVALID) { error("wrong return type"); } consumeToken(); if (currentToken() != tIDENT) { error("name expected"); } const string& name = currentTokenValue(); consumeToken(); Signature signature; signature.push_back(SignatureElement(returnType, "return")); ensureToken(tLPAREN); while (currentToken() != tRPAREN) { const string& parameterTypeName = currentTokenValue(); VarType parameterType = nameToType(parameterTypeName); if (parameterType == VT_INVALID) { error("wrong parameter type"); } consumeToken(); const string& parameterName = currentTokenValue(); if (currentToken() != tIDENT) { error("identifier expected"); } consumeToken(); signature.push_back(SignatureElement(parameterType, parameterName)); if (currentToken() == tCOMMA) { consumeToken(); } } ensureToken(tRPAREN); BlockNode* body = 0; pushScope(); for (uint32_t i = 1; i < signature.size(); i++) { const string& name = signature[i].second; VarType type = signature[i].first; if (!_currentScope->declareVariable(name, type)) { error("Formal \"%s\" already declared", name.c_str()); } } if ((currentToken() == tIDENT) && currentTokenValue() == "native") { consumeToken(); if (currentToken() != tSTRING) { error("Native name expected, got %s", tokenStr(currentToken())); } pushScope(); body = new BlockNode(_currentTokenIndex, _currentScope); body->add(new NativeCallNode(tokenIndex, currentTokenValue(), signature)); consumeToken(); ensureToken(tSEMICOLON); body->add(new ReturnNode(0, 0)); popScope(); } else { body = parseBlock(true, false); if (body->nodes() == 0 || !(body->nodeAt(body->nodes() - 1)->isReturnNode())) { body->add(new ReturnNode(0, defaultReturnExpr(returnType))); } } popScope(); if (_currentScope->lookupFunction(name) != 0) { error("Function %s already defined", name.c_str()); } FunctionNode* result = new FunctionNode(tokenIndex, name, signature, body); _currentScope->declareFunction(result); // We don't add function node into AST. return 0; }
void Jumpman::onCollision(CollisionEvent event) { Collider* collider = event.myCollider(); double rollbackTime = event.getCollisionTime() * mDeltaTime; float bounce = 1.3f; float bounceMin = 0.2f; unsigned int reference = collider->getRefNumber(); if(reference == mFeetNumber) { //std::cout << " FEET " << std::endl; mIsGrounded = true; std::vector<glm::vec3> contactPoints = event.getContactPoints(); float yOverlap = contactPoints[0].y; float upVelocity = glm::dot(mOrientation.getUp(), mVelocity); if(mVelocity.y < 0) { mVelocity.y = 0; } glm::vec3 pos = mOrientation.getPos(); if(yOverlap - pos.y < 0.3f) { pos.y = yOverlap+mFeetHeight; } mOrientation.setPos(pos); std::cout << yOverlap << std::endl; //glm::vec3 rollback = float(rollbackTime) * (-mVelocity * mOrientation.getUp()); //mOrientation.translate(rollback.x, rollback.y, rollback.z); } else if(reference == mRayNumber) { std::vector<glm::vec3> contactPoints = event.getContactPoints(); //Should only be one point, but just make sure. for(int i = 0; i < contactPoints.size(); i++) { BlockNode* blockNode = (BlockNode*) event.collidedWith()->getMaster(); mClimable = blockNode->isClimable(contactPoints[i]); mClimableCoord = contactPoints[i]; std::cout << " RAYHIT: "; if(mClimable) std::cout << "brick" << std::endl; else std::cout << "metal" << std::endl; std::cout << " X: " << contactPoints[i].x << " Y: " << contactPoints[i].y <<" Z:" << contactPoints[i].z << std::endl; } } else { if(reference == mFrontNumber) { mCanMoveForward = false; glm::vec3 inverseForward = -mOrientation.getForward(); float forwardVelocity = glm::dot(inverseForward, mVelocity); if(forwardVelocity > 0.0f) { //glm::vec3 rollback = float(rollbackTime) * (-mVelocity * mOrientation.getForward()); //mOrientation.translate(rollback.x, rollback.y, rollback.z); mBounceVelocity -= ( ((bounce * forwardVelocity)+bounceMin) * inverseForward) ; std::cout << "FRONT: " << mVelocity.x << ", " << mVelocity.y << ", " << mVelocity.z << std::endl; } } else if(reference == mBackNumber) { mCanMoveBackward = false; glm::vec3 inverseForward = -mOrientation.getForward(); float forwardVelocity = glm::dot(inverseForward, mVelocity); if(forwardVelocity < -0.0f) { //glm::vec3 rollback = float(rollbackTime) * (-mVelocity * mOrientation.getForward()); //mOrientation.translate(rollback.x, rollback.y, rollback.z); mBounceVelocity -= (((bounce * forwardVelocity)-bounceMin) * inverseForward); std::cout << "BACK: " << mVelocity.x << ", " << mVelocity.y << ", " << mVelocity.z << std::endl; } } else if(reference == mLeftNumber) { mCanMoveLeft = false; float rightVelocity = glm::dot(mOrientation.getRight(), mVelocity); if(rightVelocity < -0.0f) { //glm::vec3 rollback = float(rollbackTime) * (-mVelocity * mOrientation.getRight()); //mOrientation.translate(rollback.x, rollback.y, rollback.z); mBounceVelocity -= (((bounce * rightVelocity)-bounceMin) * mOrientation.getRight()); std::cout << "LEFT: " << mVelocity.x << ", " << mVelocity.y << ", " << mVelocity.z << std::endl; } } else if(reference == mRightNumber) { mCanMoveRight = false; float rightVelocity = glm::dot(mOrientation.getRight(), mVelocity); if(rightVelocity > 0.0f) { //glm::vec3 rollback = float(rollbackTime) * (-mVelocity * mOrientation.getRight()); //mOrientation.translate(rollback.x, rollback.y, rollback.z); mBounceVelocity -= (((bounce * rightVelocity)+bounceMin) * mOrientation.getRight()); std::cout << "RIGHT: " << mVelocity.x << ", " << mVelocity.y << ", " << mVelocity.z << std::endl; } } else if(reference == mTopNumber) { mCanJump = false; float upVelocity = glm::dot(mOrientation.getUp(), mVelocity); if(upVelocity > 0.0f) { mBounceVelocity -= (((bounce * upVelocity)-bounceMin) * mOrientation.getUp()); } //std::cout << " TOP " << std::endl; } } }