コード例 #1
0
        //biadsy
        public static HashSet <DVariable> GetVars(List <Statement> statements, out HashSet <DVariable> declVars, bool containNonModified)
        {
            DVariableComparer   comparer = new DVariableComparer();
            HashSet <DVariable> vars     = new HashSet <DVariable>(comparer);

            declVars = new HashSet <DVariable>(comparer);
            foreach (var stmt in statements)
            {
                vars.UnionWith(GetVars(stmt, declVars, containNonModified));
            }

            return(vars);
        }
コード例 #2
0
        //biadsy
        public static void GetVariables(List <Statement> statements, List <Statement> otherStatements, out List <DVariable> ins, out List <DVariable> outs, out List <DVariable> toDeclare)
        {
            DVariableComparer   comparer = new DVariableComparer();
            HashSet <DVariable> varsDeclaredInSelectedScope;
            var varsUsedInSelectedScope = GetVars(statements, out varsDeclaredInSelectedScope, true);
            HashSet <DVariable> t;
            var varsModifiedInSelectedScope = GetVars(statements, out t, false).ToList();
            HashSet <DVariable> varsDeclaredAfterScope;
            var varsUsedAfterScope = GetVars(otherStatements, out varsDeclaredAfterScope, true);

            ins = varsUsedInSelectedScope.ToList();
            //          outs = varsModifiedInSelectedScope.Intersect(varsUsedAfterScope, comparer).ToList();
            outs      = varsModifiedInSelectedScope;
            toDeclare = varsDeclaredInSelectedScope.Intersect(varsUsedAfterScope, comparer).ToList();
        }
コード例 #3
0
        private void button_Click(object sender, RoutedEventArgs e)
        {
            this.Hide();
            DVariableComparer comparer = new DVariableComparer();
            List <Statement>  afterSelected;
            List <Statement>  selectedStatements = (List <Statement>)HelpFunctions.GetSelectedStatements();

            if (selectedStatements.Count == 0)
            {
                return;
            }

            //start and end of all relevant stmts and not only the selected ones.
            var start = selectedStatements[0].Tok.pos;

            if (selectedStatements[0] is UpdateStmt)
            {
                if (((UpdateStmt)selectedStatements[0]).Lhss.Count > 0)
                {
                    start = ((UpdateStmt)selectedStatements[0]).Lhss[0].tok.pos;
                }
                else if (((UpdateStmt)selectedStatements[0]).Rhss.Count > 0)
                {
                    if (((UpdateStmt)selectedStatements[0]).Rhss[0] is ExprRhs)
                    {
                        if (((ExprRhs)((UpdateStmt)selectedStatements[0]).Rhss[0]).Expr is ApplySuffix)
                        {
                            start -= ((NameSegment)((ApplySuffix)((ExprRhs)((UpdateStmt)selectedStatements[0]).Rhss[0]).Expr).Lhs).Name.Length;
                        }
                    }
                }
            }
            var end = selectedStatements[selectedStatements.Count - 1].EndTok.pos;

            HelpFunctions.GetSelectedStatements(out afterSelected).ToList();
            List <DVariable> tempIns       = new List <DVariable>();
            List <DVariable> tempOuts      = new List <DVariable>();
            List <DVariable> tempToDeclare = new List <DVariable>();

            HelpFunctions.GetVariables(selectedStatements, afterSelected, out tempIns, out tempOuts, out tempToDeclare);
            tempOuts = tempOuts.Union(tempToDeclare).ToList();
            List <DVariable>            intersect = tempIns.Intersect(tempOuts, comparer).ToList <DVariable>();
            Dictionary <string, string> renameDic = new Dictionary <string, string>();

            foreach (var x in intersect)
            {
                renameDic.Add(x.name, x.name + HelpFunctions.getNextIndex(x.name, tempIns, tempOuts, tempToDeclare));
            }
            List <Formal> ins  = new List <Formal>();
            List <Formal> outs = new List <Formal>();

            foreach (var x in tempIns)
            {
                DVariable temp = new DVariable(x.name, x.type);
                if (renameDic.ContainsKey(temp.name))
                {
                    temp.name = renameDic[temp.name];
                }
                ins.Add(temp.ToFormal());
            }

            foreach (var x in tempOuts)
            {
                outs.Add(x.ToFormal());
            }


            var requires = HelpFunctions.getPreAsserts(selectedStatements);
            var ensures  = HelpFunctions.getPostAsserts(selectedStatements);

            selectedStatements = HelpFunctions.removeReqAndEnsFromStmts(selectedStatements);
            selectedStatements = HelpFunctions.removeVarDeclFromStmts(selectedStatements);
            var method = HelpFunctions.GetCurrentMethod();
            List <MaybeFreeExpression> req = new List <MaybeFreeExpression>();

            foreach (var x in requires)
            {
                //HelpFunctions.renameB(x.Expr, renameDic);
                req.Add(new MaybeFreeExpression(HelpFunctions.renameB(x.Expr, renameDic)));
            }
            List <MaybeFreeExpression> ens = new List <MaybeFreeExpression>();

            foreach (var x in ensures)
            {
                ens.Add(new MaybeFreeExpression(x.Expr));
            }
            var newMethod = new Method(null, this.textBox.Text, false, false, new List <TypeParameter>(), ins, outs, req, new Specification <FrameExpression>(null, null), ens, new Specification <Microsoft.Dafny.Expression>(null, null), null, null, null);
            List <Microsoft.Dafny.Expression> Lhs = new List <Microsoft.Dafny.Expression>();
            List <AssignmentRhs> Rhs = new List <AssignmentRhs>();

            foreach (var x in intersect)
            {
                Lhs.Add(new NameSegment(null, x.name, new List <Type>()));
                Rhs.Add(new ExprRhs(new NameSegment(null, renameDic[x.name], new List <Type>())));
            }
            if (Lhs.Count > 0)
            {
                UpdateStmt correctingNames = new UpdateStmt(null, null, Lhs, Rhs);
                selectedStatements.Insert(0, correctingNames);
            }
            newMethod.Body = new BlockStmt(null, null, selectedStatements);
            // HelpFunctions.renameBody(newMethod.Body, new Dictionary<string, string>());///debug purposes only!!!!
            string signature = "aklt 5ra";
            string body      = "ya m3lm";

            try
            {
                signature = Printer.MethodSignatureToString(newMethod);
                body      = Printer.StatementToString(newMethod.Body);
            }
            catch (System.Exception ee)
            {
            }
            // Place the new method implementation in the code.
            int       position = HelpFunctions.GetCurrentMethod().BodyEndTok.pos + 1;
            ITextEdit edit     = HelpFunctions.GetWpfView().TextBuffer.CreateEdit();

            edit.Insert(position, "\r\n\r\n" + signature + "\r\n" + body);

            string methodcall = HelpFunctions.generateMethodCall(newMethod, tempIns, tempOuts);

            //DTE dte = (DTE)ExtractMethodPackage.GetGlobalService(typeof(DTE));
            //var selection = (EnvDTE.TextSelection)dte.ActiveDocument.Selection;

            edit.Delete(start, end - start + 1);
            edit.Insert(start, HelpFunctions.toDeclareString(tempToDeclare) + methodcall);
            edit.Apply();
            //selection.Text = methodcall;
        }
コード例 #4
0
        //biadsy
        private static HashSet <DVariable> GetVars(Microsoft.Dafny.Expression exp, HashSet <DVariable> declaredVars)
        {
            DVariableComparer   comparer = new DVariableComparer();
            HashSet <DVariable> vars     = new HashSet <DVariable>(comparer);

            if (exp is SeqSelectExpr)
            {
                var expr = exp as SeqSelectExpr;
                vars.UnionWith(GetVars(expr.Seq, declaredVars));
                vars.UnionWith(GetVars(expr.E0, declaredVars));
                vars.UnionWith(GetVars(expr.E1, declaredVars));
            }
            else if (exp is NameSegment)
            {
                var       expr = exp as NameSegment;
                DVariable var  = new DVariable(expr.Name, expr.Type);
                if (!declaredVars.Contains(var))
                {
                    vars.Add(var);
                }
            }
            else if (exp is ApplySuffix)
            {
                var expr = exp as ApplySuffix;
                foreach (var arg in expr.Args)
                {
                    vars.UnionWith(GetVars(arg, declaredVars));
                }
            }
            else if (exp is BinaryExpr)
            {
                var expr = exp as BinaryExpr;
                vars.UnionWith(GetVars(expr.E0, declaredVars));
                vars.UnionWith(GetVars(expr.E1, declaredVars));
            }
            else if (exp is UnaryOpExpr)
            {
                var expr = exp as UnaryOpExpr;
                vars.UnionWith(GetVars(expr.E, declaredVars));
            }
            else if (exp is ParensExpression)
            {
                var expr = exp as ParensExpression;
                vars.UnionWith(GetVars(expr.E, declaredVars));
            }
            else if (exp is ChainingExpression)
            {
                var expr = exp as ChainingExpression;
                vars.UnionWith(GetVars(expr.E, declaredVars));
            }
            else if (exp is SeqDisplayExpr)
            {
                var expr = exp as SeqDisplayExpr;
                foreach (var arg in expr.Elements)
                {
                    vars.UnionWith(GetVars(arg, declaredVars));
                }
            }
            else if (exp is Microsoft.Dafny.ForallExpr)
            {
                var expr       = exp as Microsoft.Dafny.ForallExpr;
                var newDecVars = new HashSet <DVariable>(declaredVars, comparer);
                if (expr.BoundVars != null)
                {
                    foreach (var bvar in expr.BoundVars)
                    {
                        DVariable dvar = new DVariable(bvar.DisplayName, bvar.Type);
                        newDecVars.Add(dvar);
                    }
                }
                vars.UnionWith(GetVars(expr.Term, newDecVars));
            }
            return(vars);
        }
コード例 #5
0
        //biadsy
        private static HashSet <DVariable> GetVars(Statement stmt, HashSet <DVariable> declaredVars, bool containNonModified)
        {
            DVariableComparer   comparer = new DVariableComparer();
            HashSet <DVariable> usedVars = new HashSet <DVariable>(comparer);

            if (stmt is UpdateStmt)
            {
                var ustmt = (UpdateStmt)stmt;
                foreach (var ls in ustmt.Lhss)
                {
                    usedVars.UnionWith(GetVars(ls, declaredVars));
                }
                if (containNonModified)
                {
                    foreach (var rs in ustmt.Rhss)
                    {
                        var exp = rs as ExprRhs;
                        usedVars.UnionWith(GetVars(exp.Expr, declaredVars));
                    }
                }
            }
            else if (stmt is AssertStmt && containNonModified)
            {
                var asrt = stmt as AssertStmt;
                usedVars.UnionWith(GetVars(asrt.Expr, declaredVars));
                usedVars.UnionWith(GetVars(asrt.Proof, declaredVars, containNonModified));
            }
            else if (stmt is WhileStmt)
            {
                var wstmt = stmt as WhileStmt;
                usedVars.UnionWith(GetVars(wstmt.Body, declaredVars, containNonModified));
                foreach (var exp in wstmt.Decreases.Expressions)
                {
                    usedVars.UnionWith(GetVars(exp, declaredVars));
                }
                usedVars.UnionWith(GetVars(wstmt.Guard, declaredVars));
                foreach (var exp in wstmt.Invariants)
                {
                    usedVars.UnionWith(GetVars(exp.E, declaredVars));
                }
            }
            else if (stmt is BlockStmt)
            {
                var stmts = stmt as BlockStmt;
                foreach (var bodyStmt in stmts.Body)
                {
                    usedVars.UnionWith(GetVars(bodyStmt, declaredVars, containNonModified));
                }
            }
            else if (stmt is CalcStmt)
            {
                var calcstmt = stmt as CalcStmt;
                foreach (var x in calcstmt.Lines)
                {
                    usedVars.UnionWith(GetVars(x, declaredVars));
                }
                foreach (var x in calcstmt.Hints)
                {
                    usedVars.UnionWith(GetVars(x, declaredVars, containNonModified));
                }
                foreach (var x in calcstmt.Steps)
                {
                    usedVars.UnionWith(GetVars(x, declaredVars));
                }
            }
            else if (stmt is VarDeclStmt)
            {
                var decl = stmt as VarDeclStmt;
                usedVars.UnionWith(GetVars(decl.Update, declaredVars, containNonModified));
                if (decl.Locals != null)
                {
                    foreach (var v in decl.Locals)
                    {
                        DVariable dvar = new DVariable(v.DisplayName, v.Type);
                        declaredVars.Add(dvar);
                    }
                }
            }
            else if (stmt is IfStmt)
            {
                var ifstmt = stmt as IfStmt;
                usedVars.UnionWith(GetVars(ifstmt.Guard, declaredVars));
                usedVars.UnionWith(GetVars(ifstmt.Thn, declaredVars, containNonModified));
                usedVars.UnionWith(GetVars(ifstmt.Els, declaredVars, containNonModified));
            }
            else if (stmt is PrintStmt)
            {
                var pstmt = stmt as PrintStmt;
                foreach (var arg in pstmt.Args)
                {
                    usedVars.UnionWith(GetVars(arg, declaredVars));
                }
            }

            return(usedVars);
        }