private void DebugProc(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
string msg = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(message, length);
Console.WriteLine(
"{0} {1} {2} {3}: {4}",
source, type, id, severity, msg);
}
private static void DebugCallback(DebugSource source, DebugType type, int id,
DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
string msg = Marshal.PtrToStringAnsi(message);
Console.WriteLine("[GL] {0}; {1}; {2}; {3}; {4}",
source, type, id, severity, msg);
}
static void PCCallbackHandler(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
if (severity == DebugSeverity.DebugSeverityHigh || severity == DebugSeverity.DebugSeverityMedium)
{
string msg = Marshal.PtrToStringAnsi(message);
Console.WriteLine("[GL] {0}; {1}; {2}; {3}; {4}", source, type, id, severity, msg);
}
}
/// <summary>
/// Creates an expression which, when evaluated, creates a List<T> in the debugee
/// filled with contents of IEnumerable<T> from the debugee.
/// </summary>
/// <param name="iEnumerableVariable">Expression for IEnumerable variable in the debugee.</param>
/// <param name="itemType">
/// The generic argument of IEnumerable<T> that <paramref name="iEnumerableVariable"/> implements.</param>
public static Expression CreateDebugListExpression(Expression iEnumerableVariable, DebugType itemType, out DebugType listType)
{
// is using itemType.AppDomain ok?
listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
// explicitely cast the variable to IEnumerable<T>, where T is itemType
Expression iEnumerableVariableExplicitCast = new CastExpression(iEnumerableType.GetTypeReference() , iEnumerableVariable, CastType.Cast);
return new ObjectCreateExpression(listType.GetTypeReference(), iEnumerableVariableExplicitCast.ToList());
}
internal static void Debug(DebugType type, string s, params object[] args)
{
if (!Configuration.Debug.Contains(DebugType.All) &&
!Configuration.Debug.Contains(type))
{
return;
}
string message = Output.Format(s, args);
Console.WriteLine(message);
}
public LogEntry(char TypeId, string Tag, int Pid, string Message)
{
this.LogType = GetDebugTypeFromIdentifier(TypeId);
if (this.LogType == DebugType.Unknown)
throw new Exception("Unknown DebugType identifier");
this.LogTag = Tag;
this.Pid = Pid;
this.LogMsg = Message;
}
/// <summary>
/// Creates an expression which, when evaluated, creates a List<T> in the debugee
/// filled with contents of IEnumerable<T> from the debugee.
/// </summary>
/// <param name="iEnumerableVariable">Expression for IEnumerable variable in the debugee.</param>
/// <param name="itemType">
/// The generic argument of IEnumerable<T> that <paramref name="iEnumerableVariable"/> implements.</param>
public static Expression CreateDebugListExpression(Expression iEnumerableVariable, DebugType itemType, out DebugType listType)
{
// is using itemType.AppDomain ok?
listType = DebugType.CreateFromType(itemType.AppDomain, typeof(System.Collections.Generic.List<>), itemType);
var iEnumerableType = DebugType.CreateFromType(itemType.AppDomain, typeof(IEnumerable<>), itemType);
// explicitely cast the variable to IEnumerable<T>, where T is itemType
Expression iEnumerableVariableExplicitCast = new CastExpression { Expression = iEnumerableVariable.Clone() , Type = iEnumerableType.GetTypeReference() };
var obj = new ObjectCreateExpression() { Type = listType.GetTypeReference() };
obj.Arguments.Add(iEnumerableVariableExplicitCast);
return obj;
}
public DebugRect(Point _Center, Point _Offset, int _Width, int _Height, DebugType _Type, Game _Game)
: base(_Game)
{
Offset = _Offset;
Color Color = Color.HotPink;
switch (_Type)
{
case DebugType.View: { Color = Color.Blue; } break;
case DebugType.Physics: { Color = Color.White; } break;
case DebugType.Hostile: { Color = Color.Red; } break;
case DebugType.Trigger: { Color = Color.Yellow; } break;
}
RectangeGraphic = new RectangeGraphic(new Rectangle(_Center.X - Offset.X, _Center.Y - Offset.Y, _Width, _Height), 3, Color, _Game);
}
/// <summary>
/// 输出 debug 日志
/// </summary>
/// <param name="msg">输入内容</param>
/// <param name="logType">输出的类型</param>
private static void WriteDebug(object msg, DebugType logType)
{
if (!LCSConfig.IsDebugMode) return;
switch (logType)
{
case DebugType.Log:
UnityEngine.Debug.Log(msg);
break;
case DebugType.Warning:
UnityEngine.Debug.LogWarning(msg);
break;
case DebugType.Error:
UnityEngine.Debug.LogError(msg);
break;
}
}
internal Value(AppDomain appDomain, ICorDebugValue corValue)
{
if (corValue == null)
throw new ArgumentNullException("corValue");
this.appDomain = appDomain;
this.corValue = corValue;
this.corValue_pauseSession = this.Process.PauseSession;
this.isNull = corValue is ICorDebugReferenceValue && ((ICorDebugReferenceValue)corValue).IsNull() != 0;
if (corValue is ICorDebugReferenceValue &&
((ICorDebugReferenceValue)corValue).GetValue() == 0 &&
((ICorDebugValue2)corValue).GetExactType() == null)
{
// We were passed null reference and no metadata description
// (happens during CreateThread callback for the thread object)
this.type = appDomain.ObjectType;
} else {
ICorDebugType exactType = ((ICorDebugValue2)this.CorValue).GetExactType();
this.type = DebugType.CreateFromCorType(appDomain, exactType);
}
}
public static void Main(string[] args)
{
#region CommandlineArguments
if (args.Length < 2 || args.Length > 3)
{
ShowUsage( );
return;
}
string outputPath = args.Length == 3 ? args[2] : Environment.CurrentDirectory;
string srcPath = args[1];
if (!File.Exists(srcPath))
{
Console.Error.WriteLine("Src file not found: '{0}'", srcPath);
return;
}
srcPath = Path.GetFullPath(srcPath);
#endregion
using var libLLVM = InitializeLLVM( );
#region TargetDetailsSelection
switch (args[0].ToUpperInvariant( ))
{
case "M3":
TargetDetails = new CortexM3Details(libLLVM);
break;
case "X64":
TargetDetails = new X64Details(libLLVM);
break;
default:
ShowUsage( );
return;
}
string moduleName = $"test_{TargetDetails.ShortName}.bc";
#endregion
#region CreatingModule
using var context = new Context( );
using var module = context.CreateBitcodeModule(moduleName, SourceLanguage.C99, srcPath, VersionIdentString);
module.SourceFileName = Path.GetFileName(srcPath);
module.TargetTriple = TargetDetails.TargetMachine.Triple;
module.Layout = TargetDetails.TargetMachine.TargetData;
Debug.Assert(!(module.DICompileUnit is null), "Expected module with non-null compile unit");
TargetDependentAttributes = TargetDetails.BuildTargetDependentFunctionAttributes(context);
#endregion
var diFile = module.DIBuilder.CreateFile(srcPath);
#region CreatingBasicTypesWithDebugInfo
// Create basic types used in this compilation
var i32 = new DebugBasicType(module.Context.Int32Type, module, "int", DiTypeKind.Signed);
var f32 = new DebugBasicType(module.Context.FloatType, module, "float", DiTypeKind.Float);
var voidType = DebugType.Create <ITypeRef, DIType>(module.Context.VoidType, null);
var i32Array_0_32 = i32.CreateArrayType(module, 0, 32);
#endregion
#region CreatingStructureTypes
// create the LLVM structure type and body with full debug information
var fooBody = new[]
{
new DebugMemberInfo(0, "a", diFile, 3, i32),
new DebugMemberInfo(1, "b", diFile, 4, f32),
new DebugMemberInfo(2, "c", diFile, 5, i32Array_0_32),
};
var fooType = new DebugStructType(module, "struct.foo", module.DICompileUnit, "foo", diFile, 1, DebugInfoFlags.None, fooBody);
#endregion
#region CreatingGlobalsAndMetadata
// add global variables and constants
var constArray = ConstantArray.From(i32, 32, module.Context.CreateConstant(3), module.Context.CreateConstant(4));
var barValue = module.Context.CreateNamedConstantStruct(fooType
, module.Context.CreateConstant(1)
, module.Context.CreateConstant(2.0f)
, constArray
);
var bar = module.AddGlobal(fooType, false, 0, barValue, "bar");
bar.Alignment = module.Layout.AbiAlignmentOf(fooType);
bar.AddDebugInfo(module.DIBuilder.CreateGlobalVariableExpression(module.DICompileUnit, "bar", string.Empty, diFile, 8, fooType.DIType, false, null));
var baz = module.AddGlobal(fooType, false, Linkage.Common, Constant.NullValueFor(fooType), "baz");
baz.Alignment = module.Layout.AbiAlignmentOf(fooType);
baz.AddDebugInfo(module.DIBuilder.CreateGlobalVariableExpression(module.DICompileUnit, "baz", string.Empty, diFile, 9, fooType.DIType, false, null));
// add module flags and compiler identifiers...
// this can technically occur at any point, though placing it here makes
// comparing against clang generated files easier
AddModuleFlags(module);
#endregion
#region CreatingQualifiedTypes
// create types for function args
var constFoo = module.DIBuilder.CreateQualifiedType(fooType.DIType, QualifiedTypeTag.Const);
var fooPtr = new DebugPointerType(fooType, module);
#endregion
// Create the functions
// NOTE: The declaration ordering is reversed from that of the sample code file (test.c)
// However, this is what Clang ends up doing for some reason so it is
// replicated here to aid in comparing the generated LL files.
IrFunction doCopyFunc = DeclareDoCopyFunc(module, diFile, voidType);
IrFunction copyFunc = DeclareCopyFunc(module, diFile, voidType, constFoo, fooPtr);
CreateCopyFunctionBody(module, copyFunc, diFile, fooType, fooPtr, constFoo);
CreateDoCopyFunctionBody(module, doCopyFunc, fooType, bar, baz, copyFunc);
// finalize the debug information
// all temporaries must be replaced by now, this resolves any remaining
// forward declarations and marks the builder to prevent adding any
// nodes that are not completely resolved.
module.DIBuilder.Finish( );
// verify the module is still good and print any errors found
if (!module.Verify(out string msg))
{
Console.Error.WriteLine("ERROR: {0}", msg);
}
else
{
// test optimization works, but don't save it as that makes it harder to do a compare with official clang builds
{// force a GC to verify callback delegate for diagnostics is still valid, this is for test only and wouldn't
// normally be done in production code.
GC.Collect(GC.MaxGeneration);
using var modForOpt = module.Clone( );
// NOTE:
// The ordering of passes can matter depending on the pass, and passes may be added more than once
// the caller has full control of ordering, this is just a sample of effectively randomly picked
// passes and not necessarily a reflection of any particular use case.
var pm = new ModulePassManager( );
pm.AddAlwaysInlinerPass( )
.AddAggressiveDCEPass( )
.AddArgumentPromotionPass( )
.AddBasicAliasAnalysisPass( )
.AddBitTrackingDCEPass( )
.AddCFGSimplificationPass( )
.AddConstantMergePass( )
.AddConstantPropagationPass( )
.AddFunctionInliningPass( )
.AddGlobalOptimizerPass( )
.AddInstructionCombiningPass( )
.Run(modForOpt);
}
// Module is good, so generate the output files
module.WriteToFile(Path.Combine(outputPath, "test.bc"));
File.WriteAllText(Path.Combine(outputPath, "test.ll"), module.WriteToString( ));
TargetDetails.TargetMachine.EmitToFile(module, Path.Combine(outputPath, "test.o"), CodeGenFileType.ObjectFile);
TargetDetails.TargetMachine.EmitToFile(module, Path.Combine(outputPath, "test.s"), CodeGenFileType.AssemblySource);
Console.WriteLine("Generated test.bc, test.ll, test.o, and test.s");
}
}
/// <summary> /// Outputs the Debug-Messages to the debug-console. /// </summary> /// <param name="pMessage">Debug-Message</param> /// <param name="pParameters">Output-Parameters [Not required for ToDebug-Method]</param> public static void ToDebug(string pMessage, DebugType pDebugType, params object[] pParameters) => Debug.Print(pMessage);
/// <summary>
/// Retrives a number of messages from message log and return the messages in array.
/// </summary>
/// <param name="sources"></param>
/// <param name="types"></param>
/// <param name="ids"></param>
/// <param name="severities"></param>
/// <param name="count"></param>
/// <returns></returns>
public static string[] GetDebugMessageLog(DebugSource[] sources, DebugType[] types, uint[] ids, DebugSeverity[] severities, int count = -1)
{
if (count == -1)
{
count = GetIntegerv(GetParameters.DebugLoggedMessages);
}
else
count = Math.Min(sources.Length, Math.Min(types.Length, Math.Min(ids.Length, severities.Length))); // , MessageLogs.Length))));
var maxmessagelength = GetIntegerv(GetParameters.MaxDebugMessageLength);
var sb = new StringBuilder(count * maxmessagelength + 4);
var lengths = new int[count];
var result = (int)Delegates.glGetDebugMessageLog((uint)count, sb.Capacity - 2, ref sources[0], ref types[0], ref ids[0], ref severities[0], ref lengths[0], sb);
if (result > 0)
{
var messages = new string[Math.Min(result, lengths.Length)];
int lastpos = 0;
for (int i = 0; i < messages.Length; i++)
{
messages[i] = sb.ToString(lastpos, lengths[i] - 1);
lastpos = lengths[i];
}
return messages;
}
else
return new string[0];
}
private static void DebugCallback(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
string debugMessage = Marshal.PtrToStringAnsi(message, length);
Debug.WriteLine(String.Format("{0} {1} {2}", severity, type, debugMessage));
}
/// <exception cref="GetValueException"><c>GetValueException</c>.</exception>
private static void MethodInvokeStarter(Eval eval, DebugMethodInfo method, Value thisValue, Value[] args)
{
List <ICorDebugValue> corArgs = new List <ICorDebugValue>();
args = args ?? new Value[0];
if (args.Length != method.ParameterCount)
{
throw new GetValueException("Invalid parameter count");
}
if (!method.IsStatic)
{
if (thisValue == null)
{
throw new GetValueException("'this' is null");
}
if (thisValue.IsNull)
{
throw new GetValueException("Null reference");
}
// if (!(thisValue.IsObject)) // eg Can evaluate on array
if (!method.DeclaringType.IsInstanceOfType(thisValue))
{
throw new GetValueException(
"Can not evaluate because the object is not of proper type. " +
"Expected: " + method.DeclaringType.FullName + " Seen: " + thisValue.Type.FullName
);
}
corArgs.Add(thisValue.CorValue);
}
for (int i = 0; i < args.Length; i++)
{
Value arg = args[i];
DebugType paramType = (DebugType)method.GetParameters()[i].ParameterType;
if (!arg.Type.CanImplicitelyConvertTo(paramType))
{
throw new GetValueException("Inncorrect parameter type");
}
// Implicitely convert to correct primitve type
if (paramType.IsPrimitive && args[i].Type != paramType)
{
object oldPrimVal = arg.PrimitiveValue;
object newPrimVal = Convert.ChangeType(oldPrimVal, paramType.PrimitiveType);
arg = CreateValue(method.AppDomain, newPrimVal);
}
// It is importatnt to pass the parameted in the correct form (boxed/unboxed)
if (paramType.IsValueType)
{
corArgs.Add(arg.CorGenericValue);
}
else
{
if (args[i].Type.IsValueType)
{
corArgs.Add(arg.Box().CorValue);
}
else
{
corArgs.Add(arg.CorValue);
}
}
}
ICorDebugType[] genericArgs = ((DebugType)method.DeclaringType).GenericArgumentsAsCorDebugType;
eval.CorEval2.CallParameterizedFunction(
method.CorFunction,
(uint)genericArgs.Length, genericArgs,
(uint)corArgs.Count, corArgs.ToArray()
);
}
void debugOutput(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
string msg = Marshal.PtrToStringAnsi(message, length);
Info.print("GL Debug Message: {0} \n\tSource:{1} \n\tType:{2} \n\tSeverity:{3} \n\tID:{4} ", msg, source, type, severity, id);
}
public TypedValue(Value value, DebugType type)
{
this.value = value;
this.type = type;
}
void DebugMessage(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
var msg = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(message, length);
Console.WriteLine(string.Format("{0} {1} {2}", severity, type, msg));
}
public bool IsVisualizerAvailable(DebugType type)
{
return(type.FullName == typeof(string).FullName);
}
/// <summary>
/// Outputs the Debug-Messages to the system-console.
/// </summary>
/// <param name="pMessage">Debug-Message</param>
/// <param name="pParameters">Output-Parameters [Not required for ToConsole-Method]</param>
public static void ToConsole(string pMessage, DebugType pDebugType, params object[] pParameters)
{
Console.Write($"({Thread.CurrentThread.ManagedThreadId.ToString("D3")})");
switch (pDebugType)
{
case DebugType.Info:
Console.ForegroundColor = ConsoleColor.Green;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[ ~INFO ] ");
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(pMessage);
break;
case DebugType.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[WARNING] ");
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(pMessage);
break;
case DebugType.Cronjob:
Console.ForegroundColor = ConsoleColor.Cyan;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[CRONJOB] ");
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(pMessage);
break;
case DebugType.Confirmation:
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[CONFIRM] ");
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(pMessage);
break;
case DebugType.Error:
Console.ForegroundColor = ConsoleColor.Red;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[ ERROR ] ");
Console.WriteLine(pMessage);
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
break;
case DebugType.Fatal:
Console.ForegroundColor = ConsoleColor.Black;
Console.BackgroundColor = ConsoleColor.DarkRed;
Console.Write("[ FATAL ] ");
Console.WriteLine(pMessage);
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
break;
case DebugType.Remote:
Console.ForegroundColor = ConsoleColor.Magenta;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[~REMOTE] ");
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(pMessage);
break;
case DebugType.Exception:
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.BackgroundColor = ConsoleColor.Black;
Console.Write("[EXCEPT.] ");
Console.WriteLine(pMessage);
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
break;
}
}
#pragma warning disable IDE0060 // unused arguments
// ╔════╤════════════════════════════════════════════════════════╗
// ║ 4d │ M E T H O D S ( P U B L I C ) ║
// ╟────┴────────────────────────────────────────────────────────╢
// ║ N O N - S T A T I C & S T A T I C ║
// ╚═════════════════════════════════════════════════════════════╝
#region ═╣ M E T H O D S ( P U B L I C ) ╠═
/// <summary>
/// Disables all debug-outputs.
/// </summary>
/// <param name="pMessage"></param>
/// <param name="pParameters"></param>
public static void Disable(string pMessage, DebugType pDebugType, params object[] pParameters)
{
}
/// <summary>
/// Outputs the Debug-Messages to a given WinForms-Textbox.
/// </summary>
/// <param name="pMessage">Debug-Message</param>
/// <param name="pParameters">Output-Parameters - First parameter: the target textbox-instance</param>
public static void ToTextbox(string pMessage, DebugType pDebugType, params object[] pParameters)
{
(pParameters[0] as TextBox).Text += pMessage + "\r\n";
(pParameters[0] as TextBox).ScrollToCaret();
}
public static Value NewObjectNoConstructor(DebugType debugType)
{
return AsyncNewObjectNoConstructor(debugType).WaitForResult();
}
static M SetStaticType <M>(this M expr, DebugType type) where M : AstNode
{
expr.AddAnnotation(type);
return(expr);
}
private bool DoMatchForLogType(DebugType type)
{
switch (Oper)
{
case FilterOperator.Equal:
return ((DebugType)Value) == type;
case FilterOperator.NotEqual:
return ((DebugType)Value) != type;
default:
return false;
}
}
public override bool Execute(out IList <Exception> thrownExceptions)
{
thrownExceptions = null;
LoggingHelper.LogMessage(Normal, $"{new string(' ', 0)}Compiling Xaml, assembly: {Assembly}");
var skipassembly = !CompileByDefault;
bool success = true;
if (!File.Exists(Assembly))
{
LoggingHelper.LogMessage(Normal, $"{new string(' ', 2)}Assembly file not found. Skipping XamlC.");
return(true);
}
var resolver = DefaultAssemblyResolver ?? new XamlCAssemblyResolver();
if (resolver is XamlCAssemblyResolver xamlCResolver)
{
if (!string.IsNullOrEmpty(DependencyPaths))
{
foreach (var dep in DependencyPaths.Split(';').Distinct())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {dep}");
xamlCResolver.AddSearchDirectory(dep);
}
}
if (!string.IsNullOrEmpty(ReferencePath))
{
var paths = ReferencePath.Replace("//", "/").Split(';').Distinct();
foreach (var p in paths)
{
var searchpath = Path.GetDirectoryName(p);
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {searchpath}");
xamlCResolver.AddSearchDirectory(searchpath);
}
}
}
else
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Ignoring dependency and reference paths due to an unsupported resolver");
}
var debug = DebugSymbols || (!string.IsNullOrEmpty(DebugType) && DebugType.ToLowerInvariant() != "none");
var readerParameters = new ReaderParameters {
AssemblyResolver = resolver,
ReadWrite = !ReadOnly,
ReadSymbols = debug,
};
using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(Path.GetFullPath(Assembly), readerParameters)) {
CustomAttribute xamlcAttr;
if (assemblyDefinition.HasCustomAttributes &&
(xamlcAttr =
assemblyDefinition.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skipassembly = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skipassembly = false;
}
}
foreach (var module in assemblyDefinition.Modules)
{
var skipmodule = skipassembly;
if (module.HasCustomAttributes &&
(xamlcAttr =
module.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skipmodule = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skipmodule = false;
}
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Module: {module.Name}");
var resourcesToPrune = new List <EmbeddedResource>();
foreach (var resource in module.Resources.OfType <EmbeddedResource>())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Resource: {resource.Name}");
string classname;
if (!resource.IsXaml(module, out classname))
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}skipped.");
continue;
}
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no type found... skipped.");
continue;
}
var skiptype = skipmodule;
if (typeDef.HasCustomAttributes &&
(xamlcAttr =
typeDef.CustomAttributes.FirstOrDefault(
ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlCompilationAttribute")) != null)
{
var options = (XamlCompilationOptions)xamlcAttr.ConstructorArguments[0].Value;
if ((options & XamlCompilationOptions.Skip) == XamlCompilationOptions.Skip)
{
skiptype = true;
}
if ((options & XamlCompilationOptions.Compile) == XamlCompilationOptions.Compile)
{
skiptype = false;
}
}
if (Type != null)
{
skiptype = !(Type == classname);
}
if (skiptype && !ForceCompile)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}has XamlCompilationAttribute set to Skip and not Compile... skipped.");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no InitializeComponent found... skipped.");
continue;
}
CustomAttribute xamlFilePathAttr;
var xamlFilePath = typeDef.HasCustomAttributes && (xamlFilePathAttr = typeDef.CustomAttributes.FirstOrDefault(ca => ca.AttributeType.FullName == "Xamarin.Forms.Xaml.XamlFilePathAttribute")) != null ?
(string)xamlFilePathAttr.ConstructorArguments[0].Value :
resource.Name;
var initCompRuntime = typeDef.Methods.FirstOrDefault(md => md.Name == "__InitComponentRuntime");
if (initCompRuntime != null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}__InitComponentRuntime already exists... not creating");
}
else
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Creating empty {typeDef.Name}.__InitComponentRuntime");
initCompRuntime = new MethodDefinition("__InitComponentRuntime", initComp.Attributes, initComp.ReturnType);
initCompRuntime.Body.InitLocals = true;
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Copying body of InitializeComponent to __InitComponentRuntime");
initCompRuntime.Body = new MethodBody(initCompRuntime);
var iCRIl = initCompRuntime.Body.GetILProcessor();
foreach (var instr in initComp.Body.Instructions)
{
iCRIl.Append(instr);
}
initComp.Body.Instructions.Clear();
initComp.Body.GetILProcessor().Emit(OpCodes.Ret);
initComp.Body.InitLocals = true;
typeDef.Methods.Add(initCompRuntime);
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Parsing Xaml");
var rootnode = ParseXaml(resource.GetResourceStream(), typeDef);
if (rootnode == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed.");
continue;
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
hasCompiledXamlResources = true;
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Replacing {0}.InitializeComponent ()");
Exception e;
if (!TryCoreCompile(initComp, initCompRuntime, rootnode, out e))
{
success = false;
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}failed.");
(thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e);
if (e is XamlParseException xpe)
{
LoggingHelper.LogError(null, null, null, xamlFilePath, xpe.XmlInfo.LineNumber, xpe.XmlInfo.LinePosition, 0, 0, xpe.Message, xpe.HelpLink, xpe.Source);
}
else if (e is XmlException xe)
{
LoggingHelper.LogError(null, null, null, xamlFilePath, xe.LineNumber, xe.LinePosition, 0, 0, xe.Message, xe.HelpLink, xe.Source);
}
else
{
LoggingHelper.LogError(null, null, null, xamlFilePath, 0, 0, 0, 0, e.Message, e.HelpLink, e.Source);
}
LoggingHelper.LogMessage(Low, e.StackTrace);
continue;
}
if (Type != null)
{
InitCompForType = initComp;
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
if (OptimizeIL)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Optimizing IL");
initComp.Body.Optimize();
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
#pragma warning disable 0618
if (OutputGeneratedILAsCode)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Decompiling option has been removed. Use a 3rd party decompiler to admire the beauty of the IL generated");
}
#pragma warning restore 0618
resourcesToPrune.Add(resource);
}
if (hasCompiledXamlResources)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Changing the module MVID");
module.Mvid = Guid.NewGuid();
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}done.");
}
if (!KeepXamlResources)
{
if (resourcesToPrune.Any())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Removing compiled xaml resources");
}
foreach (var resource in resourcesToPrune)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Removing {resource.Name}");
module.Resources.Remove(resource);
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
}
}
if (!hasCompiledXamlResources)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}No compiled resources. Skipping writing assembly.");
return(success);
}
if (ReadOnly)
{
return(success);
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 0)}Writing the assembly");
try {
assemblyDefinition.Write(new WriterParameters {
WriteSymbols = debug,
});
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}done.");
} catch (Exception e) {
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}failed.");
LoggingHelper.LogErrorFromException(e);
(thrownExceptions = thrownExceptions ?? new List <Exception>()).Add(e);
LoggingHelper.LogMessage(Low, e.StackTrace);
success = false;
}
}
return(success);
}
public static Value NewArray(DebugType type, uint length, uint?lowerBound)
{
return(AsyncNewArray(type, length, lowerBound).WaitForResult());
}
public static void HandleDebugGLMessage(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
StringBuilder errorString = new StringBuilder();
switch (source)
{
case DebugSource.DebugSourceApi: {
errorString.Append("[API]");
break;
}
case DebugSource.DebugSourceApplication: {
errorString.Append("[APP]");
break;
}
case DebugSource.DebugSourceOther: {
errorString.Append("[Other]");
break;
}
case DebugSource.DebugSourceShaderCompiler: {
errorString.Append("[Shader]");
break;
}
case DebugSource.DebugSourceThirdParty: {
errorString.Append("[3RD]");
break;
}
case DebugSource.DebugSourceWindowSystem: {
errorString.Append("[Window]");
break;
}
}
switch (type)
{
case DebugType.DebugTypeDeprecatedBehavior: {
errorString.Append("[DEPRECATED]");
break;
}
case DebugType.DebugTypeError: {
errorString.Append("[ERROR]");
break;
}
case DebugType.DebugTypeMarker: {
errorString.Append("[MARKER]");
break;
}
case DebugType.DebugTypeOther: {
errorString.Append("[OTHER]");
break;
}
case DebugType.DebugTypePerformance: {
errorString.Append("[PERF]");
break;
}
case DebugType.DebugTypePopGroup: {
errorString.Append("[POPGROUP]");
break;
}
case DebugType.DebugTypePortability: {
errorString.Append("[PORTABILITY]");
break;
}
case DebugType.DebugTypePushGroup: {
errorString.Append("[PUSHGROUP]");
break;
}
case DebugType.DebugTypeUndefinedBehavior: {
errorString.Append("[BEHAVIOR]");
break;
}
}
errorString.Append(Marshal.PtrToStringAnsi(message));
switch (severity)
{
case DebugSeverity.DebugSeverityHigh: {
Logger.Error(errorString.ToString());
//if (type == DebugType.DebugTypeError) throw new InvalidOperationException("ARB_debug_output found an error.");
break;
}
case DebugSeverity.DebugSeverityMedium: {
Logger.Warning(errorString.ToString());
break;
}
case DebugSeverity.DebugSeverityLow: {
errorString.Insert(0, "[Low]");
Logger.Info(errorString.ToString());
break;
}
case DebugSeverity.DebugSeverityNotification: {
errorString.Insert(0, "[Notice]");
Logger.Info(errorString.ToString());
break;
}
default: {
break;
}
}
}
public static void LogWarning(DebugType debugType, object message, params object[] arguments)
{
if(EnumExtensions.IsFlagSet(DebugType.Warning, debugType)) {
Debug.LogWarning(string.Format(message.ToString(), arguments));
}
}
public Operation SetDebug(string file, int line, int col, DebugType type, string data)
{
this.Debug = string.Format("{0}:{1}.{2}:{3}:{4}", file, line, col, type, data);
return this;
}
public void SetDebugCallback(DebugType theFunc)
{
debugFunc = theFunc;
}
public static IEnumerable <TreeNode> LazyGetChildNodesOfObject(Expression targetObject, DebugType shownType)
{
MemberInfo[] publicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] publicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
DebugType baseType = (DebugType)shownType.BaseType;
if (baseType != null)
{
yield return(new TreeNode(
ImageCache.GetIcon(TypeIcon.Class, BackgroundType.DebuggerToolTip),
"BaseClass",
baseType.Name,
baseType.FullName,
baseType.FullName == "System.Object" ? null : Utils.LazyGetChildNodesOfObject(targetObject, baseType)
));
}
if (nonPublicInstance.Length > 0)
{
yield return(new TreeNode(
null,
"NonPublicMembers",
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicInstance)
));
}
if (publicStatic.Length > 0 || nonPublicStatic.Length > 0)
{
IEnumerable <TreeNode> childs = Utils.LazyGetMembersOfObject(targetObject, publicStatic);
if (nonPublicStatic.Length > 0)
{
TreeNode nonPublicStaticNode = new TreeNode(
null,
"NonPublicStaticMembers",
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicStatic)
);
childs = Utils.PrependNode(nonPublicStaticNode, childs);
}
yield return(new TreeNode(
null,
"StaticMembers",
string.Empty,
string.Empty,
childs
));
}
DebugType iListType = (DebugType)shownType.GetInterface(typeof(IList).FullName);
if (iListType != null)
{
yield return(new IListNode(targetObject));
}
else
{
DebugType iEnumerableType, itemType;
if (shownType.ResolveIEnumerableImplementation(out iEnumerableType, out itemType))
{
yield return(new IEnumerableNode(targetObject, itemType));
}
}
foreach (TreeNode node in LazyGetMembersOfObject(targetObject, publicInstance))
{
yield return(node);
}
}
protected void OnDebugFps(bool enabled)
{
_debugType = enabled ? DebugType.Fps : DebugType.None;
}
public static Eval AsyncNewArray(DebugType type, uint length, uint? lowerBound)
{
lowerBound = lowerBound ?? 0;
return new Eval(
type.AppDomain,
"New array: " + type + "[" + length + "]",
delegate(Eval eval) {
// Multi-dimensional arrays not supported in .NET 2.0
eval.CorEval2.NewParameterizedArray(type.CorType, 1, new uint[] { length }, new uint[] { lowerBound.Value });
}
);
}
public static void D(DebugType type, string msg)
{
D(String.Format("<color=#00ffff>[{0}]</color>{1}", type.ToString(), msg));
}
public override bool Execute(out IList <Exception> thrownExceptions)
{
thrownExceptions = null;
LoggingHelper.LogMessage(Normal, $"{new string(' ', 0)}Preparing debug code for xamlc, assembly: {Assembly}");
var resolver = new DefaultAssemblyResolver();
if (!string.IsNullOrEmpty(DependencyPaths))
{
foreach (var dep in DependencyPaths.Split(';'))
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {dep}");
resolver.AddSearchDirectory(dep);
}
}
if (!string.IsNullOrEmpty(ReferencePath))
{
var paths = ReferencePath.Replace("//", "/").Split(';');
foreach (var p in paths)
{
var searchpath = Path.GetDirectoryName(p);
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Adding searchpath {searchpath}");
resolver.AddSearchDirectory(searchpath);
}
}
var debug = DebugSymbols || (!string.IsNullOrEmpty(DebugType) && DebugType.ToLowerInvariant() != "none");
using (var assemblyDefinition = AssemblyDefinition.ReadAssembly(Assembly, new ReaderParameters {
ReadWrite = true,
ReadSymbols = debug,
AssemblyResolver = resolver
})) {
foreach (var module in assemblyDefinition.Modules)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 2)}Module: {module.Name}");
foreach (var resource in module.Resources.OfType <EmbeddedResource>())
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 4)}Resource: {resource.Name}");
if (!resource.IsXaml(module, out var classname))
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}skipped.");
continue;
}
TypeDefinition typeDef = module.GetType(classname);
if (typeDef == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no type found... skipped.");
continue;
}
var initComp = typeDef.Methods.FirstOrDefault(md => md.Name == "InitializeComponent");
if (initComp == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}no InitializeComponent found... skipped.");
continue;
}
var initCompRuntime = typeDef.Methods.FirstOrDefault(md => md.Name == "__InitComponentRuntime");
if (initCompRuntime == null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Creating empty {typeDef.Name}.__InitComponentRuntime");
initCompRuntime = new MethodDefinition("__InitComponentRuntime", initComp.Attributes, initComp.ReturnType);
initCompRuntime.Body.InitLocals = true;
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Copying body of InitializeComponent to __InitComponentRuntime");
initCompRuntime.Body = new MethodBody(initCompRuntime);
var iCRIl = initCompRuntime.Body.GetILProcessor();
foreach (var instr in initComp.Body.Instructions)
{
iCRIl.Append(instr);
}
initComp.Body.Instructions.Clear();
initComp.Body.GetILProcessor().Emit(OpCodes.Ret);
typeDef.Methods.Add(initCompRuntime);
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
// IL_0000: ldarg.0
// IL_0001: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.ContentPage::'.ctor'()
//
// IL_0006: nop
// IL_0007: ldarg.1
// IL_0008: brfalse IL_0018
//
// IL_000d: ldarg.0
// IL_000e: callvirt instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::InitializeComponent()
// IL_0013: br IL_001e
//
// IL_0018: ldarg.0
// IL_0019: callvirt instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::__InitComponentRuntime()
// IL_001e: ret
var altCtor = typeDef.Methods.FirstOrDefault(md => md.IsConstructor &&
md.Parameters.Count == 1 &&
md.Parameters[0].ParameterType == module.TypeSystem.Boolean);
if (altCtor != null)
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Replacing body of {typeDef.Name}.{typeDef.Name} (bool {altCtor.Parameters[0].Name})");
}
else
{
LoggingHelper.LogMessage(Low, $"{new string(' ', 6)}Adding {typeDef.Name}.{typeDef.Name} (bool useCompiledXaml)");
altCtor = new MethodDefinition(".ctor",
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName, module.TypeSystem.Void);
altCtor.Parameters.Add(new ParameterDefinition("useCompiledXaml", ParameterAttributes.None,
module.TypeSystem.Boolean));
}
var body = new MethodBody(altCtor)
{
InitLocals = true
};
var il = body.GetILProcessor();
var br2 = Instruction.Create(OpCodes.Ldarg_0);
var ret = Instruction.Create(OpCodes.Ret);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt,
module.ImportReference(typeDef.BaseType.Resolve().GetConstructors().First(c => c.HasParameters == false)));
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Brfalse, br2);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, initComp);
il.Emit(OpCodes.Br, ret);
il.Append(br2);
il.Emit(OpCodes.Callvirt, initCompRuntime);
il.Append(ret);
altCtor.Body = body;
if (!typeDef.Methods.Contains(altCtor))
{
typeDef.Methods.Add(altCtor);
}
LoggingHelper.LogMessage(Low, $"{new string(' ', 8)}done.");
}
}
LoggingHelper.LogMessage(Normal, $"{new string(' ', 0)}Writing the assembly.");
assemblyDefinition.Write(new WriterParameters {
WriteSymbols = debug
});
}
LoggingHelper.LogMessage(Normal, $"{new string(' ', 2)}done.");
return(true);
}
void EvaluateExpression()
{
evaluated = true;
Value val;
try {
var process = WindowsDebugger.DebuggedProcess;
if (process == null)
{
return;
}
StackFrame frame = process.GetCurrentExecutingFrame();
if (frame == null)
{
return;
}
var debugger = (WindowsDebugger)DebuggerService.CurrentDebugger;
object data = debugger.debuggerDecompilerService.GetLocalVariableIndex(frame.MethodInfo.DeclaringType.MetadataToken,
frame.MethodInfo.MetadataToken,
Name);
if (expression is MemberReferenceExpression)
{
var memberExpression = (MemberReferenceExpression)expression;
memberExpression.TargetObject.UserData = data;
}
else
{
expression.UserData = data;
}
// evaluate expression
val = expression.Evaluate(process);
} catch (GetValueException e) {
error = e;
this.Text = e.Message;
return;
}
this.canSetText = val.Type.IsPrimitive;
this.expressionType = val.Type;
this.Type = val.Type.Name;
this.valueIsNull = val.IsNull;
// Note that these return enumerators so they are lazy-evaluated
if (val.IsNull)
{
}
else if (val.Type.IsPrimitive || val.Type.FullName == typeof(string).FullName) // Must be before IsClass
{
}
else if (val.Type.IsArray) // Must be before IsClass
{
if (val.ArrayLength > 0)
{
this.childNodes = Utils.LazyGetChildNodesOfArray(this, this.Expression, val.ArrayDimensions);
}
}
else if (val.Type.IsClass || val.Type.IsValueType)
{
if (val.Type.FullNameWithoutGenericArguments == typeof(List <>).FullName)
{
if ((int)val.GetMemberValue("_size").PrimitiveValue > 0)
{
this.childNodes = Utils.LazyGetItemsOfIList(this, this.expression);
}
}
else
{
this.childNodes = Utils.LazyGetChildNodesOfObject(this, this.Expression, val.Type);
}
}
else if (val.Type.IsPointer)
{
Value deRef = val.Dereference();
if (deRef != null)
{
this.childNodes = new ExpressionNode [] { new ExpressionNode(this, this.IconImage, "*" + this.Name, this.Expression.AppendDereference()) };
}
}
if (DebuggingOptions.Instance.ICorDebugVisualizerEnabled)
{
TreeNode info = ICorDebug.GetDebugInfoRoot(val.AppDomain, val.CorValue);
this.childNodes = Utils.PrependNode(info, this.ChildNodes);
}
// Do last since it may expire the object
if (val.Type.IsInteger)
{
fullText = FormatInteger(val.PrimitiveValue);
}
else if (val.Type.IsPointer)
{
fullText = String.Format("0x{0:X}", val.PointerAddress);
}
else if ((val.Type.FullName == typeof(string).FullName ||
val.Type.FullName == typeof(char).FullName) && !val.IsNull)
{
try {
fullText = '"' + Escape(val.InvokeToString()) + '"';
} catch (GetValueException e) {
error = e;
fullText = e.Message;
return;
}
}
else if ((val.Type.IsClass || val.Type.IsValueType) && !val.IsNull)
{
try {
fullText = val.InvokeToString();
} catch (GetValueException e) {
error = e;
fullText = e.Message;
return;
}
}
else
{
fullText = val.AsString();
}
this.Text = (fullText.Length > 256) ? fullText.Substring(0, 256) + "..." : fullText;
}
private void DebugMessageCallback(DebugSource source, DebugType type, int id, DebugSeverity severity,
int length, IntPtr message, IntPtr userParam)
{
var contents = $"{source}: " + Marshal.PtrToStringAnsi(message, length);
var category = "ogl.debug";
switch (type)
{
case DebugType.DebugTypePerformance:
category += ".performance";
break;
case DebugType.DebugTypeOther:
category += ".other";
break;
case DebugType.DebugTypeError:
category += ".error";
break;
case DebugType.DebugTypeDeprecatedBehavior:
category += ".deprecated";
break;
case DebugType.DebugTypeUndefinedBehavior:
category += ".ub";
break;
case DebugType.DebugTypePortability:
category += ".portability";
break;
case DebugType.DebugTypeMarker:
case DebugType.DebugTypePushGroup:
case DebugType.DebugTypePopGroup:
// These are inserted by our own code so I imagine they're not necessary to log?
return;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
var sawmill = _logManager.GetSawmill(category);
switch (severity)
{
case DebugSeverity.DontCare:
sawmill.Info(contents);
break;
case DebugSeverity.DebugSeverityNotification:
sawmill.Info(contents);
break;
case DebugSeverity.DebugSeverityHigh:
sawmill.Error(contents);
break;
case DebugSeverity.DebugSeverityMedium:
sawmill.Error(contents);
break;
case DebugSeverity.DebugSeverityLow:
sawmill.Warning(contents);
break;
default:
throw new ArgumentOutOfRangeException(nameof(severity), severity, null);
}
}
public static Value NewArray(DebugType type, uint length, uint? lowerBound)
{
return AsyncNewArray(type, length, lowerBound).WaitForResult();
}
public abstract void DebugMessageControl([Flow(FlowDirection.In)] DebugSource source, [Flow(FlowDirection.In)] DebugType type, [Flow(FlowDirection.In)] DebugSeverity severity, [Flow(FlowDirection.In)] uint count, [Flow(FlowDirection.In)] Span <uint> ids, [Flow(FlowDirection.In)] bool enabled);
public static Eval AsyncNewObjectNoConstructor(DebugType debugType)
{
return new Eval(
debugType.AppDomain,
"New object: " + debugType.FullName,
delegate(Eval eval) {
eval.CorEval2.NewParameterizedObjectNoConstructor(debugType.CorType.GetClass(), (uint)debugType.GetGenericArguments().Length, debugType.GenericArgumentsAsCorDebugType);
}
);
}
public abstract void DebugMessageInsert([Flow(FlowDirection.In)] DebugSource source, [Flow(FlowDirection.In)] DebugType type, [Flow(FlowDirection.In)] uint id, [Flow(FlowDirection.In)] DebugSeverity severity, [Flow(FlowDirection.In)] uint length, [Flow(FlowDirection.In)] string buf);
public static Value NewObjectNoConstructor(DebugType debugType)
{
return(AsyncNewObjectNoConstructor(debugType).WaitForResult());
}
private static void DebugCallback(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam)
{
string debugMessage = Marshal.PtrToStringAnsi(message, length);
Debug.WriteLine($"{severity} {type} {debugMessage}");
}
public static Eval AsyncNewObjectNoConstructor(DebugType debugType)
{
return CreateEval(
debugType.Process,
"New object: " + debugType.FullName,
delegate(Eval eval) {
eval.CorEval.CastTo<ICorDebugEval2>().NewParameterizedObjectNoConstructor(debugType.CorType.Class, (uint)debugType.GenericArguments.Count, debugType.GenericArgumentsAsCorDebugType);
}
);
}
/// <summary>
/// Retrives a number of messages from message log.
/// How many retrives is determined by Math.Min([all arrays]) and availible messages.
/// </summary>
/// <param name="sources"></param>
/// <param name="types"></param>
/// <param name="ids"></param>
/// <param name="severities"></param>
/// <param name="lengths"></param>
/// <param name="messageLog">A single preallocated stringbuilder with enough capacity to contain all the messages?</param>
/// <returns></returns>
public static uint GetDebugMessageLogARB(DebugSource[] sources, DebugType[] types, uint[] ids, DebugSeverity[] severities, int[] lengths, StringBuilder messageLog)
{
var count = Math.Min(sources.Length, Math.Min(types.Length, Math.Min(ids.Length, Math.Min(severities.Length, lengths.Length))));
return Delegates.glGetDebugMessageLogARB((uint)count, messageLog.Capacity, ref sources[0], ref types[0], ref ids[0], ref severities[0], ref lengths[0], messageLog);
}
TypedValue EvaluateAs(INode expression, DebugType type)
{
TypedValue val = Evaluate(expression);
if (val.Type == type)
return val;
if (!val.Type.CanImplicitelyConvertTo(type))
throw new EvaluateException(expression, "Can not implicitely cast {0} to {1}", val.Type.FullName, type.FullName);
if (type.IsPrimitive) {
object oldVal = val.PrimitiveValue;
object newVal;
try {
newVal = Convert.ChangeType(oldVal, type.PrimitiveType);
} catch (InvalidCastException) {
throw new EvaluateException(expression, "Can not cast {0} to {1}", val.GetType().FullName, type.FullName);
} catch (OverflowException) {
throw new EvaluateException(expression, "Overflow");
}
return CreateValue(newVal);
} else {
return new TypedValue(val.Value, type);
}
}
/// <summary>
/// Insert a new debug message in the debug message log array.
/// </summary>
/// <param name="source">Source of inserted message.</param>
/// <param name="type">type of inserted message.</param>
/// <param name="id">id of inserted message. Userid has own range of ids.</param>
/// <param name="severity">Severity of inserted message.</param>
/// <param name="Text">The text of inserted message.</param>
public static void DebugMessageInsertARB(DebugSource source, DebugType type, uint id, DebugSeverity severity, string Text)
{
Delegates.glDebugMessageInsertARB(source, type, id, severity, Text.Length, Text);
}
/// <summary>
/// Bind properties.
/// </summary>
protected override void BindProperties()
{
if (this.ProjectMgr == null)
{
return;
}
string type = "";
type= getCfgString(nameof(DebugType), DebugType.none.ToString());
if (type != null && type.Length > 0)
{
try
{
this.debugtype = (DebugType)Enum.Parse(typeof(DebugType), type);
}
catch (ArgumentException)
{
this.debugtype = DebugType.none;
}
}
debuggercommand = getCfgString(nameof(DebuggerCommand), "$(TargetPath)");
debuggercommandarguments = getCfgString(nameof(DebuggerCommandArguments), "");
debuggerworkingdirectory= getCfgString(nameof(DebuggerWorkingDirectory), "");
debuggerattach= getCfgLogic(nameof(DebuggerAttach), false);
enableunmanageddebugging = getCfgLogic(nameof(EnableUnmanagedDebugging), true);
usevshostingprocess = getCfgLogic(nameof(UseVSHostingProcess), true);
}
public static void LogError(DebugType debugType, object message)
{
if(EnumExtensions.IsFlagSet(DebugType.Error, debugType)) {
Debug.LogError(message);
}
}
public static IEnumerable<TreeNode> LazyGetChildNodesOfObject(Expression targetObject, DebugType shownType)
{
MemberInfo[] publicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] publicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
DebugType baseType = (DebugType)shownType.BaseType;
if (baseType != null) {
yield return new TreeNode(
ImageService.GetImage("Icons.16x16.Class"),
"BaseClass",
baseType.Name,
baseType.FullName,
baseType.FullName == "System.Object" ? null : Utils.LazyGetChildNodesOfObject(targetObject, baseType)
);
}
if (nonPublicInstance.Length > 0) {
yield return new TreeNode(
null,
"NonPublicMembers",
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicInstance)
);
}
if (publicStatic.Length > 0 || nonPublicStatic.Length > 0) {
IEnumerable<TreeNode> childs = Utils.LazyGetMembersOfObject(targetObject, publicStatic);
if (nonPublicStatic.Length > 0) {
TreeNode nonPublicStaticNode = new TreeNode(
null,
"NonPublicStaticMembers",
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicStatic)
);
childs = Utils.PrependNode(nonPublicStaticNode, childs);
}
yield return new TreeNode(
null,
"StaticMembers",
string.Empty,
string.Empty,
childs
);
}
DebugType iListType = (DebugType)shownType.GetInterface(typeof(IList).FullName);
if (iListType != null) {
yield return new IListNode(targetObject);
} else {
DebugType iEnumerableType, itemType;
if (shownType.ResolveIEnumerableImplementation(out iEnumerableType, out itemType)) {
yield return new IEnumerableNode(targetObject, itemType);
}
}
foreach(TreeNode node in LazyGetMembersOfObject(targetObject, publicInstance)) {
yield return node;
}
}
private void uDebugLogAdd(string _log, DebugType debugType = DebugType.INFO, [CallerMemberName] string caller = "")
{
Toolbox.uAddDebugLog(_log, debugType, caller);
}
/// <summary>
/// Changes the properties of an array of debug message ids.
/// This might be source, type, severity or just enable/disable them.
/// Enables or Disables an array of Debug Messages ids
/// </summary>
/// <param name="source">Source of ids.</param>
/// <param name="type">Type of ids</param>
/// <param name="severity">Severity of ids.</param>
/// <param name="ids">array of ids to change.</param>
/// <param name="Enabled">Enables or disables the ids.</param>
public static void DebugMessageControlARB(DebugSource source, DebugType type, DebugSeverity severity, uint[] ids, bool Enabled)
{
Delegates.glDebugMessageControlARB(source, type, severity, ids.Length, ref ids[0], Enabled);
}
public static List <TreeNode> GetDebugInfo(AppDomain appDomain, ICorDebugValue corValue)
{
List <TreeNode> items = new List <TreeNode>();
if (corValue is ICorDebugValue)
{
InfoNode info = new InfoNode("ICorDebugValue", "");
info.AddChild("Address", corValue.GetAddress().ToString("X8"));
info.AddChild("Type", ((CorElementType)corValue.GetTheType()).ToString());
info.AddChild("Size", corValue.GetSize().ToString());
items.Add(info);
}
if (corValue is ICorDebugValue2)
{
InfoNode info = new InfoNode("ICorDebugValue2", "");
ICorDebugValue2 corValue2 = (ICorDebugValue2)corValue;
string fullname;
try {
fullname = DebugType.CreateFromCorType(appDomain, corValue2.GetExactType()).FullName;
} catch (DebuggerException e) {
fullname = e.Message;
}
info.AddChild("ExactType", fullname);
items.Add(info);
}
if (corValue is ICorDebugGenericValue)
{
InfoNode info = new InfoNode("ICorDebugGenericValue", "");
try {
byte[] bytes = ((ICorDebugGenericValue)corValue).GetRawValue();
for (int i = 0; i < bytes.Length; i += 8)
{
string val = "";
for (int j = i; j < bytes.Length && j < i + 8; j++)
{
val += bytes[j].ToString("X2") + " ";
}
info.AddChild("Value" + i.ToString("X2"), val);
}
} catch (System.ArgumentException) {
info.AddChild("Value", "N/A");
}
items.Add(info);
}
if (corValue is ICorDebugReferenceValue)
{
InfoNode info = new InfoNode("ICorDebugReferenceValue", "");
ICorDebugReferenceValue refValue = (ICorDebugReferenceValue)corValue;
info.AddChild("IsNull", (refValue.IsNull() != 0).ToString());
if (refValue.IsNull() == 0)
{
info.AddChild("Value", refValue.GetValue().ToString("X8"));
if (refValue.Dereference() != null)
{
info.AddChild("Dereference", "", GetDebugInfo(appDomain, refValue.Dereference()));
}
else
{
info.AddChild("Dereference", "N/A");
}
}
items.Add(info);
}
if (corValue is ICorDebugHeapValue)
{
InfoNode info = new InfoNode("ICorDebugHeapValue", "");
items.Add(info);
}
if (corValue is ICorDebugHeapValue2)
{
InfoNode info = new InfoNode("ICorDebugHeapValue2", "");
items.Add(info);
}
if (corValue is ICorDebugObjectValue)
{
InfoNode info = new InfoNode("ICorDebugObjectValue", "");
ICorDebugObjectValue objValue = (ICorDebugObjectValue)corValue;
info.AddChild("Class", objValue.GetClass().GetToken().ToString("X8"));
info.AddChild("IsValueClass", (objValue.IsValueClass() != 0).ToString());
items.Add(info);
}
if (corValue is ICorDebugObjectValue2)
{
InfoNode info = new InfoNode("ICorDebugObjectValue2", "");
items.Add(info);
}
if (corValue is ICorDebugBoxValue)
{
InfoNode info = new InfoNode("ICorDebugBoxValue", "");
ICorDebugBoxValue boxValue = (ICorDebugBoxValue)corValue;
info.AddChild("Object", "", GetDebugInfo(appDomain, boxValue.GetObject()));
items.Add(info);
}
if (corValue is ICorDebugStringValue)
{
InfoNode info = new InfoNode("ICorDebugStringValue", "");
ICorDebugStringValue stringValue = (ICorDebugStringValue)corValue;
info.AddChild("Length", stringValue.GetLength().ToString());
info.AddChild("String", stringValue.GetString());
items.Add(info);
}
if (corValue is ICorDebugArrayValue)
{
InfoNode info = new InfoNode("ICorDebugArrayValue", "");
info.AddChild("…", "…");
items.Add(info);
}
if (corValue is ICorDebugHandleValue)
{
InfoNode info = new InfoNode("ICorDebugHandleValue", "");
ICorDebugHandleValue handleValue = (ICorDebugHandleValue)corValue;
info.AddChild("HandleType", handleValue.GetHandleType().ToString());
items.Add(info);
}
return(items);
}
void EvaluateExpression()
{
evaluated = true;
Value val;
try {
var frame = WindowsDebugger.DebuggedProcess.SelectedThread.MostRecentStackFrame;
var key = frame.MethodInfo.ToMethodKey();
// get the target name
int index = Name.IndexOf('.');
string targetName = Name;
if (index != -1) {
targetName = Name.Substring(0, index);
}
// get local variable index
MemberMapping mapping;
var textView = MainWindow.Instance.ActiveTextView;
var cm = textView == null ? null : textView.CodeMappings;
if (cm != null && cm.TryGetValue(key, out mapping)) {
var variable = mapping.LocalVariables == null ? null : mapping.LocalVariables.FirstOrDefault(v => v.Name == targetName);
if (variable != null && variable.OriginalVariable != null) {
if (expression is MemberReferenceExpression) {
var memberExpression = (MemberReferenceExpression)expression;
memberExpression.Target.AddAnnotation(new [] { variable.OriginalVariable.Index });
} else {
expression.AddAnnotation(new [] { variable.OriginalVariable.Index });
}
}
}
// evaluate expression
val = expression.Evaluate(WindowsDebugger.DebuggedProcess);
} catch (GetValueException e) {
error = e;
this.Text = e.Message;
return;
}
this.canSetText = val.Type.IsPrimitive || val.Type.FullName == typeof(string).FullName;
this.expressionType = val.Type;
this.Type = val.Type.Name;
this.valueIsNull = val.IsNull;
// Note that these return enumerators so they are lazy-evaluated
if (val.IsNull) {
} else if (val.Type.IsPrimitive || val.Type.FullName == typeof(string).FullName) { // Must be before IsClass
} else if (val.Type.IsArray) { // Must be before IsClass
if (val.ArrayLength > 0)
this.ChildNodes = Utils.LazyGetChildNodesOfArray(this.Expression, val.ArrayDimensions);
} else if (val.Type.IsClass || val.Type.IsValueType) {
if (val.Type.FullNameWithoutGenericArguments == typeof(List<>).FullName) {
if ((int)val.GetMemberValue("_size").PrimitiveValue > 0)
this.ChildNodes = Utils.LazyGetItemsOfIList(this.expression);
} else {
this.ChildNodes = Utils.LazyGetChildNodesOfObject(this.Expression, val.Type);
}
} else if (val.Type.IsPointer) {
Value deRef = val.Dereference();
if (deRef != null) {
this.ChildNodes = new ExpressionNode [] { new ExpressionNode(this.ImageSource, "*" + this.Name, this.Expression.AppendDereference()) };
}
}
// if (DebuggingOptions.Instance.ICorDebugVisualizerEnabled) {
// TreeNode info = ICorDebug.GetDebugInfoRoot(val.AppDomain, val.CorValue);
// this.ChildNodes = Utils.PrependNode(info, this.ChildNodes);
// }
// Do last since it may expire the object
if (val.Type.IsInteger) {
fullText = FormatInteger(val.PrimitiveValue);
} else if (val.Type.IsPointer) {
fullText = String.Format("0x{0:X}", val.PointerAddress);
} else if ((val.Type.FullName == typeof(string).FullName ||
val.Type.FullName == typeof(char).FullName) && !val.IsNull) {
try {
fullText = '"' + Escape(val.InvokeToString()) + '"';
} catch (GetValueException e) {
error = e;
fullText = e.Message;
return;
}
} else if ((val.Type.IsClass || val.Type.IsValueType) && !val.IsNull) {
try {
fullText = val.InvokeToString();
} catch (GetValueException e) {
error = e;
fullText = e.Message;
return;
}
} else {
fullText = val.AsString();
}
this.Text = (fullText.Length > 256) ? fullText.Substring(0, 256) + "…" : fullText;
}
public static IEnumerable <TreeNode> LazyGetChildNodesOfObject(Expression targetObject, DebugType shownType)
{
MemberInfo[] publicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] publicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
DebugType baseType = (DebugType)shownType.BaseType;
if (baseType != null)
{
if (Variables.Langue == "en")
{
yield return(new TreeNode(
Properties.Resources._namespace,
StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_BaseClass_EN),
baseType.Name,
baseType.FullName,
baseType.FullName == "System.Object" ? null : Utils.LazyGetChildNodesOfObject(targetObject, baseType)
));
}
else
{
yield return(new TreeNode(
Properties.Resources._namespace,
StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_BaseClass),
baseType.Name,
baseType.FullName,
baseType.FullName == "System.Object" ? null : Utils.LazyGetChildNodesOfObject(targetObject, baseType)
));
}
}
// if (nonPublicInstance.Length > 0) {
// if (Variables.Langue == "en")
// {
// yield return new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_NonPublicMembers_EN),
// string.Empty,
// string.Empty,
// Utils.LazyGetMembersOfObject(targetObject, nonPublicInstance)
// );
// }
// else
// {
// yield return new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_NonPublicMembers),
// string.Empty,
// string.Empty,
// Utils.LazyGetMembersOfObject(targetObject, nonPublicInstance)
// );
// }
// }
//
// if (publicStatic.Length > 0 || nonPublicStatic.Length > 0) {
// IEnumerable<TreeNode> childs = Utils.LazyGetMembersOfObject(targetObject, publicStatic);
// if (nonPublicStatic.Length > 0) {
// if (Variables.Langue == "en")
// {
// TreeNode nonPublicStaticNode = new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_NonPublicStaticMembers_EN),
// string.Empty,
// string.Empty,
// Utils.LazyGetMembersOfObject(targetObject, nonPublicStatic)
// );
// childs = Utils.PrependNode(nonPublicStaticNode, childs);
// }
// else
// {
// TreeNode nonPublicStaticNode = new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_NonPublicStaticMembers),
// string.Empty,
// string.Empty,
// Utils.LazyGetMembersOfObject(targetObject, nonPublicStatic)
// );
// childs = Utils.PrependNode(nonPublicStaticNode, childs);
// }
// }
// if (Variables.Langue == "en")
// {
// yield return new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_StaticMembers_EN),
// string.Empty,
// string.Empty,
// childs
// );
// }
// else
// {
// yield return new TreeNode(
// null,
// StringParser.Parse(VelerSoftware.SZC.Properties.Resources.MainWindow_Windows_Debug_LocalVariables_StaticMembers),
// string.Empty,
// string.Empty,
// childs
// );
// }
// }
DebugType iListType = (DebugType)shownType.GetInterface(typeof(IList).FullName);
if (iListType != null)
{
yield return(new IListNode(targetObject));
}
else
{
DebugType iEnumerableType, itemType;
if (shownType.ResolveIEnumerableImplementation(out iEnumerableType, out itemType))
{
yield return(new IEnumerableNode(targetObject, itemType));
}
}
foreach (TreeNode node in LazyGetMembersOfObject(targetObject, publicInstance))
{
yield return(node);
}
}
public static void LogWarning(DebugType debugType, object message)
{
if(EnumExtensions.IsFlagSet(DebugType.Warning, debugType)) {
Debug.LogWarning(message);
}
}
private void ExpansionGUIWindow(int windowId)
{
GUI.DragWindow(new Rect(0, 0, 10000, 20));
#region title
GUILayout.BeginHorizontal();
GUI.contentColor = _fpsColor;
if (GUILayout.Button("FPS:" + _fps, GUILayout.Height(30)))
{
_expansion = false;
_windowRect.width = 100;
_windowRect.height = 60;
}
GUI.contentColor = (_debugType == DebugType.Console ? Color.white : Color.gray);
if (GUILayout.Button("Console", GUILayout.Height(30)))
{
_debugType = DebugType.Console;
}
GUI.contentColor = (_debugType == DebugType.Memory ? Color.white : Color.gray);
if (GUILayout.Button("Memory", GUILayout.Height(30)))
{
_debugType = DebugType.Memory;
}
GUI.contentColor = (_debugType == DebugType.System ? Color.white : Color.gray);
if (GUILayout.Button("System", GUILayout.Height(30)))
{
_debugType = DebugType.System;
}
GUI.contentColor = (_debugType == DebugType.Screen ? Color.white : Color.gray);
if (GUILayout.Button("Screen", GUILayout.Height(30)))
{
_debugType = DebugType.Screen;
}
GUI.contentColor = (_debugType == DebugType.Quality ? Color.white : Color.gray);
if (GUILayout.Button("Quality", GUILayout.Height(30)))
{
_debugType = DebugType.Quality;
}
GUI.contentColor = (_debugType == DebugType.Environment ? Color.white : Color.gray);
if (GUILayout.Button("Environment", GUILayout.Height(30)))
{
_debugType = DebugType.Environment;
}
GUI.contentColor = Color.white;
GUILayout.EndHorizontal();
#endregion
#region console
if (_debugType == DebugType.Console)
{
GUILayout.BeginHorizontal();
if (GUILayout.Button("Clear"))
{
_logInformations.Clear();
_fatalLogCount = 0;
_warningLogCount = 0;
_errorLogCount = 0;
_infoLogCount = 0;
_currentLogIndex = -1;
_fpsColor = Color.white;
}
GUI.contentColor = (_showInfoLog ? Color.white : Color.gray);
_showInfoLog = GUILayout.Toggle(_showInfoLog, "Info [" + _infoLogCount + "]");
GUI.contentColor = (_showWarningLog ? Color.white : Color.gray);
_showWarningLog = GUILayout.Toggle(_showWarningLog, "Warning [" + _warningLogCount + "]");
GUI.contentColor = (_showErrorLog ? Color.white : Color.gray);
_showErrorLog = GUILayout.Toggle(_showErrorLog, "Error [" + _errorLogCount + "]");
GUI.contentColor = (_showFatalLog ? Color.white : Color.gray);
_showFatalLog = GUILayout.Toggle(_showFatalLog, "Fatal [" + _fatalLogCount + "]");
GUI.contentColor = Color.white;
GUILayout.EndHorizontal();
_scrollLogView = GUILayout.BeginScrollView(_scrollLogView, "Box", GUILayout.Height(165));
for (int i = 0; i < _logInformations.Count; i++)
{
bool show = false;
Color color = Color.white;
switch (_logInformations[i].type)
{
case "Fatal":
show = _showFatalLog;
color = Color.red;
break;
case "Error":
show = _showErrorLog;
color = Color.red;
break;
case "Info":
show = _showInfoLog;
color = Color.white;
break;
case "Warning":
show = _showWarningLog;
color = Color.yellow;
break;
default:
break;
}
if (show)
{
GUILayout.BeginHorizontal();
if (GUILayout.Toggle(_currentLogIndex == i, ""))
{
_currentLogIndex = i;
}
GUI.contentColor = color;
GUILayout.Label("[" + _logInformations[i].type + "] ");
GUILayout.Label("[" + _logInformations[i].time + "] ");
GUILayout.Label(_logInformations[i].message);
GUILayout.FlexibleSpace();
GUI.contentColor = Color.white;
GUILayout.EndHorizontal();
}
}
GUILayout.EndScrollView();
_scrollCurrentLogView = GUILayout.BeginScrollView(_scrollCurrentLogView, "Box", GUILayout.Height(100));
if (_currentLogIndex != -1)
{
GUILayout.Label(_logInformations[_currentLogIndex].message + "\r\n\r\n" + _logInformations[_currentLogIndex].stackTrace);
}
GUILayout.EndScrollView();
}
#endregion
#region memory
else if (_debugType == DebugType.Memory)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Memory Information");
GUILayout.EndHorizontal();
GUILayout.BeginVertical("Box");
#if UNITY_5
GUILayout.Label("总内存：" + Profiler.GetTotalReservedMemory() / 1000000 + "MB");
GUILayout.Label("已占用内存：" + Profiler.GetTotalAllocatedMemory() / 1000000 + "MB");
GUILayout.Label("空闲中内存：" + Profiler.GetTotalUnusedReservedMemory() / 1000000 + "MB");
GUILayout.Label("总Mono堆内存：" + Profiler.GetMonoHeapSize() / 1000000 + "MB");
GUILayout.Label("已占用Mono堆内存：" + Profiler.GetMonoUsedSize() / 1000000 + "MB");
#endif
#if UNITY_7
GUILayout.Label("总内存：" + Profiler.GetTotalReservedMemoryLong() / 1000000 + "MB");
GUILayout.Label("已占用内存：" + Profiler.GetTotalAllocatedMemoryLong() / 1000000 + "MB");
GUILayout.Label("空闲中内存：" + Profiler.GetTotalUnusedReservedMemoryLong() / 1000000 + "MB");
GUILayout.Label("总Mono堆内存：" + Profiler.GetMonoHeapSizeLong() / 1000000 + "MB");
GUILayout.Label("已占用Mono堆内存：" + Profiler.GetMonoUsedSizeLong() / 1000000 + "MB");
#endif
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
if (GUILayout.Button("卸载未使用的资源"))
{
Resources.UnloadUnusedAssets();
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button("使用GC垃圾回收"))
{
GC.Collect();
}
GUILayout.EndHorizontal();
}
#endregion
#region system
else if (_debugType == DebugType.System)
{
GUILayout.BeginHorizontal();
GUILayout.Label("System Information");
GUILayout.EndHorizontal();
_scrollSystemView = GUILayout.BeginScrollView(_scrollSystemView, "Box");
GUILayout.Label("操作系统：" + SystemInfo.operatingSystem);
GUILayout.Label("系统内存：" + SystemInfo.systemMemorySize + "MB");
GUILayout.Label("处理器：" + SystemInfo.processorType);
GUILayout.Label("处理器数量：" + SystemInfo.processorCount);
GUILayout.Label("显卡：" + SystemInfo.graphicsDeviceName);
GUILayout.Label("显卡类型：" + SystemInfo.graphicsDeviceType);
GUILayout.Label("显存：" + SystemInfo.graphicsMemorySize + "MB");
GUILayout.Label("显卡标识：" + SystemInfo.graphicsDeviceID);
GUILayout.Label("显卡供应商：" + SystemInfo.graphicsDeviceVendor);
GUILayout.Label("显卡供应商标识码：" + SystemInfo.graphicsDeviceVendorID);
GUILayout.Label("设备模式：" + SystemInfo.deviceModel);
GUILayout.Label("设备名称：" + SystemInfo.deviceName);
GUILayout.Label("设备类型：" + SystemInfo.deviceType);
GUILayout.Label("设备标识：" + SystemInfo.deviceUniqueIdentifier);
GUILayout.EndScrollView();
}
#endregion
#region screen
else if (_debugType == DebugType.Screen)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Screen Information");
GUILayout.EndHorizontal();
GUILayout.BeginVertical("Box");
GUILayout.Label("DPI：" + Screen.dpi);
GUILayout.Label("分辨率：" + Screen.currentResolution.ToString());
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
if (GUILayout.Button("全屏"))
{
Screen.SetResolution(Screen.currentResolution.width, Screen.currentResolution.height, !Screen.fullScreen);
}
GUILayout.EndHorizontal();
}
#endregion
#region Quality
else if (_debugType == DebugType.Quality)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Quality Information");
GUILayout.EndHorizontal();
GUILayout.BeginVertical("Box");
string value = "";
if (QualitySettings.GetQualityLevel() == 0)
{
value = " [最低]";
}
else if (QualitySettings.GetQualityLevel() == QualitySettings.names.Length - 1)
{
value = " [最高]";
}
GUILayout.Label("图形质量：" + QualitySettings.names[QualitySettings.GetQualityLevel()] + value);
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
if (GUILayout.Button("降低一级图形质量"))
{
QualitySettings.DecreaseLevel();
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
if (GUILayout.Button("提升一级图形质量"))
{
QualitySettings.IncreaseLevel();
}
GUILayout.EndHorizontal();
}
#endregion
#region Environment
else if (_debugType == DebugType.Environment)
{
GUILayout.BeginHorizontal();
GUILayout.Label("Environment Information");
GUILayout.EndHorizontal();
GUILayout.BeginVertical("Box");
GUILayout.Label("项目名称：" + Application.productName);
#if UNITY_5
GUILayout.Label("项目ID：" + Application.bundleIdentifier);
#endif
#if UNITY_7
GUILayout.Label("项目ID：" + Application.identifier);
#endif
GUILayout.Label("项目版本：" + Application.version);
GUILayout.Label("Unity版本：" + Application.unityVersion);
GUILayout.Label("公司名称：" + Application.companyName);
GUILayout.EndVertical();
GUILayout.BeginHorizontal();
if (GUILayout.Button("退出程序"))
{
Application.Quit();
}
GUILayout.EndHorizontal();
}
#endregion
}
public static IEnumerable <TreeNode> LazyGetChildNodesOfObject(Expression targetObject, DebugType shownType)
{
MemberInfo[] publicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] publicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicStatic = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
MemberInfo[] nonPublicInstance = shownType.GetFieldsAndNonIndexedProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
DebugType baseType = (DebugType)shownType.BaseType;
if (baseType != null)
{
yield return(new TreeNode(
DebuggerResourceService.GetImage("Icons.16x16.Class"),
StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.BaseClass}"),
baseType.Name,
baseType.FullName,
baseType.FullName == "System.Object" ? null : Utils.LazyGetChildNodesOfObject(targetObject, baseType)
));
}
if (nonPublicInstance.Length > 0)
{
yield return(new TreeNode(
null,
StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.NonPublicMembers}"),
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicInstance)
));
}
if (publicStatic.Length > 0 || nonPublicStatic.Length > 0)
{
IEnumerable <TreeNode> childs = Utils.LazyGetMembersOfObject(targetObject, publicStatic);
if (nonPublicStatic.Length > 0)
{
TreeNode nonPublicStaticNode = new TreeNode(
null,
StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.NonPublicStaticMembers}"),
string.Empty,
string.Empty,
Utils.LazyGetMembersOfObject(targetObject, nonPublicStatic)
);
childs = Utils.PrependNode(nonPublicStaticNode, childs);
}
yield return(new TreeNode(
null,
StringParser.Parse("${res:MainWindow.Windows.Debug.LocalVariables.StaticMembers}"),
string.Empty,
string.Empty,
childs
));
}
DebugType iListType = (DebugType)shownType.GetInterface(typeof(IList).FullName);
if (iListType != null)
{
yield return(new IListNode(targetObject));
}
else
{
DebugType iEnumerableType, itemType;
if (shownType.ResolveIEnumerableImplementation(out iEnumerableType, out itemType))
{
yield return(new IEnumerableNode(targetObject, itemType));
}
}
foreach (TreeNode node in LazyGetMembersOfObject(targetObject, publicInstance))
{
yield return(node);
}
}
public static bool SystemDebugEnabled(AOSystems system, DebugType debugType, IFaction faction)
{
return(SystemDebugEnabled(system, debugType) && FactionInScope(faction, Settings.Instance.DebugFactionScope));
}
