static kbool_t FuelVM_VisitIfNode(KonohaContext *kctx, KBuilder *builder, kNode *stmt, void *thunk) { kNode *expr = kNode_getFirstNode(kctx, stmt); Block *ThenBB = CreateBlock(BLD(builder)); Block *ElseBB = CreateBlock(BLD(builder)); Block *MergeBB = CreateBlock(BLD(builder)); /* if */ SUGAR VisitNode(kctx, builder, expr, thunk); CreateBranch(BLD(builder), FuelVM_getExpression(builder), ThenBB, ElseBB); { /* then */ IRBuilder_setBlock(BLD(builder), ThenBB); SUGAR VisitNode(kctx, builder, kNode_getFirstBlock(kctx, stmt), thunk); if(!Block_HasTerminatorInst(BLD(builder)->Current)) { IRBuilder_JumpTo(BLD(builder), MergeBB); } } { /* else */ IRBuilder_setBlock(BLD(builder), ElseBB); SUGAR VisitNode(kctx, builder, kNode_getElseBlock(kctx, stmt), thunk); if(!Block_HasTerminatorInst(BLD(builder)->Current)) { IRBuilder_JumpTo(BLD(builder), MergeBB); } } /* endif */ IRBuilder_setBlock(BLD(builder), MergeBB); return true; }
static kbool_t MiniVM_VisitDoWhileNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk) { bblock_t HeadBB = new_BasicBlockLABEL(kctx); bblock_t BodyBB = new_BasicBlockLABEL(kctx); bblock_t MergeBB = new_BasicBlockLABEL(kctx); kUntypedNode_SetLabelBlock(kctx, node, KSymbol_("continue"), HeadBB); kUntypedNode_SetLabelBlock(kctx, node, KSymbol_("break"), MergeBB); MiniVMBuilder_JumpTo(kctx, builder, BodyBB); { /* Head */ MiniVMBuilder_setBlock(kctx, builder, HeadBB); KLIB VisitNode(kctx, builder, kUntypedNode_getFirstNode(kctx, node), thunk); CreateBranch(kctx, builder, MiniVM_getExpression(builder), MergeBB, BodyBB, true); } { /* Body */ MiniVMBuilder_setBlock(kctx, builder, BodyBB); KLIB VisitNode(kctx, builder, kUntypedNode_getFirstBlock(kctx, node), thunk); MiniVMBuilder_JumpTo(kctx, builder, HeadBB); } MiniVMBuilder_setBlock(kctx, builder, MergeBB); return true; }
/* "Break a branch into two parts staring from a node" */ branch_t* circuit_t::SeparateBranch (branch_t* a, node_t* n) { /* Create new branch object b, with nodes from n to a->BottomNode() */ branch_t* b = CreateBranch (branches.size(), n, a->BottomNode()); /* Starting first member / item in a that has n as its top node: */ bool first_item_reached = false; for (list<item_t>::iterator i = a->items.begin(); i != a->items.end(); i++) { if (i->e->TopNode() == n) first_item_reached = true; if (first_item_reached) { /* Change all parent branches from a to b, remove and move to b->items. */ i->e->SetParentBranch(b); b->add_item(*i); a->items.erase (i); /* TODO: Move all a current relations that concern members now in new branch to b. */ } /* if */ } /* for */ return b; } /* circuit_t::SeparateBranch */
static void CreateCond(KonohaContext *kctx, KBuilder *builder, kNode *expr, enum ConditionalOp Op, void *thunk) { kNode *LHS = kNode_At(expr, 1); kNode *RHS = kNode_At(expr, 2); Block *HeadBB = CreateBlock(BLD(builder)); Block *ThenBB = CreateBlock(BLD(builder)); Block *MergeBB = CreateBlock(BLD(builder)); /* [CondExpr] * LogicalAnd case * | goto Head * Head | let bval = LHS * | if(bval) { goto Then } else { goto Merge } * Then | bval = RHS * | goto Merge * Merge | ... */ INode *Node; IRBuilder_JumpTo(BLD(builder), HeadBB); { /* Head */ IRBuilder_setBlock(BLD(builder), HeadBB); Node = CreateLocal(BLD(builder), TYPE_boolean); SUGAR VisitNode(kctx, builder, LHS, thunk); INode *Left = FuelVM_getExpression(builder); CreateUpdate(BLD(builder), Node, Left); if(Op == LogicalAnd) { CreateBranch(BLD(builder), Left, ThenBB, MergeBB); } else { CreateBranch(BLD(builder), Left, MergeBB, ThenBB); } } { /* Then */ IRBuilder_setBlock(BLD(builder), ThenBB); SUGAR VisitNode(kctx, builder, RHS, thunk); INode *Right = FuelVM_getExpression(builder); CreateUpdate(BLD(builder), Node, Right); IRBuilder_JumpTo(BLD(builder), MergeBB); } IRBuilder_setBlock(BLD(builder), MergeBB); builder->Value = Node; }
static void CreateCond(KonohaContext *kctx, KBuilder *builder, kUntypedNode *expr, enum ConditionalOp Op, void *thunk) { intptr_t cond; kUntypedNode *LHS = kUntypedNode_At(expr, 1); kUntypedNode *RHS = kUntypedNode_At(expr, 2); bblock_t HeadBB = new_BasicBlockLABEL(kctx); bblock_t ThenBB = new_BasicBlockLABEL(kctx); bblock_t MergeBB = new_BasicBlockLABEL(kctx); /* [CondExpr] * LogicalAnd case * | goto Head * Head | let bval = LHS * | if(bval) { goto Then } else { goto Merge } * Then | bval = RHS * | goto Merge * Merge | ... */ MiniVMBuilder_JumpTo(kctx, builder, HeadBB); cond = builder->stackbase; builder->stackbase += 1; { /* Head */ MiniVMBuilder_setBlock(kctx, builder, HeadBB); KLIB VisitNode(kctx, builder, LHS, thunk); CreateUpdate(kctx, builder, KType_Boolean, cond, MiniVM_getExpression(builder)); if(Op == LogicalAnd) CreateBranch(kctx, builder, cond, ThenBB, MergeBB, false); else { CreateBranch(kctx, builder, cond, ThenBB, MergeBB, true); } } { /* Then */ MiniVMBuilder_setBlock(kctx, builder, ThenBB); KLIB VisitNode(kctx, builder, RHS, thunk); CreateUpdate(kctx, builder, KType_Boolean, cond, MiniVM_getExpression(builder)); MiniVMBuilder_JumpTo(kctx, builder, MergeBB); } MiniVMBuilder_setBlock(kctx, builder, MergeBB); builder->stackbase -= 1; builder->Value = builder->stackbase; }
element_t* circuit_t::AddElement (branch_t* p_branch, ElementType etype, ident sch_id, bool initially_reversed, node_t* a, node_t* b) { if (p_branch == NONE) { p_branch = CreateBranch (branches.size(), a,b); } /*if*/ /* Add element to table */ element_t* element= new element_t (p_branch, etype, sch_id /* IDENT */); element->SetTopNode (a); element->SetBottomNode (b); element->SetReversed (initially_reversed); elements.push_back (element ); /* Create new item for this element */ item_t item (element, initially_reversed ); //TODO: correct insertion order /* handle correct item location */ if (p_branch->items.size() == 0) { p_branch->add_item (item); } /* if */ else { for (list<item_t>::iterator i = p_branch->items.begin(); i != p_branch->items.end(); i++) { if (i->e->TopNode() == a && i->e->BottomNode() == b && a != NONE && b != NONE ) { i->e = element; break; } /* if */ else if (i->e->TopNode() == b && i->e->BottomNode() == a && a != NONE && b != NONE ) { i->e = element; i->direction = ! i->direction; break; } /* else if */ else if (next(i) == p_branch->items.end()) { p_branch-> add_item (item); break; } /* else if */ } /* for */ } /* else */ } /* circuit_t::AddElement */
////////// ////////// ////////// ////////// ////////// void SingleTreeMaker::FillBranch(const TString varName, const TString varType, const TString *val) { fMethodName = "FillBranch"; TString i = varName; // If the branch named varName does not exist, then create it and its buffer variable. if( !fBranchName[i].Contains(varName) ) CreateBranch(i,varType,1); // Fill the buffer variable for the branch named varName. sprintf(fVarChar[i],"%s",val->Data()); }//END of FillBranch()
////////// ////////// ////////// ////////// ////////// void SingleTreeMaker::FillBranch(const TString varName, const TString varType, Double_t *val, const Int_t nEls) { fMethodName = "FillBranch"; TString i = varName; // If the branch named varName does not exist, then create it and its buffer variable. if( !fBranchName[i].Contains(varName) ) CreateBranch(i,varType,nEls); // Fill each element of the buffer variable for the branch named varName. for(Int_t j=0; j<nEls; j++) fVarDouble[i][j] = val[j]; }//END of FillBranch()
static kbool_t MiniVM_VisitLoopNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk, enum LoopType Loop) { kUntypedNode *ItrBlock; bblock_t HeadBB = new_BasicBlockLABEL(kctx); bblock_t BodyBB = new_BasicBlockLABEL(kctx); bblock_t ItrBB = new_BasicBlockLABEL(kctx); bblock_t MergeBB = new_BasicBlockLABEL(kctx); kUntypedNode_SetLabelBlock(kctx, node, KSymbol_("continue"), ItrBB); kUntypedNode_SetLabelBlock(kctx, node, KSymbol_("break"), MergeBB); ItrBlock = KLIB kUntypedNode_GetNode(kctx, node, KSymbol_("Iterator"), NULL); if(ItrBlock != NULL) { assert(Loop == ForLoop); MiniVMBuilder_JumpTo(kctx, builder, HeadBB); } else if(Loop == WhileLoop) { MiniVMBuilder_JumpTo(kctx, builder, HeadBB); } else { MiniVMBuilder_JumpTo(kctx, builder, BodyBB); } { /* Head */ MiniVMBuilder_setBlock(kctx, builder, HeadBB); KLIB VisitNode(kctx, builder, kUntypedNode_getFirstNode(kctx, node), thunk); CreateBranch(kctx, builder, MiniVM_getExpression(builder), BodyBB, MergeBB, false); } { /* Body */ MiniVMBuilder_setBlock(kctx, builder, BodyBB); KLIB VisitNode(kctx, builder, kUntypedNode_getFirstBlock(kctx, node), thunk); MiniVMBuilder_JumpTo(kctx, builder, ItrBB); /* Itr */ MiniVMBuilder_setBlock(kctx, builder, ItrBB); if(ItrBlock != NULL) { KLIB VisitNode(kctx, builder, ItrBlock, thunk); } MiniVMBuilder_JumpTo(kctx, builder, HeadBB); } MiniVMBuilder_setBlock(kctx, builder, MergeBB); return true; }
static kbool_t MiniVM_VisitIfNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk) { bblock_t ThenBB = new_BasicBlockLABEL(kctx); bblock_t ElseBB = new_BasicBlockLABEL(kctx); bblock_t MergeBB = new_BasicBlockLABEL(kctx); /* if */ KLIB VisitNode(kctx, builder, kUntypedNode_getFirstNode(kctx, node), thunk); CreateBranch(kctx, builder, MiniVM_getExpression(builder), ThenBB, ElseBB, false); { /* then */ MiniVMBuilder_setBlock(kctx, builder, ThenBB); KLIB VisitNode(kctx, builder, kUntypedNode_getFirstBlock(kctx, node), thunk); if(!Block_HasTerminatorInst(kctx, builder->bbMainId)) MiniVMBuilder_JumpTo(kctx, builder, MergeBB); } { /* else */ MiniVMBuilder_setBlock(kctx, builder, ElseBB); KLIB VisitNode(kctx, builder, kUntypedNode_getElseBlock(kctx, node), thunk); if(!Block_HasTerminatorInst(kctx, builder->bbMainId)) MiniVMBuilder_JumpTo(kctx, builder, MergeBB); } /* endif */ MiniVMBuilder_setBlock(kctx, builder, MergeBB); return true; }
Plant::Plant(float iter) { if (!cylinder) CreateBranch(); if (!leaf) CreateLeaf(); if (!sphere) CreateSphere(); branchLength = iter; growRate = 0.07f; branches = 3; memUsage = sizeof(*leaf) + sizeof(*cylinder) + sizeof(*sphere); trunk = new SceneNode(); trunk->SetMesh(cylinder); trunk->SetModelScale(Vector3(0,0,0)); trunk->SetTransform(Matrix4::Translation(Vector3(0, 0, 0))); memUsage += sizeof(*trunk); AddChild(trunk); CreateTree(trunk, branchLength); }
static kbool_t FuelVM_VisitLoopNode(KonohaContext *kctx, KBuilder *builder, kNode *stmt, void *thunk, enum LoopType Loop) { Block *HeadBB = CreateBlock(BLD(builder)); Block *BodyBB = CreateBlock(BLD(builder)); Block *ItrBB = CreateBlock(BLD(builder)); Block *MergeBB = CreateBlock(BLD(builder)); kNode_SetLabelBlock(kctx, stmt, KSymbol_("continue"), ItrBB); kNode_SetLabelBlock(kctx, stmt, KSymbol_("break"), MergeBB); kNode *itrBlock = SUGAR kNode_GetNode(kctx, stmt, KSymbol_("Iterator"), NULL); if(itrBlock != NULL) { assert(Loop == ForLoop); IRBuilder_JumpTo(BLD(builder), HeadBB); } else if(Loop == WhileLoop) { /* [WhileStmt] * "Head" is Join Node * Head : if(COND) { goto Body } else {goto Merge } * Body : Body * ... * goto Itr * Itr : Body3 * goto Head * Merge : ... */ IRBuilder_JumpTo(BLD(builder), HeadBB); } else { /* [LoopStmt] (e.g. do-while loop) * "Body" is Join Node * Body : Body * ... * goto Itr * Itr : Body3 * goto Head * Head : if(COND) { goto Body } else {goto Merge } * Merge : ... */ IRBuilder_JumpTo(BLD(builder), BodyBB); } { /* Head */ IRBuilder_setBlock(BLD(builder), HeadBB); SUGAR VisitNode(kctx, builder, kNode_getFirstNode(kctx, stmt), thunk); CreateBranch(BLD(builder), FuelVM_getExpression(builder), BodyBB, MergeBB); } { /* Body */ IRBuilder_setBlock(BLD(builder), BodyBB); SUGAR VisitNode(kctx, builder, kNode_getFirstBlock(kctx, stmt), thunk); IRBuilder_JumpTo(BLD(builder), ItrBB); /* Itr */ IRBuilder_setBlock(BLD(builder), ItrBB); if(itrBlock != NULL) { SUGAR VisitNode(kctx, builder, itrBlock, thunk); } IRBuilder_JumpTo(BLD(builder), HeadBB); } IRBuilder_setBlock(BLD(builder), MergeBB); return true; }