static StackObject *GetStackTraceLogType_37(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.LogType @logType = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = UnityEngine.Application.GetStackTraceLogType(@logType); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
static public ELogLevel ConvertToCustomLogLevel(this UnityEngine.LogType eLogType) { switch (eLogType) { case UnityEngine.LogType.Warning: return(ELogLevel.CustomLine_Warning); case UnityEngine.LogType.Exception: case UnityEngine.LogType.Error: case UnityEngine.LogType.Assert: return(ELogLevel.CustomLine_Error); } return(ELogLevel.CustomLine_Log); }
static int GetStackTraceLogType(IntPtr L) { try { ToLua.CheckArgsCount(L, 1); UnityEngine.LogType arg0 = (UnityEngine.LogType)ToLua.CheckObject(L, 1, typeof(UnityEngine.LogType)); UnityEngine.StackTraceLogType o = UnityEngine.Application.GetStackTraceLogType(arg0); ToLua.Push(L, o); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static int SetStackTraceLogType(IntPtr L) { try { ToLua.CheckArgsCount(L, 2); UnityEngine.LogType arg0 = (UnityEngine.LogType)ToLua.CheckObject(L, 1, typeof(UnityEngine.LogType)); UnityEngine.StackTraceLogType arg1 = (UnityEngine.StackTraceLogType)ToLua.CheckObject(L, 2, typeof(UnityEngine.StackTraceLogType)); UnityEngine.Application.SetStackTraceLogType(arg0, arg1); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static int GetStackTraceLogType(IntPtr L) { try { ToLua.CheckArgsCount(L, 1); UnityEngine.LogType arg0 = (UnityEngine.LogType)LuaDLL.luaL_checknumber(L, 1); var o = UnityEngine.Application.GetStackTraceLogType(arg0); LuaDLL.lua_pushinteger(L, (int)o); return(1); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static int QPYX_HandleLog_YXQP(IntPtr L_YXQP) { try { ToLua.CheckArgsCount(L_YXQP, 3); string QPYX_arg0_YXQP = ToLua.CheckString(L_YXQP, 1); string QPYX_arg1_YXQP = ToLua.CheckString(L_YXQP, 2); UnityEngine.LogType QPYX_arg2_YXQP = (UnityEngine.LogType)ToLua.CheckObject(L_YXQP, 3, typeof(UnityEngine.LogType)); CustomerUtil.HandleLog(QPYX_arg0_YXQP, QPYX_arg1_YXQP, QPYX_arg2_YXQP); return(0); } catch (Exception e_YXQP) { return(LuaDLL.toluaL_exception(L_YXQP, e_YXQP)); } }
static void WriteBackInstance(CSHotFix.Runtime.Enviorment.AppDomain __domain, StackObject *ptr_of_this_method, IList <object> __mStack, ref UnityEngine.LogType instance_of_this_method) { ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method); switch (ptr_of_this_method->ObjectType) { case ObjectTypes.Object: { __mStack[ptr_of_this_method->Value] = instance_of_this_method; } break; case ObjectTypes.FieldReference: { var ___obj = __mStack[ptr_of_this_method->Value]; if (___obj is ILTypeInstance) { ((ILTypeInstance)___obj)[ptr_of_this_method->ValueLow] = instance_of_this_method; } else { var t = __domain.GetType(___obj.GetType()) as CLRType; t.SetFieldValue(ptr_of_this_method->ValueLow, ref ___obj, instance_of_this_method); } } break; case ObjectTypes.StaticFieldReference: { var t = __domain.GetType(ptr_of_this_method->Value); if (t is ILType) { ((ILType)t).StaticInstance[ptr_of_this_method->ValueLow] = instance_of_this_method; } else { ((CLRType)t).SetStaticFieldValue(ptr_of_this_method->ValueLow, instance_of_this_method); } } break; case ObjectTypes.ArrayReference: { var instance_of_arrayReference = __mStack[ptr_of_this_method->Value] as UnityEngine.LogType[]; instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method; } break; } }
static int OnLog(IntPtr L) { try { ToLua.CheckArgsCount(L, 3); string arg0 = ToLua.CheckString(L, 1); string arg1 = ToLua.CheckString(L, 2); UnityEngine.LogType arg2 = (UnityEngine.LogType)ToLua.CheckObject(L, 3, typeof(UnityEngine.LogType)); Game.OnLog(arg0, arg1, arg2); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static StackObject *SetStackTraceLogType_44(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.StackTraceLogType stackTraceType = (UnityEngine.StackTraceLogType) typeof(UnityEngine.StackTraceLogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); UnityEngine.LogType logType = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); UnityEngine.Application.SetStackTraceLogType(logType, stackTraceType); return(__ret); }
static int SetStackTraceLogType(IntPtr L) { #if UNITY_EDITOR ToluaProfiler.AddCallRecord("UnityEngine.Application.SetStackTraceLogType"); #endif try { ToLua.CheckArgsCount(L, 2); UnityEngine.LogType arg0 = (UnityEngine.LogType)ToLua.CheckObject(L, 1, typeof(UnityEngine.LogType)); UnityEngine.StackTraceLogType arg1 = (UnityEngine.StackTraceLogType)ToLua.CheckObject(L, 2, typeof(UnityEngine.StackTraceLogType)); UnityEngine.Application.SetStackTraceLogType(arg0, arg1); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static StackObject *set_filterLogType_5(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.LogType @value = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); UnityEngine.ILogger instance_of_this_method = (UnityEngine.ILogger) typeof(UnityEngine.ILogger).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); instance_of_this_method.filterLogType = value; return(__ret); }
static StackObject *Log_1(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.LogType @importance = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.Object @message = (System.Object) typeof(System.Object).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); global::DebugSystem.Log(@message, @importance); return(__ret); }
/// <summary> /// Handles any logging events from unity /// </summary> /// <param name="logString">The log string</param> /// <param name="stackTrace">The stacktrace for the log</param> /// <param name="type">The log type</param> private void _handleUnityLog(string logString, string stackTrace, UnityEngine.LogType type) { switch (type) { case UnityEngine.LogType.Assert: case UnityEngine.LogType.Log: _handleLog(logString, stackTrace, LogType.LOG); break; case UnityEngine.LogType.Warning: _handleLog(logString, stackTrace, LogType.WARNING); break; case UnityEngine.LogType.Error: case UnityEngine.LogType.Exception: _handleLog(logString, stackTrace, LogType.ERROR); break; } }
public bool Check(LogType type) { switch (type) { case LogType.Log: return(Log); case LogType.Warning: return(Warning); case LogType.Error: return(Error); case LogType.Assert: return(Assert); case LogType.Exception: return(Exception); default: L.SomethingWentWrong(); return(false); } }
/// <summary> /// Creates a log with multiple ategories for the msg provided /// </summary> /// <param name="categories">The multiple categories</param> /// <param name="severityLevel">THe severity of this log</param> /// <param name="msg">Message that will be logged</param> /// <param name="args">Objects that will be formatted into the msg is need be</param> public virtual void LogWithCategories(List <string> categories, LogType severityLevel, string msg, params object[] args) { //If none of the ategories are active, skip this log if (!IsAnyCategoryActive(categories.ToArray())) { return; } StackTrace stack = new StackTrace(1, true); sLogInfo newLogInfo = new sLogInfo(); newLogInfo.Message = string.Format(msg, args); newLogInfo.Timestamp = UnityEngine.Time.time.ToString(); newLogInfo.StackInfo = CreateInfoLine(stack); newLogInfo.Categories = categories.ToArray(); newLogInfo.SeverityLevel = severityLevel; ProcessLog(newLogInfo, stack); }
static StackObject *IsLogTypeAllowed_6(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 2); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); UnityEngine.LogType @logType = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); UnityEngine.ILogger instance_of_this_method = (UnityEngine.ILogger) typeof(UnityEngine.ILogger).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.IsLogTypeAllowed(@logType); __ret->ObjectType = ObjectTypes.Integer; __ret->Value = result_of_this_method ? 1 : 0; return(__ret + 1); }
public virtual void WriteRaw(string msg, UnityEngine.LogType logType) { #if PRINT_TIME if (Category != null) { msg = $"<{DateTime.Now.ToString("hh:mm:ss.fff")}> <{Category}> {msg}"; } else { msg = $"<{DateTime.Now.ToString("hh:mm:ss.fff")}> {msg}"; } #else if (Category != null) { msg = $"<{Category}> {msg}"; } #endif UnityEngine.Debug.unityLogger.Log(logType, msg); }
static int LogFormat(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (TypeChecker.CheckTypes <UnityEngine.LogType, UnityEngine.LogOption, UnityEngine.Object, string>(L, 1) && TypeChecker.CheckParamsType <object>(L, 5, count - 4)) { UnityEngine.LogType arg0 = (UnityEngine.LogType)ToLua.ToObject(L, 1); UnityEngine.LogOption arg1 = (UnityEngine.LogOption)ToLua.ToObject(L, 2); UnityEngine.Object arg2 = (UnityEngine.Object)ToLua.ToObject(L, 3); string arg3 = ToLua.ToString(L, 4); object[] arg4 = ToLua.ToParamsObject(L, 5, count - 4); UnityEngine.Debug.LogFormat(arg0, arg1, arg2, arg3, arg4); return(0); } else if (TypeChecker.CheckTypes <UnityEngine.Object, string>(L, 1) && TypeChecker.CheckParamsType <object>(L, 3, count - 2)) { UnityEngine.Object arg0 = (UnityEngine.Object)ToLua.ToObject(L, 1); string arg1 = ToLua.ToString(L, 2); object[] arg2 = ToLua.ToParamsObject(L, 3, count - 2); UnityEngine.Debug.LogFormat(arg0, arg1, arg2); return(0); } else if (TypeChecker.CheckTypes <string>(L, 1) && TypeChecker.CheckParamsType <object>(L, 2, count - 1)) { string arg0 = ToLua.ToString(L, 1); object[] arg1 = ToLua.ToParamsObject(L, 2, count - 1); UnityEngine.Debug.LogFormat(arg0, arg1); return(0); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Debug.LogFormat")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static StackObject *Log_7(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { CSHotFix.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 3); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Object message = (System.Object) typeof(System.Object).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); UnityEngine.LogType logType = (UnityEngine.LogType) typeof(UnityEngine.LogType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 3); UnityEngine.Logger instance_of_this_method; instance_of_this_method = (UnityEngine.Logger) typeof(UnityEngine.Logger).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); instance_of_this_method.Log(logType, message); return(__ret); }
public static void Log(object obj, UnityEngine.LogType logLevel = UnityEngine.LogType.Log) { string message = "[AdvancedElectrolyzer]: " + obj; switch (logLevel) { case UnityEngine.LogType.Exception: case UnityEngine.LogType.Error: Debug.LogError(message); break; case UnityEngine.LogType.Assert: case UnityEngine.LogType.Warning: Debug.LogWarning(message); break; default: Debug.Log(message); break; } }
public static LogLevel FromUnity(UnityEngine.LogType logType) { switch (logType) { case UnityEngine.LogType.Log: return(LogLevel.Debug); case UnityEngine.LogType.Warning: return(LogLevel.Warning); case UnityEngine.LogType.Error: case UnityEngine.LogType.Exception: return(LogLevel.Error); case UnityEngine.LogType.Assert: return(LogLevel.Assert); default: return(LogLevel.Debug); } }
public void __Gen_Delegate_Imp18(string p0, string p1, UnityEngine.LogType p2) { #if THREAD_SAFE || HOTFIX_ENABLE lock (luaEnv.luaEnvLock) { #endif RealStatePtr L = luaEnv.rawL; int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); ObjectTranslator translator = luaEnv.translator; LuaAPI.lua_pushstring(L, p0); LuaAPI.lua_pushstring(L, p1); translator.Push(L, p2); PCall(L, 3, 0, errFunc); LuaAPI.lua_settop(L, errFunc - 1); #if THREAD_SAFE || HOTFIX_ENABLE } #endif }
// 额外记录系统的LogError Exception信息 // static void HandleSysLog(string logString, string stackTrace, UnityEngine.LogType type) { switch (type) { case UnityEngine.LogType.Log: break; case UnityEngine.LogType.Warning: break; case UnityEngine.LogType.Error: ErrorHandler(Format("[Sys Error]: {0}\r\n{1}\r\n", logString, stackTrace)); break; case UnityEngine.LogType.Assert: ErrorHandler(Format("[Sys Assert]: {0}\r\n{1}\r\n", logString, stackTrace)); break; case UnityEngine.LogType.Exception: ErrorHandler(Format("[Sys Exception]: {0}\r\n{1}\r\n", logString, stackTrace)); break; } }
private static void WriteRaw(string msg, UnityEngine.LogType logType) { logger.WriteRaw(msg, logType); }
private static void UnityApplication_LogMessageReceived(string condition, string stackTrace, UnityEngine.LogType type) { lock (_unitySyncLock) { if (_skipReadUnityLogs.Remove(condition)) { return; } if (_rerouteUnityLogTo == null) { return; } _skipWriteUnityLogs.Add(condition); } // Put additional information we get from unity into a context object, which we // forward through our custom logging. That way, we don't lose any information. UnityLogContext unityContext = new UnityLogContext { StackTrace = stackTrace }; // Forward the Unity-log to our custom log and provide the stack trace as // a context object. We'll parse this on the editor side to provide code info. switch (type) { default: case UnityEngine.LogType.Log: _rerouteUnityLogTo.Write(condition, unityContext); break; case UnityEngine.LogType.Warning: _rerouteUnityLogTo.WriteWarning(condition, unityContext); break; case UnityEngine.LogType.Assert: case UnityEngine.LogType.Exception: _rerouteUnityLogTo.WriteError( condition + Environment.NewLine + "Stacktrace:" + Environment.NewLine + "{1}", unityContext, stackTrace); break; case UnityEngine.LogType.Error: _rerouteUnityLogTo.WriteError(condition, unityContext); break; } }
static internal void Lua_BuglyAgent_LogCallbackDelegate(LuaFunction ld, string a1, string a2, UnityEngine.LogType a3) { IntPtr l = ld.L; int error = pushTry(l); pushValue(l, a1); pushValue(l, a2); pushValue(l, a3); ld.pcall(3, error); LuaDLL.lua_settop(l, error - 1); }
public static void Log(ILIntepreter __intp, Enviorment.AppDomain __domain, UnityEngine.LogType level, string text) { UnityEngine.Debug.unityLogger.Log(level, string.Format("{0}\nStackTrance:{1}", text, __domain.DebugService.GetStackTrace(__intp))); }
/// <summary> /// receive unity log message. see /// <see cref="UnityEngine.Application.logMessageReceived"/> /// </summary> /// <param name="logString"></param> /// <param name="stackTrace"></param> /// <param name="logType"></param> private void Application_logMessageReceived(string logString, string stackTrace, UnityEngine.LogType logType) { var entry = LogEntry.Create(logString, stackTrace, logType); lock (m_LogQueueLock) { m_LogQueue.Enqueue(entry); } }
public void SendLog(string _msg, string _trace, UnityEngine.LogType _type) { }
/// <summary> /// Creates a log with a single category for the msg provided. /// </summary> /// <param name="category">The single category</param> /// <param name="severityLevel">The severity of this log</param> /// <param name="msg">Message that will be logged</param> /// <param name="args">Objects that will be formatted into the msg is need be</param> public void LogWithCategory(string category, LogType severityLevel, string msg, params object[] args) { LogWithCategories(new List<string>(new string[] { category }), severityLevel, msg, args); }
private static void onLogMessageReceivedHandler(string condition, string stackTrace, UnityEngine.LogType type) { #if !UNITY_EDITOR if (type != UnityEngine.LogType.Exception && type != UnityEngine.LogType.Error) { return; } WriteLog(condition, stackTrace, eLogLevel.Exception, eLogOutputType.Txt, eLogColor.Default); #else if (type == UnityEngine.LogType.Exception) { UnityEditor.EditorApplication.isPaused = true; } #endif }
/// <summary> /// Creates a log with multiple ategories for the msg provided /// </summary> /// <param name="categories">The multiple categories</param> /// <param name="severityLevel">THe severity of this log</param> /// <param name="msg">Message that will be logged</param> /// <param name="args">Objects that will be formatted into the msg is need be</param> public virtual void LogWithCategories(List<string> categories, LogType severityLevel, string msg, params object[] args) { //If none of the ategories are active, skip this log if (!IsAnyCategoryActive(categories.ToArray())) { return; } StackTrace stack = new StackTrace(1, true); sLogInfo newLogInfo = new sLogInfo(); newLogInfo.Message = string.Format(msg, args); newLogInfo.Timestamp = UnityEngine.Time.time.ToString(); newLogInfo.StackInfo = CreateInfoLine(stack); newLogInfo.Categories = categories.ToArray(); newLogInfo.SeverityLevel = severityLevel; ProcessLog(newLogInfo, stack); }