コード例 #1
0
 bool IDfirNodeVisitor <bool> .VisitBuildTupleNode(BuildTupleNode buildTupleNode)
 {
     foreach (Terminal inputTerminal in buildTupleNode.InputTerminals)
     {
         MarkTrueVariableOfTerminalConsumed(inputTerminal);
     }
     MarkFacadeVariableOfTerminalLive(buildTupleNode.OutputTerminals[0]);
     return(true);
 }
コード例 #2
0
ファイル: TupleTests.cs プロジェクト: rebarlang/rebar
        public void BuildTupleNodeWithUnwiredInputs_ValidateVariableUsages_ErrorOnUnwiredInputs()
        {
            DfirRoot       function   = DfirRoot.Create();
            BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);

            ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, false);

            RunSemanticAnalysisUpToValidation(function);

            AssertTerminalHasRequiredTerminalUnconnectedMessage(buildTuple.InputTerminals[1]);
        }
コード例 #3
0
ファイル: TupleTests.cs プロジェクト: rebarlang/rebar
        public void BuildTupleNode_SetVariableTypes_OutputIsClusterType()
        {
            DfirRoot       function   = DfirRoot.Create();
            BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);

            ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, false);
            ConnectConstantToInputTerminal(buildTuple.InputTerminals[1], NITypes.Boolean, false);

            RunSemanticAnalysisUpToSetVariableTypes(function);

            VariableReference builtTupleOutputVariable = buildTuple.OutputTerminals[0].GetTrueVariable();
            NIType            tupleType = builtTupleOutputVariable.Type;

            Assert.IsTrue(tupleType.IsCluster());
            Assert.IsTrue(tupleType.GetFields().ElementAt(0).GetDataType().IsInt32());
            Assert.IsTrue(tupleType.GetFields().ElementAt(1).GetDataType().IsBoolean());
        }
コード例 #4
0
        bool IDfirNodeVisitor <bool> .VisitBuildTupleNode(BuildTupleNode buildTupleNode)
        {
            TypeVariableReference[] elementTypes = new TypeVariableReference[buildTupleNode.InputTerminals.Count];
            for (int i = 0; i < buildTupleNode.InputTerminals.Count; ++i)
            {
                Terminal inputTerminal = buildTupleNode.InputTerminals[i];
                // TODO: constrain these to be unbounded lifetime
                TypeVariableReference elementType = _typeVariableSet.CreateReferenceToNewTypeVariable();
                _nodeFacade[inputTerminal] = new SimpleTerminalFacade(inputTerminal, elementType);
                elementTypes[i]            = elementType;
            }
            TypeVariableReference tupleType = _typeVariableSet.CreateReferenceToTupleType(elementTypes);
            Terminal outputTerminal         = buildTupleNode.OutputTerminals[0];

            _nodeFacade[outputTerminal] = new SimpleTerminalFacade(outputTerminal, tupleType);
            return(true);
        }
コード例 #5
0
ファイル: TupleTests.cs プロジェクト: rebarlang/rebar
        public void DecomposeTupleElementRefsNode_SetVariableTypes_OutputsAreElementRefTypes()
        {
            DfirRoot       function   = DfirRoot.Create();
            BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);

            ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, false);
            ConnectConstantToInputTerminal(buildTuple.InputTerminals[1], NITypes.Boolean, false);
            var decomposeTuple = new DecomposeTupleNode(function.BlockDiagram, 2, DecomposeMode.Borrow);

            Wire.Create(function.BlockDiagram, buildTuple.OutputTerminals[0], decomposeTuple.InputTerminals[0]);

            RunSemanticAnalysisUpToSetVariableTypes(function);

            VariableReference decomposeOutputVariable0 = decomposeTuple.OutputTerminals[0].GetTrueVariable(),
                              decomposeOutputVariable1 = decomposeTuple.OutputTerminals[1].GetTrueVariable();

            Assert.IsTrue(decomposeOutputVariable0.Type.GetReferentType().IsInt32());
            Assert.IsTrue(decomposeOutputVariable1.Type.GetReferentType().IsBoolean());
        }
コード例 #6
0
        public void BuildTupleAndDecomposeTupleAsMove_Execute_CorrectElementValues()
        {
            DfirRoot       function   = DfirRoot.Create();
            BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);

            ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, 1, false);
            ConnectConstantToInputTerminal(buildTuple.InputTerminals[1], NITypes.Boolean, true, false);
            var decomposeTuple = new DecomposeTupleNode(function.BlockDiagram, 2, DecomposeMode.Move);

            Wire.Create(function.BlockDiagram, buildTuple.OutputTerminals[0], decomposeTuple.InputTerminals[0]);
            FunctionalNode inspect0 = ConnectInspectToOutputTerminal(decomposeTuple.OutputTerminals[0]),
                           inspect1 = ConnectInspectToOutputTerminal(decomposeTuple.OutputTerminals[1]);

            TestExecutionInstance executionInstance = CompileAndExecuteFunction(function);

            byte[] inspectValue = executionInstance.GetLastValueFromInspectNode(inspect0);
            AssertByteArrayIsInt32(inspectValue, 1);
            inspectValue = executionInstance.GetLastValueFromInspectNode(inspect1);
            AssertByteArrayIsBoolean(inspectValue, true);
        }
コード例 #7
0
        public void UnconsumedTupleVariable_AutomaticNodeInsertion_TupleIsMoveDecomposedAndElementsAreDropped()
        {
            DfirRoot       function   = DfirRoot.Create();
            BuildTupleNode buildTuple = new BuildTupleNode(function.BlockDiagram, 2);

            ConnectConstantToInputTerminal(buildTuple.InputTerminals[0], NITypes.Int32, false);
            ConnectConstantToInputTerminal(buildTuple.InputTerminals[1], NITypes.Boolean, false);

            RunCompilationUpToAutomaticNodeInsertion(function);

            DecomposeTupleNode decomposeTuple = AssertDiagramContainsNodeWithSources <DecomposeTupleNode>(function.BlockDiagram, buildTuple.OutputTerminals[0]);

            Assert.AreEqual(DecomposeMode.Move, decomposeTuple.DecomposeMode);
            AssertVariablesReferenceSame(buildTuple.OutputTerminals[0].GetTrueVariable(), decomposeTuple.InputTerminals[0].GetTrueVariable());
            Assert.AreEqual(2, decomposeTuple.OutputTerminals.Count);
            DropNode drop0 = AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, decomposeTuple.OutputTerminals[0]);

            AssertDropInputVariableHasType(drop0, NITypes.Int32);
            DropNode drop1 = AssertDiagramContainsNodeWithSources <DropNode>(function.BlockDiagram, decomposeTuple.OutputTerminals[1]);

            AssertDropInputVariableHasType(drop1, NITypes.Boolean);
        }
コード例 #8
0
 public bool VisitBuildTupleNode(BuildTupleNode buildTupleNode)
 {
     buildTupleNode.InputTerminals.ForEach(ValidateRequiredInputTerminal);
     return(true);
 }
コード例 #9
0
 bool IDfirNodeVisitor <bool> .VisitBuildTupleNode(BuildTupleNode buildTupleNode)
 {
     buildTupleNode.UnifyNodeInputTerminalTypes(_typeUnificationResults);
     return(true);
 }