public override int CompareTo(Cil.ISingleEntrySubGraph other)
{
PartialCFGBlockLogicalConstruct otherPartial = (other as ILogicalConstruct).FirstBlock as PartialCFGBlockLogicalConstruct;
if(otherPartial != null)
{
if(this.Index == otherPartial.Index)
{
if(this == otherPartial)
{
return 0;
}
PartialCFGBlockLogicalConstruct currentPartial = this;
while (currentPartial != null && currentPartial.Index == this.Index)
{
if(currentPartial == otherPartial)
{
return -1;
}
if(currentPartial.CFGSuccessors.Count != 1)
{
break;
}
IEnumerator<CFGBlockLogicalConstruct> cfgSuccessorsEnumerator = currentPartial.CFGSuccessors.GetEnumerator();
cfgSuccessorsEnumerator.MoveNext();
currentPartial = cfgSuccessorsEnumerator.Current as PartialCFGBlockLogicalConstruct;
}
return 1;
}
}
return base.CompareTo(other);
}
static uint Sizeof <T>()
{
Cil.Sizeof <T>();
Cil.Ret();
return(0);
}
protected override ControllerTraversalSearchResult TryGetStateEntry(Cil.InstructionBlock theBlock, out Cil.InstructionBlock actualSuccessor)
{
actualSuccessor = SkipBranchChain(theBlock);
if (!IsDisposingBlock(actualSuccessor))
{
return ControllerTraversalSearchResult.FoundControllerCandidate;
}
toBeRemoved.Add(actualSuccessor);
if (IsFalseReturnBlock(actualSuccessor.Successors[1])) //more likely to be the near successor
{
toBeRemoved.Add(actualSuccessor.Successors[1]);
actualSuccessor = actualSuccessor.Successors[0];
}
else if (IsFalseReturnBlock(actualSuccessor.Successors[0]))
{
toBeRemoved.Add(actualSuccessor.Successors[0]);
actualSuccessor = actualSuccessor.Successors[1];
}
else
{
return ControllerTraversalSearchResult.PatternFailed;
}
return ControllerTraversalSearchResult.FoundStateEntry;
}
public void Execute(AdviceSpec spec)
{
foreach (Navigator aspectNav in spec.AspectNavigators)
{
IMethodDefinition aspectMethod = Narrow.Interceptor(aspectNav, spec);
foreach (Navigator targetNav in spec.TargetNavigators)
{
Instruction targetCallInstruction = Narrow.CallInstruction(targetNav, spec);
MethodReference targetMethod = (MethodReference)targetCallInstruction.Operand;
MethodDefinition containerMethod = Narrow.Method(targetNav.Parent, spec);
// Prevent recursive weaving
if (targetMethod != aspectMethod &&
containerMethod != aspectMethod &&
!Cil.BelongsToAspectDng(targetMethod) &&
!Cil.BelongsToAspectDng(aspectMethod) &&
!Cil.BelongsToAspectDng(containerMethod) &&
targetMethod.GenericParameters.Count == 0 &&
targetMethod.DeclaringType.GenericParameters.Count == 0)
{
// Cannot weave on acces to boxed arrays. Methods look like int32[0...,0...]::Get(int32, int32)
if (targetMethod.DeclaringType.Name.IndexOf("]") == -1 &&
targetMethod.ToString().IndexOf("&") == -1
// To prevent base.SameMethod() calls from child types, event if AroundBody already occurred
&& Cil.GetOriginalMethodName(targetMethod) != Cil.GetOriginalMethodName(containerMethod)
)
{
AddInterceptor(targetCallInstruction, containerMethod, aspectMethod);
}
}
}
}
}
public void Execute(AdviceSpec spec)
{
foreach (Navigator aspectNav in spec.AspectNavigators)
{
IMethodDefinition aspectMethod = Narrow.Interceptor(aspectNav, spec);
foreach (Navigator targetNav in spec.TargetNavigators)
{
MethodDefinition targetMethod = Narrow.ConcreteMethod(targetNav, spec);
// Prevent recursive weaving
if (targetMethod != aspectMethod &&
!Cil.BelongsToAspectDng(targetMethod) &&
!Cil.BelongsToAspectDng(aspectMethod) &&
targetMethod.GenericParameters.Count == 0 &&
targetMethod.DeclaringType.GenericParameters.Count == 0)
{
// Cannot keep semantics of "ref" parameters
if (targetMethod.ToString().IndexOf("&") == -1)
{
AddInterceptor(targetMethod, aspectMethod);
}
}
}
}
}
static void CopyTo <T>(IntPtr dst, T value)
{
Cil.Ldarg(0);
Cil.Ldarga(1);
Cil.Sizeof <T>();
Cil.Cpblk();
}
private void Weave(string configFile)
{
AspectDngConfig conf = new AspectDngConfig(configFile);
if (!File.Exists(conf.TargetAssembly))
{
throw new ConfigurationException("File doesn't exist: " + conf.TargetAssembly);
}
if (!File.Exists(conf.AspectsAssembly))
{
throw new ConfigurationException("File doesn't exist: " + conf.AspectsAssembly);
}
string backup = CopyToBackup(conf.TargetAssembly);
if (conf.TargetAssembly == conf.AspectsAssembly || conf.AspectsAssembly == null || conf.AspectsAssembly == "")
{
Cil.Init(backup, backup);
}
else
{
Cil.Init(backup, conf.AspectsAssembly);
}
PerformWeave();
Cil.SaveTo(conf.WeavedAssembly);
}
static Hashtable GetInstructions(Cil.MethodBody body)
{
Hashtable instructions = new Hashtable (body.Instructions.Count);
foreach (Cil.Instruction i in body.Instructions)
instructions.Add (i.Offset, i);
return instructions;
}
static Cil.Instruction GetInstruction(Cil.MethodBody body, Hashtable instructions, int offset)
{
Cil.Instruction instr = (Cil.Instruction) instructions [offset];
if (instr != null)
return instr;
return body.Instructions.Outside;
}
public void Read (Cil.MethodBody body, IDictionary instructions)
{
try {
ISymbolMethod method = m_reader.GetMethod (new SymbolToken ((int) body.Method.MetadataToken.ToUInt ()));
ReadSequencePoints (method, instructions);
ReadScopeAndLocals (method.RootScope, null, body, instructions);
} catch (COMException) {}
}
public void Execute(AdviceSpec spec)
{
foreach (Navigator targetNav in spec.TargetNavigators)
{
foreach (Navigator aspectNav in spec.AspectNavigators)
{
Cil.CopyTo(targetNav.Current, (ICloneable)aspectNav.Current);
}
}
}
private void DirectWeave(string targetAssemblyPath)
{
if (!File.Exists(targetAssemblyPath))
{
throw new ConfigurationException("File doesn't exist: " + targetAssemblyPath);
}
string backup = CopyToBackup(targetAssemblyPath);
Cil.Init(backup, backup);
PerformWeave();
Cil.SaveTo(targetAssemblyPath);
}
static void ReadScopeAndLocals (ISymbolScope scope, Cil.Scope parent, Cil.MethodBody body, IDictionary instructions)
{
Cil.Scope s = new Cil.Scope ();
s.Start = GetInstruction (body, instructions, scope.StartOffset);
s.End = GetInstruction (body, instructions, scope.EndOffset);
if (parent != null)
parent.Scopes.Add (s);
else
body.Scopes.Add (s);
foreach (ISymbolVariable local in scope.GetLocals ()) {
Cil.VariableDefinition variable = body.Variables [local.AddressField1];
variable.Name = local.Name;
s.Variables.Add (variable);
}
foreach (ISymbolScope child in scope.GetChildren ())
ReadScopeAndLocals (child, s, body, instructions);
}
public void Cleanup()
{
foreach (ToBeWeaved tbw in Map.Values)
{
Instruction fieldAccessInstruction = tbw.TargetCall;
MethodDefinition containerMethod = tbw.ContainerMethod;
FieldReference field = (FieldReference)fieldAccessInstruction.Operand;
MethodDefinition tplMethod = Cil.AspectTemplateCall.Clone();
tplMethod.Name = field.Name + "_" + (IsGetter ? "Getter" : "Setter") + Cil.GetNextId();
((TypeDefinition)containerMethod.DeclaringType).Methods.Add(tplMethod);
tplMethod.Body.InitLocals = true;
tplMethod.Body.Instructions.Clear(); // remove ret
// *** Inside interceptor ***
PopulateInterceptor(tbw, fieldAccessInstruction, field, tplMethod);
// Do nothing instead of the the previous behavior
fieldAccessInstruction.OpCode = OpCodes.Call;
fieldAccessInstruction.Operand = tplMethod;
}
}
public void Cleanup()
{
Hashtable templateMethods = new Hashtable();
Hashtable templateMethodsInterceptors = new Hashtable();
foreach (ToBeWeaved tbw in m_InterceptorsToWeave.Values)
{
Instruction call = tbw.TargetCall;
MethodDefinition containerMethod = tbw.ContainerMethod;
MethodReference targetMethod = (MethodReference)call.Operand;
if (containerMethod != null && containerMethod.DeclaringType != null)
{
MethodDefinition tplMethod = Cil.AspectTemplateCall.Clone();
tplMethod.Body.Instructions.Clear(); // remove ret
tplMethod.Name = targetMethod.Name + Joinpoints.OperationJoinPoint.WrappedMethodSuffix + "Call_" + Cil.GetNextId();
((TypeDefinition)containerMethod.DeclaringType).Methods.Add(tplMethod);
PopulateInterceptor(tbw, call, targetMethod, tplMethod);
call.OpCode = OpCodes.Call;
call.Operand = tplMethod;
}
}
}
public void Cleanup()
{
foreach (DictionaryEntry entry in m_InterceptorsToWeave)
{
MethodDefinition containerMethod = entry.Key as MethodDefinition;
TypeDefinition containerType = (TypeDefinition)containerMethod.DeclaringType;
// Methods can be removed. In that case, they don't have a declaring type any more
if (containerType != null)
{
// Clone and rename the target method
MethodDefinition targetMethod = containerMethod.Clone();
targetMethod.Name += Joinpoints.OperationJoinPoint.WrappedMethodSuffix + "Body_" + Cil.GetNextId();
targetMethod.IsNewSlot = false;
targetMethod.IsFinal = false;
targetMethod.IsRuntimeSpecialName = targetMethod.IsSpecialName = false;
containerType.Methods.Add(targetMethod);
// Clear containerMethod
containerMethod.Body.InitLocals = true;
containerMethod.Body.ExceptionHandlers.Clear();
containerMethod.Body.Variables.Clear();
containerMethod.Body.Instructions.Clear();
// Reify arguments and call interceptors in the original (now target) method
EmittingContext ctx = new EmittingContext(containerMethod);
VariableDefinition tmpObj = null;
if (!Cil.IsStatic(targetMethod))
{
ctx.Emit(OpCodes.Ldarg_0);
if (targetMethod.DeclaringType.IsValueType)
{
ctx.Emit(OpCodes.Ldobj, targetMethod.DeclaringType);
ctx.Emit(OpCodes.Box, targetMethod.DeclaringType);
// Tmp object to store boxed value types when passed along call interceptors and then unwrapped after calls
//tmpObj = new VariableDefinition(new ReferenceType(targetMethod.DeclaringType));
tmpObj = new VariableDefinition(Cil.GetTypeReference(typeof(object)));
containerMethod.Body.Variables.Add(tmpObj);
ctx.Emit(OpCodes.Stloc, tmpObj);
ctx.Emit(OpCodes.Ldloc, tmpObj);
}
}
VariableDefinition arrayDef = new VariableDefinition(Cil.GetTypeReference(typeof(object[])));
containerMethod.Body.Variables.Add(arrayDef);
ParameterDefinitionCollection containerParameters = containerMethod.Parameters;
ParameterDefinitionCollection targetParameters = targetMethod.Parameters;
// Instantiate an array of the right size
ctx.Emit(OpCodes.Ldc_I4, containerParameters.Count);
ctx.Emit(OpCodes.Newarr, Cil.GetTypeReference(typeof(object)));
ctx.Emit(OpCodes.Stloc, arrayDef);
// Load the array with data coming from the current parameters
for (int i = containerParameters.Count - 1; i >= 0; i--)
{
ParameterDefinition p = containerParameters[i];
ctx.Emit(OpCodes.Ldloc, arrayDef);
ctx.Emit(OpCodes.Ldc_I4, i);
ctx.Emit(OpCodes.Ldarg, p);
Cil.BoxIfRequired(p.ParameterType, ctx);
ctx.Emit(OpCodes.Stelem_Ref);
}
// Pass real parameter values (taken from the stack) as the next parameter
ctx.Emit(OpCodes.Ldloc, arrayDef);
// end of Reify parameters
ArrayList interceptors = entry.Value as ArrayList;
Cil.InvokeInterceptors(containerMethod, ctx, targetMethod, interceptors);
Cil.UnboxIfRequired(targetMethod.ReturnType.ReturnType, ctx);
if (!Cil.IsStatic(targetMethod) && targetMethod.DeclaringType.IsValueType)
{
ctx.Emit(OpCodes.Ldarg_0);
ctx.Emit(OpCodes.Ldloc, tmpObj);
Cil.UnboxIfRequired(targetMethod.DeclaringType, ctx);
ctx.Emit(OpCodes.Stobj, targetMethod.DeclaringType);
}
// Cast (to satisfy PEVerify)
Cil.CastIfRequired(containerMethod.ReturnType.ReturnType, ctx);
ctx.Emit(OpCodes.Ret);
}
}
}
private static void PopulateInterceptor(ToBeWeaved tbw, Instruction call, MethodReference targetMethod, MethodDefinition tplMethod)
{
EmittingContext ctx = new EmittingContext(tplMethod);
VariableDefinition tmpObj = null;
int offset = 0;
// Interceptor signature must be :
if (call.OpCode == OpCodes.Newobj)
{
// new object -> static ctorDeclaringType interceptor(ctorParametersList);
tplMethod.ReturnType.ReturnType = targetMethod.DeclaringType;
ctx.Emit(OpCodes.Ldnull); // create a brand new object, don't initialize an existing one
}
else if (Cil.IsStatic(targetMethod))
{
// call static method -> static methodReturnType interceptor(methodParametersList);
tplMethod.ReturnType.ReturnType = targetMethod.ReturnType.ReturnType;
}
else
{
//call instance method -> static methodReturnType interceptor(methodDeclaringType, methodParametersList);
tplMethod.ReturnType.ReturnType = targetMethod.ReturnType.ReturnType;
offset = 1;
ctx.Emit(OpCodes.Ldarg_0); // load "this", which is the first parameter of the tplMethod
if (!targetMethod.DeclaringType.IsValueType)
{
tplMethod.Parameters.Add(new ParameterDefinition(targetMethod.DeclaringType));
}
else
{
tplMethod.Parameters.Add(new ParameterDefinition(new ReferenceType(targetMethod.DeclaringType)));
ctx.Emit(OpCodes.Ldobj, targetMethod.DeclaringType);
ctx.Emit(OpCodes.Box, targetMethod.DeclaringType);
// Tmp object to store boxed value types when passed along call interceptors and then unwrapped after calls
// tmpObj = new VariableDefinition(new ReferenceType(targetMethod.DeclaringType));
tmpObj = new VariableDefinition(Cil.GetTypeReference(typeof(object)));
tplMethod.Body.Variables.Add(tmpObj);
ctx.Emit(OpCodes.Stloc, tmpObj);
ctx.Emit(OpCodes.Ldloc, tmpObj);
}
}
foreach (ParameterDefinition p in targetMethod.Parameters)
{
tplMethod.Parameters.Add(new ParameterDefinition(p.ParameterType));
}
ParameterDefinitionCollection tplParameters = tplMethod.Parameters;
ParameterDefinitionCollection targetParameters = targetMethod.Parameters;
int nbParams = tplParameters.Count - offset;
if (nbParams == 0)
{
// Load an empty array
ctx.Emit(OpCodes.Ldnull);
}
else
{
// Instantiate an array of the right size
VariableDefinition arrayDef = new VariableDefinition(Cil.GetTypeReference(typeof(object[])));
tplMethod.Body.Variables.Add(arrayDef);
ctx.Emit(OpCodes.Ldc_I4, nbParams);
ctx.Emit(OpCodes.Newarr, Cil.GetTypeReference(typeof(object)));
ctx.Emit(OpCodes.Stloc, arrayDef);
// Load the array with data coming from the current parameters
for (int i = tplParameters.Count - 1; i >= offset; i--)
{
ctx.Emit(OpCodes.Ldloc, arrayDef);
ctx.Emit(OpCodes.Ldc_I4, i - offset);
ParameterDefinition p = tplParameters[i];
ctx.Emit(OpCodes.Ldarg, p);
Cil.BoxIfRequired(p.ParameterType, ctx);
ctx.Emit(OpCodes.Stelem_Ref);
}
ctx.Emit(OpCodes.Ldloc, arrayDef);
}
// end of reify parameters
Cil.InvokeInterceptors(tplMethod, ctx, targetMethod, tbw.Interceptors);
if (call.OpCode != OpCodes.Newobj)
{
Cil.UnboxIfRequired(targetMethod.ReturnType.ReturnType, ctx);
}
if (call.OpCode != OpCodes.Newobj && !Cil.IsStatic(targetMethod) && targetMethod.DeclaringType.IsValueType)
{
ctx.Emit(OpCodes.Ldarg_0);
ctx.Emit(OpCodes.Ldloc, tmpObj);
ctx.Emit(OpCodes.Unbox, targetMethod.DeclaringType);
ctx.Emit(OpCodes.Ldobj, targetMethod.DeclaringType);
ctx.Emit(OpCodes.Stobj, targetMethod.DeclaringType);
}
// Cast (to satisfy PEVerify)
Cil.CastIfRequired(tplMethod.ReturnType.ReturnType, ctx);
ctx.Emit(OpCodes.Ret);
}
public void Generuj()
{
// Odstraní předešlý a vygeneruje nový požadovaný level
// Pokud by byl problém s pamětí (ale podle ukazatele v C# tento Dispose moc paměti neušetří)
//
//foreach (Control ct in this.form.Controls)
//{
// if (ct.BackColor == Color.Cyan) // všem PictureBoxům k odstranění se nastaví tato barva
// ct.Dispose();
//}
this.form.Controls.Clear();
string levelDesign = Storage.GetLevels()[this.levelNum];
Standard s; Zrychlovaci zr; Zpomalovaci zp; Propadavaci p;
Klic k; Cil c;
//vyresetování listů kvůli opakovaným restartům
ScoreBoard.VynulujKlice();
Blok.solidBlokList.Clear();
Blok.zrychlovaciBlokList.Clear();
Blok.zpomalovaciBlokList.Clear();
Blok.propadavaciBlokList.Clear();
Blok.klicList.Clear();
// přidání pauzy a možnosti odejít ze hry
this.form.Controls.Add(GameSetup.LPause);
this.form.Controls.Add(GameSetup.LExit);
// přidání nepřátel
foreach (Nepritel N in Nepritel.listNepratel)
{
form.Controls.Add(N.postavicka);
}
// přidání hráče
this.hrac.postavicka.Top = this.hracTop;
this.hrac.postavicka.Left = this.hracLeft;
form.Controls.Add(hrac.postavicka);
// přidání bloků podle level designu - jedná se o string, viz. class Storage
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 32; x++)
{
switch (levelDesign[x + (32 * y)])
{
case '#':
s = new Standard(x, y);
form.Controls.Add(s.pbox);
s.pbox.BringToFront();
break;
case 'Z':
zr = new Zrychlovaci(x, y);
form.Controls.Add(zr.pbox);
zr.pbox.BringToFront();
break;
case 'S':
zp = new Zpomalovaci(x, y);
form.Controls.Add(zp.pbox);
zp.pbox.BringToFront();
break;
case 'P':
p = new Propadavaci(x, y);
form.Controls.Add(p.pbox);
p.pbox.BringToFront();
break;
case 'K':
k = new Klic(x, y);
form.Controls.Add(k.pbox);
k.pbox.BringToFront();
ScoreBoard.PridejKlic();
break;
case 'C':
c = new Cil(x, y);
form.Controls.Add(c.pbox);
break;
default:
break;
}
}
}
// přidání skore
ScoreBoard.Zobraz(this.form, this.hrac);
ScoreBoard.airBarHodnota = ScoreBoard.airBarKapacita;
ScoreBoard.airBar.BackColor = Color.Green;
}
private void PopulateInterceptor(ToBeWeaved tbw, Instruction fieldAccessInstruction, FieldReference field, MethodDefinition tplMethod)
{
tplMethod.ReturnType.ReturnType = IsGetter ? field.FieldType : Cil.GetTypeReference(typeof(void));
bool isStaticField = fieldAccessInstruction.OpCode == OpCodes.Stsfld || fieldAccessInstruction.OpCode == OpCodes.Ldsfld;
// The target object is already on the stack if we access an instance field
if (!isStaticField)
{
if (field.DeclaringType.IsValueType)
{
tplMethod.Parameters.Add(new ParameterDefinition(new ReferenceType(field.DeclaringType)));
}
else
{
tplMethod.Parameters.Add(new ParameterDefinition(field.DeclaringType));
}
}
// The value to assign is already on the stack as well
if (!IsGetter)
{
tplMethod.Parameters.Add(new ParameterDefinition(field.FieldType));
}
EmittingContext ctx = new EmittingContext(tplMethod);
VariableDefinition tmpObj = null;
if (!isStaticField)
{
ctx.Emit(OpCodes.Ldarg_0); // load "this", which is the first parameter of the tplMethod
if (field.DeclaringType.IsValueType)
{
ctx.Emit(OpCodes.Ldobj, field.DeclaringType);
ctx.Emit(OpCodes.Box, field.DeclaringType);
// Tmp object to store boxed value types when passed along call interceptors and then unwrapped after calls
// tmpObj = new VariableDefinition(new ReferenceType(field.DeclaringType));
tmpObj = new VariableDefinition(Cil.GetTypeReference(typeof(object)));
tplMethod.Body.Variables.Add(tmpObj);
ctx.Emit(OpCodes.Stloc, tmpObj);
ctx.Emit(OpCodes.Ldloc, tmpObj);
}
if (!IsGetter)
{
ctx.Emit(OpCodes.Ldarg, tplMethod.Parameters[1]);
Cil.BoxIfRequired(field.FieldType, ctx);
}
}
else // Static field
{
if (!IsGetter)
{
ctx.Emit(OpCodes.Ldarg, tplMethod.Parameters[0]);
Cil.BoxIfRequired(field.FieldType, ctx);
}
}
// Pass the field representation as the last parameter
ctx.Emit(OpCodes.Ldtoken, field);
#if DOTNETTWO
ctx.Emit(OpCodes.Ldtoken, field.DeclaringType);
ctx.Emit(OpCodes.Call, Cil.GetGenericFieldFromHandle);
#else
ctx.Emit(OpCodes.Call, Cil.GetFieldFromHandle);
#endif
// Create the JoinPoint
MethodReference joinPointFactory;
OpCode opCode = fieldAccessInstruction.OpCode;
if (opCode == OpCodes.Stsfld)
{
joinPointFactory = Cil.StaticFieldSetterJoinPointFactory;
}
else if (opCode == OpCodes.Ldsfld)
{
joinPointFactory = Cil.StaticFieldGetterJoinPointFactory;
}
else if (opCode == OpCodes.Stfld)
{
joinPointFactory = Cil.FieldSetterJoinPointFactory;
}
else if (opCode == OpCodes.Ldfld)
{
joinPointFactory = Cil.FieldGetterJoinPointFactory;
}
else
{
throw new NotSupportedException("This kind of field accessor is not supported : " + opCode);
}
ctx.Emit(OpCodes.Newobj, joinPointFactory);
// Add each interceptor
foreach (MethodReference aspectMethod in tbw.Interceptors)
{
ctx.Emit(OpCodes.Ldtoken, Cil.TargetMainModule.Import(aspectMethod));
ctx.Emit(OpCodes.Call, Cil.GetMethodFromHandle);
ctx.Emit(OpCodes.Call, Cil.AddInterceptorMethod);
}
// Invoke "proceed" on the joinpoint
ctx.Emit(OpCodes.Call, Cil.ProceedMethod);
Cil.UnboxIfRequired(tplMethod.ReturnType.ReturnType, ctx);
if (!isStaticField && field.DeclaringType.IsValueType) // Unbox and update "this"
{
ctx.Emit(OpCodes.Ldarg_0);
ctx.Emit(OpCodes.Ldloc, tmpObj);
ctx.Emit(OpCodes.Unbox, field.DeclaringType);
ctx.Emit(OpCodes.Ldobj, field.DeclaringType);
ctx.Emit(OpCodes.Stobj, field.DeclaringType);
}
// Cast (to satisfy PEVerify)
Cil.CastIfRequired(tplMethod.ReturnType.ReturnType, ctx);
ctx.Emit(OpCodes.Ret);
}
public static int Main(string[] argv)
{
#if TEST
AutoTest.TestSuite();
#endif
int result = 1;
StringCollection parameters = new StringCollection();
parameters.AddRange(argv);
AppDomain.CurrentDomain.AppendPrivatePath(Environment.CurrentDirectory);
AppDomain.CurrentDomain.AppendPrivatePath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
try {
EntryPoint entryPoint = new EntryPoint();
if (parameters.Contains(DebugOption)) // Handle debug mode
{
AspectDngConfig.Instance.debug = true;
parameters.Remove(DebugOption);
}
if (parameters.Contains(QueryOption) && parameters.Count >= 3) // Handle query mode
{
parameters.Remove(QueryOption);
Cil.Init(parameters[0], parameters[0]);
parameters.RemoveAt(0);
string[] array = new string[parameters.Count];
parameters.CopyTo(array, 0);
string xpath = string.Join(" ", array);
Console.WriteLine("\nReal XPath query:\n{0}", xpath);
ICollection results = Cil.TargetNavigator.SelectList(xpath);
Console.WriteLine("{0} results", results.Count);
foreach (Navigator nav in results)
{
Console.WriteLine("[" + nav.Name + "] " + nav);
}
}
else if (parameters.Contains(IlmlDumpOption) && parameters.Count == 3) // Handle ilml mode
{
parameters.Remove(IlmlDumpOption);
Cil.Init(parameters[0], parameters[0]);
parameters.RemoveAt(0);
// Apply XSLT to Assembly
XslTransform ilmlDump = new XslTransform();
ilmlDump.Load(new XmlTextReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("IlmlDump.xsl")), null, null);
XmlTextWriter writer = new XmlTextWriter(parameters[0], Encoding.Unicode);
writer.Formatting = Formatting.Indented;
ilmlDump.Transform(new Navigator(Cil.TargetAssembly), null, writer, null);
writer.Close();
}
else // Handle weave mode
{
long Start = DateTime.Now.Ticks;
// Interpret parameters
if (parameters.Count > 0)
{
string firstArg = parameters[0];
if (firstArg.EndsWith(".xml"))
{
Log.Debug("Weaving as specified in " + firstArg);
entryPoint.Weave(firstArg);
result = 0;
}
else if (firstArg.EndsWith(".dll") || firstArg.EndsWith(".exe"))
{
if (parameters.Count == 1)
{
entryPoint.DirectWeave(firstArg);
}
else if (parameters.Count == 2)
{
string secondArg = parameters[1];
entryPoint.DirectWeave(firstArg, secondArg);
}
result = 0;
}
else
{
entryPoint.PrintUsage();
}
}
else
{
entryPoint.PrintUsage();
}
if (result == 0)
{
Log.Debug("aspectdng took in {0} millis to weave {1} aspects", (DateTime.Now.Ticks - Start) / 10000, AspectDngConfig.Instance.Advice.Count);
Log.Save();
}
}
} catch (ConfigurationException e) {
Log.Error(e.Message);
} catch (AdviceException e) {
Log.Error(e.Message);
} catch (Exception e) {
Log.Error(e.Message);
Log.Error(e.StackTrace);
}
return(result);
}
