// buildResolveStatement builds the CodeDOM for a resolve statement. func (db *domBuilder) buildResolveStatement(node compilergraph.GraphNode) (codedom.Statement, codedom.Statement) { sourceExpr := db.getExpression(node, parser.NodeResolveStatementSource) destinationNode := node.GetNode(parser.NodeAssignedDestination) destinationScope, _ := db.scopegraph.GetScope(destinationNode) destinationName := destinationNode.Get(parser.NodeNamedValueName) var destinationStatement codedom.Statement = nil if !destinationScope.GetIsAnonymousReference() { destinationStatement = codedom.VarDefinitionWithInit(destinationName, sourceExpr, node) } else { destinationStatement = codedom.ExpressionStatement(sourceExpr, node) destinationName = "" } // If the resolve statement has a rejection value, then we need to wrap the source expression // call to catch any rejections *or* exceptions. rejectionNode, hasRejection := node.TryGetNode(parser.NodeAssignedRejection) if hasRejection { rejectionName := rejectionNode.Get(parser.NodeNamedValueName) rejectionScope, _ := db.scopegraph.GetScope(rejectionNode) if rejectionScope.GetIsAnonymousReference() { rejectionName = "" } empty := codedom.EmptyStatement(node) return codedom.ResolveExpression(sourceExpr, destinationName, rejectionName, empty, node), empty } else { // Otherwise, we simply execute the expression, optionally assigning it to the // destination variable. return destinationStatement, destinationStatement } }
// popResource removes a resource from the resource stack. func (sg *stateGenerator) popResource(name string, basis compilergraph.GraphNode) { sg.managesResources = true sg.resources.Pop() // popr('varName').then(...) popCall := codedom.RuntimeFunctionCall( codedom.StatePopResourceFunction, []codedom.Expression{ codedom.LiteralValue("'"+name+"'", basis), }, basis, ) sg.generateStates(codedom.ExpressionStatement(codedom.AwaitPromise(popCall, basis), basis), generateImplicitState) }
// pushResource adds a resource to the resource stack with the given name. func (sg *stateGenerator) pushResource(name string, basis compilergraph.GraphNode) { sg.managesResources = true // pushr(varName, 'varName'); pushCall := codedom.RuntimeFunctionCall( codedom.StatePushResourceFunction, []codedom.Expression{ codedom.LocalReference(name, basis), codedom.LiteralValue("'"+name+"'", basis), }, basis, ) sg.generateStates(codedom.ExpressionStatement(pushCall, basis), generateImplicitState) sg.resources.Push(resource{ name: name, basis: basis, }) }
// buildExpressionStatement builds the CodeDOM for an expression at the statement level. func (db *domBuilder) buildExpressionStatement(node compilergraph.GraphNode) codedom.Statement { childExpr := db.getExpression(node, parser.NodeExpressionStatementExpression) return codedom.ExpressionStatement(childExpr, node) }
// buildAssignStatement builds the CodeDOM for an assignment statement. func (db *domBuilder) buildAssignStatement(node compilergraph.GraphNode) codedom.Statement { targetNode := node.GetNode(parser.NodeAssignStatementName) exprValue := db.getExpression(node, parser.NodeAssignStatementValue) return codedom.ExpressionStatement(db.buildAssignmentExpression(targetNode, exprValue, node), node) }
// buildLoopStatement builds the CodeDOM for a loop statement. func (db *domBuilder) buildLoopStatement(node compilergraph.GraphNode) (codedom.Statement, codedom.Statement) { startStatement := codedom.EmptyStatement(node) startStatement.MarkReferenceable() finalStatement := codedom.EmptyStatement(node) // Save initial continue and break statements for the loop. db.continueStatementMap[node.NodeId] = startStatement db.breakStatementMap[node.NodeId] = finalStatement // A loop statement is buildd as a start statement which conditionally jumps to either the loop body // (on true) or, on false, jumps to a final state after the loop. if loopExpr, hasLoopExpr := db.tryGetExpression(node, parser.NodeLoopStatementExpression); hasLoopExpr { // Check for a named value under the loop. If found, this is a loop over a stream or streamable. namedValue, hasNamedValue := node.TryGetNode(parser.NodeStatementNamedValue) if hasNamedValue { namedValueName := namedValue.Get(parser.NodeNamedValueName) resultVarName := db.generateScopeVarName(node) namedValueScope, _ := db.scopegraph.GetScope(namedValue) // Create the stream variable. streamVarName := db.generateScopeVarName(node) var streamVariable = codedom.VarDefinitionWithInit(streamVarName, loopExpr, node) // If the expression is Streamable, first call .Stream() on the expression to get the stream // for the variable. if namedValueScope.HasLabel(proto.ScopeLabel_STREAMABLE_LOOP) { // Call .Stream() on the expression. streamableMember, _ := db.scopegraph.TypeGraph().StreamableType().GetMember("Stream") streamExpr := codedom.MemberCall( codedom.MemberReference(loopExpr, streamableMember, namedValue), streamableMember, []codedom.Expression{}, namedValue) streamVariable = codedom.VarDefinitionWithInit(streamVarName, streamExpr, node) } // Create variables to hold the named value (as requested in the SRG) and the loop result. namedVariable := codedom.VarDefinition(namedValueName, node) resultVariable := codedom.VarDefinition(resultVarName, node) // Create an expression statement to set the result variable to a call to Next(). streamMember, _ := db.scopegraph.TypeGraph().StreamType().GetMember("Next") nextCallExpr := codedom.MemberCall( codedom.MemberReference(codedom.LocalReference(streamVarName, node), streamMember, node), streamMember, []codedom.Expression{}, namedValue) resultExpressionStatement := codedom.ExpressionStatement(codedom.LocalAssignment(resultVarName, nextCallExpr, namedValue), namedValue) resultExpressionStatement.MarkReferenceable() // Set the continue statement to call Next() again. db.continueStatementMap[node.NodeId] = resultExpressionStatement // Create an expression statement to set the named variable to the first part of the tuple. namedExpressionStatement := codedom.ExpressionStatement( codedom.LocalAssignment(namedValueName, codedom.NativeAccess( codedom.LocalReference(resultVarName, namedValue), "First", namedValue), namedValue), namedValue) // Jump to the body state if the second part of the tuple in the result variable is true. bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock) checkJump := codedom.ConditionalJump( codedom.NativeAccess(codedom.LocalReference(resultVarName, node), "Second", node), bodyStart, finalStatement, node) // Steps: // 1) Empty statement // 2) Create the stream's variable (with no value) // 3) Create the named value variable (with no value) // 4) Create the result variable (with no value) // 5) (loop starts here) Pull the Next() result out of the stream // 6) Pull the true/false bool out of the result // 7) Pull the named value out of the result // 8) Jump based on the true/false boolean value codedom.AssignNextStatement(startStatement, streamVariable) codedom.AssignNextStatement(streamVariable, namedVariable) codedom.AssignNextStatement(namedVariable, resultVariable) codedom.AssignNextStatement(resultVariable, resultExpressionStatement) codedom.AssignNextStatement(resultExpressionStatement, namedExpressionStatement) codedom.AssignNextStatement(namedExpressionStatement, checkJump) // Jump to the result checking expression once the loop body completes. directJump := codedom.UnconditionalJump(resultExpressionStatement, node) codedom.AssignNextStatement(bodyEnd, directJump) return startStatement, finalStatement } else { bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock) // Loop over a direct boolean expression which is evaluated on each iteration. initialJump := codedom.ConditionalJump(loopExpr, bodyStart, finalStatement, node) directJump := codedom.UnconditionalJump(initialJump, node) codedom.AssignNextStatement(bodyEnd, directJump) codedom.AssignNextStatement(startStatement, initialJump) return startStatement, finalStatement } } else { bodyStart, bodyEnd := db.getStatements(node, parser.NodeLoopStatementBlock) // A loop without an expression just loops infinitely over the body. directJump := codedom.UnconditionalJump(bodyStart, node) codedom.AssignNextStatement(bodyEnd, directJump) codedom.AssignNextStatement(startStatement, bodyStart) return startStatement, directJump } }