Exemple #1
0
        public void SerializeOverlapped(Stream stream, Epa e1, Epa e2)
        {
            Contract.Requires(stream != null && stream.CanWrite);
            Contract.Requires(e1 != null && e2 != null);
            Contract.Requires(Contract.ForAll(e2.Transitions, t => e1.Transitions.Any(t2 => t2.Equals(t))), "e2 is subgraph of e1");

            var graph = new Graph
            {
                Attr =
                {
                    OptimizeLabelPositions = true,
                    LayerDirection         = LayerDirection.LR
                }
            };

            epa = e1;

            foreach (var s in e1.States)
            {
                AddState(s, graph);
            }

            foreach (var t in e1.Transitions)
            {
                var overlapped = e2.Transitions.Any(t2 => t2.Equals(t));
                AddTransitionOverlapped(t, graph, overlapped);
            }

            RenderGraph(stream, graph);
        }
Exemple #2
0
        public IStatement GenerateIf(FieldDefinition field, List <int> toStateIds, Epa epa, Dictionary <State, int> stateNumberMap)
        {
            var toStates = new List <State>();

            foreach (var kvp in stateNumberMap)
            {
                var id    = kvp.Value;
                var state = kvp.Key;
                if (toStateIds.Contains(id))
                {
                    toStates.Add(state);
                }
            }

            var conditions = GenerateStatesConditions(toStates);

            var stmt = new AssignmentGenerator().GenerateAssign(field, toStateIds[0]);

            for (var i = 1; i < toStateIds.Count; ++i)
            {
                stmt = new ConditionalStatement
                {
                    Condition   = conditions[i],
                    TrueBranch  = new AssignmentGenerator().GenerateAssign(field, toStateIds[i]),
                    FalseBranch = stmt
                };
            }
            return(stmt);
        }
Exemple #3
0
        protected void SerializeStates(Epa epa, XmlWriter writer)
        {
            Contract.Requires(epa != null && epa.Type != null);
            Contract.Requires(writer != null);

            var states = new List <State>(from s in epa.States orderby s.Name select s);

            foreach (var s in states)
            {
                writer.WriteStartElement("state");
                writer.WriteAttributeString("name", s.Name);

                var enabledActions = new List <Action>(from a in s.EnabledActions orderby a.Name select a);
                foreach (var a in enabledActions)
                {
                    writer.WriteStartElement("enabled_label");
                    writer.WriteAttributeString("name", a.Name);
                    writer.WriteEndElement();
                }

                SerializeTransitions(epa, writer, s);

                writer.WriteEndElement(); // State
            }
        }
Exemple #4
0
        protected void OnInitialStateAdded(object sender, IEpaBuilder epaBuilder)
        {
            generatedEpa = epaBuilder.Build();
            var stateAddedEventArg = new StateAddedEventArgs(epaBuilder.Type, epaBuilder, generatedEpa.Initial);

            StateAdded(sender, stateAddedEventArg);
        }
Exemple #5
0
        protected static void SaveEpasAsImages(Epa epa, DirectoryInfo outputDir)
        {
            Contract.Requires(epa != null);
            Contract.Requires(outputDir != null);

            SaveEpaAs <EpaBinarySerializer>(epa, outputDir, "png");
        }
Exemple #6
0
        protected static void SaveEpasAsXml(Epa epa, DirectoryInfo outputDir)
        {
            Contract.Requires(epa != null);
            Contract.Requires(outputDir.Exists);

            SaveEpaAs <EpaXmlSerializer>(epa, outputDir, "xml");
        }
Exemple #7
0
        public void Serialize(Stream stream, Epa epa)
        {
            Contract.Requires(stream.CanWrite);
            Contract.Requires(epa != null);

            throw new NotImplementedException();
        }
Exemple #8
0
        public void Serialize(Stream stream, Epa epa)
        {
            this.epa = epa;

            var graph = new Graph
            {
                Attr =
                {
                    OptimizeLabelPositions = true,
                    LayerDirection         = LayerDirection.LR
                }
            };

            foreach (var s in epa.States)
            {
                AddState(s, graph);
            }

            foreach (var t in epa.Transitions)
            {
                AddTransition(t, graph);
            }

            RenderGraph(stream, graph);
        }
Exemple #9
0
        protected static IAssembly GenerateStrengthenedAssembly(Epa epa, CciAssembly assembly)
        {
            Contract.Requires(epa != null);
            Contract.Requires(assembly != null);

            System.Console.WriteLine("Generating strengthened output assembly");
            var instrumenter = new Instrumenter.Instrumenter();

            return(instrumenter.InstrumentType(assembly, epa));
        }
Exemple #10
0
        protected static void SaveEpaAs <T>(Epa epa, DirectoryInfo outputDir, string fileNameExtension) where T : ISerializer, new()
        {
            var typeName     = epa.Type.ToString().Replace('.', '_');
            var safeFileName = GetSafeFilename(string.Format("{0}\\{1}.{2}", outputDir.FullName, typeName, fileNameExtension));

            using (var stream = File.Create(safeFileName))
            {
                new T().Serialize(stream, epa);
            }
        }
Exemple #11
0
        public TypeAnalysisResult(Epa epa, TimeSpan totalTime, int generatedQueriesCount, int unprovenQueriesCount)
        {
            Contract.Requires(epa != null);
            Contract.Requires(totalTime != null);
            Contract.Requires(generatedQueriesCount >= 0);
            Contract.Requires(unprovenQueriesCount >= 0);
            Contract.Requires(unprovenQueriesCount <= generatedQueriesCount);

            this.epa                   = epa;
            this.totalTime             = totalTime;
            this.generatedQueriesCount = generatedQueriesCount;
            this.unprovenQueriesCount  = unprovenQueriesCount;
        }
Exemple #12
0
        protected void SerializeActions(Epa epa, XmlWriter writer)
        {
            Contract.Requires(epa != null);
            Contract.Requires(writer != null);

            var actions = new HashSet <Action>(from t in epa.Transitions orderby t.Action.Name select t.Action);

            foreach (var a in actions)
            {
                writer.WriteStartElement("label");
                writer.WriteAttributeString("name", a.Name);
                writer.WriteEndElement();
            }
        }
Exemple #13
0
        protected void GenerateAssembly(FileInfo outputFile, Epa epa)
        {
            UpdateStatus("Generating strengthened output assembly {0}...", outputFile);

            try
            {
                var instrumenter         = new Instrumenter.Instrumenter();
                var strengthenedAssembly = instrumenter.InstrumentType(model.InputAssembly as CciAssembly, epa) as CciAssembly;
                new CciAssemblyPersister().Save(strengthenedAssembly, outputFile.FullName);
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
            UpdateStatus("Done!", outputFile);
        }
Exemple #14
0
        protected void SerializeTransitions(Epa epa, XmlWriter writer, State s)
        {
            Contract.Requires(epa != null && epa.Type != null);
            Contract.Requires(writer != null);
            Contract.Requires(s != null);

            var transitionsFromState = epa.Transitions.Where(t => t.SourceState.Equals(s));
            var transitions          = (from t in transitionsFromState select t).OrderBy(x => x.TargetState.Name).ThenByDescending(x => x.Action.Name);

            foreach (var t in transitions)
            {
                writer.WriteStartElement("transition");
                writer.WriteAttributeString("destination", t.TargetState.Name);
                writer.WriteAttributeString("label", t.Action.Name);
                writer.WriteAttributeString("uncertain", t.IsUnproven.ToString().ToLower());
                writer.WriteAttributeString("violates_invariant", "false"); //Contractor.NET does not support this attribute
                writer.WriteEndElement();
            }
        }
Exemple #15
0
        protected void ExportGraph(FileInfo outputFile, Epa epa, ISerializer serializer)
        {
            Contract.Requires(outputFile != null);
            Contract.Requires(epa != null);
            Contract.Requires(serializer != null);

            UpdateStatus("Exporting graph to {0}...", outputFile);
            try
            {
                using (var fileStream = File.Create(outputFile.FullName))
                {
                    serializer.Serialize(fileStream, epa);
                }
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
            UpdateStatus("Done!", outputFile);
        }
Exemple #16
0
        public void Serialize(Stream stream, Epa epa)
        {
            var settings = new XmlWriterSettings
            {
                CloseOutput = false,
                Indent      = true
            };

            using (var writer = XmlWriter.Create(stream, settings))
            {
                writer.WriteStartDocument();

                writer.WriteStartElement("abstraction");
                writer.WriteAttributeString("initial_state", epa.Initial.Name);
                writer.WriteAttributeString("input_format", "code-with-pre");
                writer.WriteAttributeString("name", epa.Type.Name);

                SerializeActions(epa, writer);
                SerializeStates(epa, writer);

                writer.WriteEndDocument();
            }
        }
Exemple #17
0
 public SwitchGenerator(Epa epa, Dictionary <State, int> stateNumberMap)
 {
     this.epa            = epa;
     this.stateNumberMap = stateNumberMap;
 }
Exemple #18
0
 protected void OnTransitionAdded(object sender, TransitionAddedEventArgs e)
 {
     generatedEpa = e.EpaBuilder.Build();
     TransitionAdded(sender, e);
 }
Exemple #19
0
        public IAssembly InstrumentType(CciAssembly assembly, Epa epa)
        {
            Contract.Requires(assembly != null);
            Contract.Requires(epa != null);
            Contract.Requires(assembly.Types().Contains(epa.Type));

            // Clone assembly
            var host   = CciHostEnvironment.GetInstance();
            var module = new CodeAndContractDeepCopier(host).Copy(assembly.Module);

            var contractExtractor = host.GetContractExtractor(module.UnitIdentity);
            var contractProvider  = new AggregatingContractProvider(contractExtractor);

            var preconditions = new Dictionary <string, List <IPrecondition> >();

            var actions = new List <Action>(from transition in epa.Transitions.GroupBy(t => t.Action) select transition.Key);

            Contract.Assert(actions.Any());

            foreach (var action in actions)
            {
                // TODO (lleraromero): Es necesario? NullObject Pattern?
                var mc = action.Contract as MethodContract;
                if (mc == null)
                {
                    continue;
                }

                preconditions.Add(action.Name, action.Contract.Preconditions.ToList());
            }

            var typeDefinition    = epa.Type;
            var cciTypeDefinition =
                module.AllTypes.First(
                    t => TypeHelper.GetTypeName(t, NameFormattingOptions.UseGenericTypeNameSuffix).Equals(typeDefinition.Name)) as NamedTypeDefinition;

            Contract.Assert(cciTypeDefinition != null);

            var typeContract = RemoveInvariantMethods(typeDefinition, cciTypeDefinition);

            // Add a field to represent the state
            var field = CreateStateField(cciTypeDefinition, typeContract);

            cciTypeDefinition.Fields.Add(field);

            // Associate type contract to the contract provider
            contractProvider.AssociateTypeWithContract(cciTypeDefinition, typeContract);

            // Create Ids
            var stateNumberMap = new Dictionary <State, int>();

            foreach (var state in epa.States)
            {
                stateNumberMap.Add(state, stateNumberMap.Keys.Count);
            }

            foreach (var action in actions)
            {
                // voy a agrupar las transiciones que usan esta accion por sourceState.Id
                // transitions = Dicc<int, List<int>> o sea: "Dicc<from, List<to>>"
                var transitionsUsingAction = new List <Transition>(from t in epa.Transitions where t.Action.Equals(action) select t);
                var transitionsSourceIds   = new HashSet <int>(from t in transitionsUsingAction select stateNumberMap[t.SourceState]).Distinct();

                var transitions = new Dictionary <int, List <int> >();
                foreach (var t in transitionsUsingAction)
                {
                    var sourceStateId = stateNumberMap[t.SourceState];
                    if (!transitions.ContainsKey(sourceStateId))
                    {
                        transitions.Add(sourceStateId, new List <int>());
                    }

                    var targetStateId = stateNumberMap[t.TargetState];
                    transitions[sourceStateId].Add(targetStateId);
                }

                var methodContract   = action.Contract as MethodContract ?? new MethodContract();
                var methodDefinition = cciTypeDefinition.Methods.First(m => m.GetUniqueName().Equals(action.Method.GetUniqueName()));

                BlockStatement actionBodyBlock = null;
                if (methodDefinition.Body is SourceMethodBody)
                {
                    var actionBody = (SourceMethodBody)methodDefinition.Body;
                    actionBodyBlock = actionBody.Block as BlockStatement;
                }
                else if (methodDefinition.Body is Microsoft.Cci.MutableCodeModel.SourceMethodBody)
                {
                    var actionBody = (Microsoft.Cci.MutableCodeModel.SourceMethodBody)methodDefinition.Body;
                    actionBodyBlock = actionBody.Block as BlockStatement;
                }
                Contract.Assert(actionBodyBlock != null);

                //Por tratarse de un constructor insertamos en 1 porque en 0 esta base..ctor()
                var insertAtIndex = methodDefinition.IsConstructor ? 1 : 0;

                // CodeContracts no permite utilizar 'this' en los requires de los constructores
                if (!methodDefinition.IsConstructor)
                {
                    var pre = new PreconditionGenerator().GeneratePrecondition(field, transitions.Keys.ToList());
                    methodContract.Preconditions.Add(pre);
                }

                var posts = new PostconditionGenerator(stateNumberMap[epa.Initial]).GeneratePostconditions(field, transitions);
                methodContract.Postconditions.AddRange(posts);

                // Associate contract
                contractProvider.AssociateMethodWithContract(methodDefinition, methodContract);

                var stmt = new SwitchGenerator(epa, stateNumberMap).GenerateSwitch(field, transitions);

                // Se actualiza el $state en un finally porque los if de adentro del switch tienen que ser ejecutados despues del cuerpo de este metodo
                var stmtsCount = actionBodyBlock.Statements.Count - insertAtIndex;
                var tryBlock   = new BlockStatement();
                var bodyStmts  = new List <IStatement>(actionBodyBlock.Statements.GetRange(insertAtIndex, stmtsCount));
                tryBlock.Statements.AddRange(bodyStmts);

                var finallyBlock = new BlockStatement();
                finallyBlock.Statements.Add(stmt);

                var tryStmt = new TryCatchFinallyStatement
                {
                    TryBody     = tryBlock,
                    FinallyBody = finallyBlock
                };

                actionBodyBlock.Statements.RemoveRange(insertAtIndex, stmtsCount);
                actionBodyBlock.Statements.Insert(insertAtIndex, tryStmt);
            }

            return(new CciAssembly(module, contractProvider));
        }