public CciAssembly Rewrite(CciAssembly assembly)
{
ISourceLocationProvider sourceLocationProvider = GetPdbReader(assembly.Module);
var trans = new ContractRewriter(host, assembly.ContractProvider, sourceLocationProvider);
var newModule = trans.Rewrite(assembly.Module) as Module;
return(new CciAssembly(newModule, assembly.ContractProvider));
}
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));
}
public CorralAnalyzerFactory(string defaultArgs, DirectoryInfo workingDir, CciQueryGenerator queryGenerator, CciAssembly inputAssembly,
string inputFileName, ITypeDefinition typeToAnalyze, CancellationToken token)
{
this.defaultArgs = defaultArgs;
this.workingDir = workingDir;
this.queryGenerator = queryGenerator;
this.inputAssembly = inputAssembly;
this.inputFileName = inputFileName;
this.typeToAnalyze = typeToAnalyze;
this.token = token;
generatedQueriesCount = 0;
unprovenQueriesCount = 0;
}
public CodeContractsAnalyzer(DirectoryInfo workingDir, string ccCheckDefaultArgs, string libPaths, CciQueryGenerator queryGenerator,
CciAssembly inputAssembly, string inputFileName, ITypeDefinition typeToAnalyze, CancellationToken token)
{
this.workingDir = workingDir;
this.ccCheckDefaultArgs = ccCheckDefaultArgs;
this.libPaths = libPaths;
this.queryGenerator = queryGenerator;
this.inputAssembly = inputAssembly;
this.typeToAnalyze = typeToAnalyze;
this.inputFileName = inputFileName;
this.token = token;
generatedQueriesCount = 0;
unprovenQueriesCount = 0;
}
protected static TypeAnalysisResult GenerateEpa(CciAssembly inputAssembly, ITypeDefinition typeToAnalyze, Options options)
{
System.Console.WriteLine("Starting analysis for type {0}", typeToAnalyze);
var cancellationSource = new CancellationTokenSource();
var workingDir = CreateOrCleanupWorkingDirectory();
var queryGenerator = new CciQueryGenerator();
IAnalyzerFactory analyzerFactory;
switch (options.Backend)
{
case "CodeContracts":
var codeContracts = Environment.GetEnvironmentVariable("CodeContractsInstallDir");
if (string.IsNullOrEmpty(codeContracts))
{
var msg = new StringBuilder();
msg.AppendLine("The environment variable %CodeContractsInstallDir% does not exist.");
msg.AppendLine("Please make sure that Code Contracts is installed correctly.");
msg.AppendLine("This might be because the system was not restarted after Code Contracts installation.");
throw new DirectoryNotFoundException(msg.ToString());
}
var cccheckArgs = ConfigurationManager.AppSettings["CccheckArgs"];
Contract.Assert(cccheckArgs != null);
var cccheck = new FileInfo(ConfigurationManager.AppSettings["CccheckFullName"]);
Contract.Assert(cccheck.Exists);
analyzerFactory = new CodeContractsAnalyzerFactory(workingDir, cccheckArgs, string.Empty, queryGenerator, inputAssembly,
options.InputAssembly,
typeToAnalyze, cancellationSource.Token);
break;
case "Corral":
var corralDefaultArgs = ConfigurationManager.AppSettings["CorralDefaultArgs"];
Contract.Assert(corralDefaultArgs != null);
analyzerFactory = new CorralAnalyzerFactory(corralDefaultArgs, workingDir, queryGenerator, inputAssembly,
options.InputAssembly, typeToAnalyze, cancellationSource.Token);
break;
default:
throw new NotSupportedException();
}
var generator = new EpaGenerator(analyzerFactory, options.Cutter);
var epaBuilder = new EpaBuilder(typeToAnalyze);
var epaBuilderObservable = new ObservableEpaBuilder(epaBuilder);
epaBuilderObservable.TransitionAdded += OnTransitionAdded;
TypeAnalysisResult analysisResult;
if (!options.Methods.Equals("All"))
{
var selectedMethods = options.Methods.Split(';');
analysisResult = generator.GenerateEpa(typeToAnalyze, selectedMethods, epaBuilderObservable).Result;
}
else
{
analysisResult = generator.GenerateEpa(typeToAnalyze, epaBuilderObservable).Result;
}
return(analysisResult);
}
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));
}
