Ejemplo n.º 1
0
        public static List <CompoundErrorInformation> GenerateErrorInfoList(ProofState state, string msg = "")
        {
            List <CompoundErrorInformation> errs = new List <CompoundErrorInformation>();
            //resolving errors: moving those errors to error info
            var report = state.GetErrHandler().Reporter;

            if (report.Count(ErrorLevel.Error) != 0)
            {
                foreach (var errMsg in report.AllMessages[ErrorLevel.Error])
                {
                    AddErrorInfo(state, errMsg.message);
                }
            }
            // verification error + resolving errors
            var l = state.GetErrHandler().ErrorList;

            Console.WriteLine("\n================ Tactic exception: ================");

            if (l != null && l.Count > 0)
            {
                foreach (var err in l)
                {
                    errs.Add(new CompoundErrorInformation(msg, err, state));
                    Console.WriteLine(err.FullMsg);
                }
            }
            var errInfo = new CompoundErrorInformation(msg, state);

            Console.WriteLine(errInfo.FullMsg);
            Console.WriteLine("================ End of tactic exception ================");
            errs.Add(errInfo);

            return(errs);
        }
Ejemplo n.º 2
0
        internal static void AddErrorInfo(ProofState state, string msg)
        {
            var errInfo = new CompoundErrorInformation(msg, state);

            if (state.GetErrHandler().ErrorList == null)
            {
                state.GetErrHandler().ErrorList = new List <ErrorInformation>();
            }
            state.GetErrHandler().ErrorList.Add(errInfo);
        }
Ejemplo n.º 3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="rootState"></param>
        /// <param name="errDelegate"></param> to report err back to GUI
        /// <returns></returns>
        internal static IEnumerable <ProofState> GenerateSolution(ProofState rootState, ErrorReporterDelegate errDelegate)
        {
            var               stack      = new Stack <IEnumerator <ProofState> >();
            ProofState        lastSucc   = null;                                           // the last verified state, for recovering over-backtracking
            var               discarded  = new List <Tuple <ProofState, VerifyResult> >(); // failed ps and its verified status
            List <ProofState> proofState = new List <ProofState> ()
            {
                rootState
            };
            var rootBranches = rootState.EvalStep();

            if (rootBranches == null)
            {
                yield break;
            }
            stack.Push(rootBranches.GetEnumerator());

            IEnumerator <ProofState> enumerator = null;

            List <int> backtrackList = null;

            while (stack.Count > 0)
            {
                bool wasNull = false;
                if (enumerator != null)
                {
                    try {
                        if (enumerator.Current == null)
                        {
                            wasNull = true;
                        }
                    } catch {
                        wasNull = true;
                    }
                }

                if (enumerator == null || !enumerator.MoveNext())
                {
                    // check if current is valid, and the enumerator is empty when current is invalid and MoveNext is null
                    if (enumerator != null && wasNull)
                    {
                        //Console.WriteLine("Null eval result is detected !");
                        foreach (var state in proofState)
                        {
                            discarded.Add(new Tuple <ProofState, VerifyResult>(state, VerifyResult.Unresolved));
                        }
                    }

                    enumerator = stack.Pop();
                    if (!enumerator.MoveNext())
                    {
                        continue;
                    }
                }

                var stateCount = 0;
                proofState.Clear();
                while (stateCount < VerifyNProofState)
                {
                    var current = enumerator.Current;
                    proofState.Add(current);
                    stateCount++;
                    if (backtrackList != null)
                    {
                        current.SetBackTrackCount(backtrackList);
                    }
                    if (current.NeedVerify && proofState[0].GetVerifyN() > 1)
                    {
                        current.DecreaseVerifyN();
                        current.NeedVerify = false;
                    }
                    if (!enumerator.MoveNext())
                    {
                        break;
                    }
                }

                //should at least one state in the list, use [0] as a typical state;
                var rep = proofState[0];
                backtrackList = rep.GetBackTrackCount();

                List <VerifyResult> ress     = null;
                List <bool>         returned = null;

                //check if any new added coded reuqires to call verifier, or reach the last line of code
                if ((rep.NeedVerify && rep.GetVerifyN() == 1) || rep.IsCurFrameEvaluated())
                {
                    foreach (var s in proofState)
                    {
                        s.ResetVerifyN();
                        s.NeedVerify = false;
                    }

                    bool backtracked = false;
                    ress     = VerifyState(proofState);
                    returned = new List <bool>();

                    for (var i = 0; i < ress.Count; i++)
                    {
                        var res = ress[i];
                        var ret = false;
                        switch (res)
                        {
                        case VerifyResult.Verified:
                            //check if the frame are evaluated, as well as requiests for backtraking
                            proofState[i].MarkCurFrameAsTerminated(true, out backtracked);
                            if (backtracked)
                            {
                                lastSucc = proofState[i];
                                discarded.Add(new Tuple <ProofState, VerifyResult>(proofState[i], VerifyResult.Backtracked));
                            }

                            if (proofState[i].IsTerminated())
                            {
                                ret = true;
                                yield return(proofState[i]);
                            }
                            returned.Add(ret);
                            break;

                        case VerifyResult.Failed:
                            if (proofState[i].IsCurFrameEvaluated())
                            {
                                proofState[i].MarkCurFrameAsTerminated(false, out backtracked);
                                if (backtracked)
                                {
                                    lastSucc = proofState[i];
                                    discarded.Add(new Tuple <ProofState, VerifyResult>(proofState[i], VerifyResult.Backtracked));
                                }
                                if (proofState[i].IsTerminated())
                                {
                                    ret = true;
                                    yield return(proofState[i]);
                                }
                            }
                            returned.Add(ret);
                            break;

                        case VerifyResult.Unresolved:
                            //Console.WriteLine("in unresolved");
                            discarded.Add(new Tuple <ProofState, VerifyResult>(proofState[i], VerifyResult.Unresolved));
                            //discard current branch if fails to resolve
                            returned.Add(false);
                            continue;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }
                    }
                }

                /*
                 * when failed, check if this method is evaluated , i.e. all tstmt are evalauted,
                 * if so, do nothing will dischard this branch and continue with the next one
                 * otherwise, continue to evaluate the next stmt
                 */
                if (!rep.IsCurFrameEvaluated())
                {
                    //push the current one to the stack
                    stack.Push(enumerator);
                    //move to the next stmt
                    for (var i = 0; i < proofState.Count; i++)
                    {
                        if (returned == null || !returned[i])
                        {
                            stack.Push(proofState[i].EvalStep().GetEnumerator());
                        }
                    }
                    enumerator = stack.Pop();
                }
                else
                {
                    backtrackList = rep.GetBackTrackCount(); // update the current bc count to the list
                    for (var i = 0; i < proofState.Count; i++)
                    {
                        if (returned == null || !returned[i])
                        {
                            if (proofState[i].InAsserstion)
                            {
                                proofState[i].GetErrHandler().ErrType = TacticBasicErr.ErrorType.Assertion;
                                var patchRes = proofState[i].ApplyPatch();
                                if (patchRes != null)
                                {
                                    stack.Push(enumerator);
                                    enumerator = patchRes.GetEnumerator();
                                }
                            }
                            else
                            {
                                proofState[i].GetErrHandler().ErrType = TacticBasicErr.ErrorType.NotProved;
                            }
                            discarded.Add(new Tuple <ProofState, VerifyResult>(proofState[i], VerifyResult.Failed));
                        }
                    }
                }
            }
            //check if over-backchecked
            if (backtrackList != null && backtrackList.Exists(x => x > 0))
            {
                if (lastSucc == null)
                {
                    Console.WriteLine("!!! No more branch for the request of " + (backtrackList.Last() + 1) +
                                      "backtracking, and no branch.");
                }
                else
                {
                    Console.WriteLine("!!! No more branch for the request of " + lastSucc.GetOrignalTopBacktrack() +
                                      ", remaining " +
                                      (backtrackList.Last() + 1 > lastSucc.GetOrignalTopBacktrack()
                              ? lastSucc.GetOrignalTopBacktrack()
                              : backtrackList.Last() + 1) + " requests, return the last one.");
                    yield return(lastSucc);
                }
            }
            else
            {
                // no result is successful
                ProofState s0;
                if (discarded.Count > 0)
                {
                    s0 = discarded[discarded.Count - 1].Item1;
                    //s0.GetErrHandler().ExceptionReport();
                }
                else
                {
                    s0 = rootState;
                }
                s0.ReportTacticError(s0.TopLevelTacApp.Tok,
                                     "No solution is found. \n The error message from the last failed branch: ");
                var errs = CompoundErrorInformation.GenerateErrorInfoList(s0);
                if (errDelegate != null)
                {
                    foreach (var err in errs)
                    {
                        errDelegate(err);
                    }
                }
            }
        }
Ejemplo n.º 4
0
        public static IEnumerable <ProofState> EvalTopLevelTactic(ProofState state, Dictionary <IVariable, Type> variables,
                                                                  Statement tacticApplication, ApplySuffix aps, ErrorReporterDelegate errorDelegate, bool ifPartial)
        {
            Contract.Requires <ArgumentNullException>(Tcce.NonNull(variables));
            Contract.Requires <ArgumentNullException>(Tcce.NonNull(tacticApplication));
            Contract.Requires <ArgumentNullException>(state != null, "state");
            Contract.Requires(tacticApplication == null ||
                              tacticApplication is UpdateStmt || tacticApplication is InlineTacticBlockStmt);

            IEnumerable <ProofState> branches;

            if (state.InitState(tacticApplication, aps, variables, ifPartial) == false)
            {
                return(null);
            }

#if !TACNY_DEBUG
            try {
#endif
            if (state.GetErrHandler().Reporter.Count(ErrorLevel.Error) != 0)
            {
                var errs = CompoundErrorInformation.GenerateErrorInfoList(state);
                if (errorDelegate != null)
                {
                    foreach (var err in errs)
                    {
                        errorDelegate(err);
                    }
                }

                return(null);
            }
            branches = GenerateSolution(state, errorDelegate);

      #if !TACNY_DEBUG
        }

        catch (Exception e) {
            String msg;
            List <CompoundErrorInformation> errs;
            try {
                msg  = "Tactic unknown exception: " + e.Message;
                errs = CompoundErrorInformation.GenerateErrorInfoList(state, msg);
            } catch (Exception) {
                msg  = "Tactic exception";
                errs = new List <CompoundErrorInformation>();
            }

            if (errorDelegate != null)
            {
                foreach (var err in errs)
                {
                    errorDelegate(err);
                }
            }
            return(null);
        }
#endif

            return(branches);
        }