public static DataStreamValue operator ^(DataStreamValue t1, DataStreamValue t2)
        {
            var result   = new DataStreamValue();
            var table1   = CreateTableByStream(t1.Stream);
            var table2   = CreateTableByStream(t2.Stream);
            var varNames = table1.Keys.Union(table2.Keys);
            var table3   = new Dictionary <string, SemilatticeValue>();

            foreach (var varName in varNames)
            {
                var semilatticeValue = new SemilatticeValue(SemilatticeValueEnum.UNDEF);
                var isFirstVar       = table1.Keys.Contains(varName);
                var isSecondVar      = table2.Keys.Contains(varName);
                if (isFirstVar && !isSecondVar)
                {
                    semilatticeValue = table1[varName] ^ semilatticeValue;
                }
                else if (!isFirstVar && isSecondVar)
                {
                    semilatticeValue = semilatticeValue ^ table2[varName];
                }
                else if (isFirstVar && isSecondVar)
                {
                    semilatticeValue = table1[varName] ^ table2[varName];
                }
                table3.Add(varName, semilatticeValue);
            }
            result.Stream = CreateStreamByTable(table3);
            return(result);
        }
        // Оператор сбора для Потока данных
        public static DataStreamTable operator ^(DataStreamTable t1, DataStreamTable t2)
        {
            var stream1 = new DataStreamValue(DataStreamValue.CreateStreamByTable(t1.Table));
            var stream2 = new DataStreamValue(DataStreamValue.CreateStreamByTable(t2.Table));
            var stream3 = stream1 ^ stream2;

            return(new DataStreamTable(stream3.Stream));
        }
Example #3
0
        // Использует итерационный алгоритм для задачи распространения констант IN[B] = ^P-предшB OUT[P]
        // Принимает два потока firstSet и secondSet, создаёт на их основе DataStreamValue - Поток данных(реализация на множествах для ITA)
        // Далее применяет оператор сбора ^ для Потока данных и возвращает его поток
        public HashSet <SemilatticeStreamValue> Collect(HashSet <SemilatticeStreamValue> firstSet, HashSet <SemilatticeStreamValue> secondSet)
        {
            var dataStreamValue1 = new DataStreamValue(firstSet);
            var dataStreamValue2 = new DataStreamValue(secondSet);
            var dataStreamValue3 = dataStreamValue1 ^ dataStreamValue2;

            return(dataStreamValue3.Stream);
        }
 // Инициализация потоком
 public DataStreamTable(HashSet <SemilatticeStreamValue> stream)
 {
     if (stream == null)
     {
         Table = new Dictionary <string, SemilatticeValue>();
     }
     else
     {
         Table = DataStreamValue.CreateTableByStream(stream);
     }
 }
        static public void TestForStreamValueOperator()
        {
            var set1 = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "12")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.CONST, "14"))
            };
            var dataStreamValue1 = new DataStreamValue(set1);
            var set2             = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "12")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.CONST, "14"))
            };
            var dataStreamValue2 = new DataStreamValue(set2);
            var dataStreamValue3 = dataStreamValue1 ^ dataStreamValue2;
            var table3           = DataStreamValue.CreateTableByStream(dataStreamValue3.Stream);

            Debug.Assert(table3["a"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "12"));
            Debug.Assert(table3["b"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "13"));
            Debug.Assert(table3["c"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "14"));

            set1 = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "12")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.CONST, "14"))
            };
            dataStreamValue1 = new DataStreamValue(set1);
            set2             = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "14")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.UNDEF))
            };
            dataStreamValue2 = new DataStreamValue(set2);
            dataStreamValue3 = dataStreamValue1 ^ dataStreamValue2;
            table3           = DataStreamValue.CreateTableByStream(dataStreamValue3.Stream);
            Debug.Assert(table3["a"] == new SemilatticeValue(SemilatticeValueEnum.NAC));
            Debug.Assert(table3["b"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "13"));
            Debug.Assert(table3["c"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "14"));
        }
        static public void TestForOperator()
        {
            var constDistribOperator = new ConstDistribOperator();
            var set1 = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "12")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.CONST, "14"))
            };
            var set2 = new HashSet <SemilatticeStreamValue>()
            {
                new SemilatticeStreamValue("a", new SemilatticeValue(SemilatticeValueEnum.CONST, "14")),
                new SemilatticeStreamValue("b", new SemilatticeValue(SemilatticeValueEnum.CONST, "13")),
                new SemilatticeStreamValue("c", new SemilatticeValue(SemilatticeValueEnum.UNDEF))
            };
            var set3   = constDistribOperator.Collect(set1, set2);
            var table3 = DataStreamValue.CreateTableByStream(set3);

            Debug.Assert(table3["a"] == new SemilatticeValue(SemilatticeValueEnum.NAC));
            Debug.Assert(table3["b"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "13"));
            Debug.Assert(table3["c"] == new SemilatticeValue(SemilatticeValueEnum.CONST, "14"));
        }
Example #7
0
        // Использует итерационный алгоритм для задачи распространения констант OUT[B] = fB(IN[B])
        // На вход получает _in Stream из которого создается DataStreamValue - Поток данных(реализация на множествах для ITA)
        // Выход новый Stream после изменения значений для присваиваний из tACodeLines
        // где SemilatticeStreamValue - обёртка над именем переменной и её значением из полурешётки констант SemilatticeValue
        // где DataStreamTable - Поток данных(реализация на словаре для реализации алгоритма и более удобной работы)
        public HashSet <SemilatticeStreamValue> Calculate(HashSet <SemilatticeStreamValue> _in, ThreeAddressCode tACodeLines)
        {
            basicBlock = tACodeLines;
            var result           = new HashSet <SemilatticeStreamValue>();
            var dataStreamValue1 = new DataStreamValue(_in);
            var dataStreamValue2 = new DataStreamValue();

            foreach (TacNode node in tACodeLines)
            {
                if (node is TacAssignmentNode assign)
                {
                    var idVar     = assign.LeftPartIdentifier;
                    var value1    = assign.FirstOperand;
                    var operation = assign.Operation;
                    var value2    = assign.SecondOperand;
                    var table     = new DataStreamTable(dataStreamValue1.Stream, dataStreamValue2.Stream);
                    if (IsSimpleAssignNode(assign))
                    {
                        dataStreamValue2.ChangeStreamValue(idVar, table.GetValue(value1));
                    }
                    else
                    {
                        var semVal1 = table.GetValue(value1);
                        var semVal2 = table.GetValue(value2);
                        if (semVal1.TypeValue == SemilatticeValueEnum.CONST && semVal2.TypeValue == SemilatticeValueEnum.CONST)
                        {
                            double val1 = double.Parse(semVal1.ConstValue);
                            double val2 = double.Parse(semVal2.ConstValue);
                            double val3 = 0;
                            switch (operation)
                            {
                            case "+":
                                val3 = val1 + val2;
                                break;

                            case "-":
                                val3 = val1 - val2;
                                break;

                            case "/":
                                val3 = val1 / val2;
                                break;

                            case "*":
                                val3 = val1 * val2;
                                break;
                            }
                            dataStreamValue2.ChangeStreamValue(idVar, new SemilatticeValue(SemilatticeValueEnum.CONST, val3.ToString()));
                        }
                        else if (semVal1.TypeValue == SemilatticeValueEnum.NAC || semVal2.TypeValue == SemilatticeValueEnum.NAC)
                        {
                            dataStreamValue2.ChangeStreamValue(idVar, new SemilatticeValue(SemilatticeValueEnum.NAC));
                        }
                        else
                        {
                            dataStreamValue2.ChangeStreamValue(idVar, new SemilatticeValue(SemilatticeValueEnum.UNDEF));
                        }
                    }
                }
            }
            var dataStreamValue3 = dataStreamValue1 ^ dataStreamValue2;

            return(dataStreamValue3.Stream);
        }