internal ModbusException(int DeviceAddress, FunctionCode FunctionCode, ExceptionType Type, string Comment = null)
 {
     this.Type = Type;  
     this.DeviceAddress = DeviceAddress;
     this.Code = FunctionCode;
     this.Comment = Comment;
 }

        // modloader errors can be constructed without parameters
        public ExceptionLogger()
        {
            this.version = ModLoader.getVersion();
            this.url = "http://mods.scrollsguide.com";

            this.type = ExceptionType.MODLOADER;
        }

		public static Exception Log(Exception error, ExceptionType type, OutputHandler OutputCallback)
		{
			lock (Lock)
			{
				OutputHandler callback = new OutputHandler(delegate(Exception e, ExceptionType t) { });
				Errors.Add(new ExceptionItem(error, type));
				if (Output != null)
				{
					callback = Output;
				}
				if (OutputCallback != null)
				{
					callback = OutputCallback;
				}
				if (callback != null)
				{
					callback(error, type);
				}
				Logger.Log(">> Exception Detected >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
				//System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace();
				//for (int i = 0; i < st.FrameCount; i++)
				//{
				//    System.Diagnostics.StackFrame sf = st.GetFrame(i);
				//    Logger.Log(String.Format(">> File name:{0}\tLine:{1}\tColumn:{2}\tMethodName:{3} ", sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber(), sf.GetMethod().Name));
				//}
				Logger.Log(error.ToString());
			}
			return error;
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="exType">Type of ExceptionType.</param>
 /// <param name="message">The error message for this exception.</param>
 /// <param name="innerException">The inner exception that is wrapped in this exception.</param>
 public CustomException(ExceptionType exType, string message, System.Exception innerException)
     : base(message, innerException)
 {
     //this.CustomMessage = rm.GetString(exType.ToString());
     this.CustomMessage = ExpResources.ExpResources.ResourceManager.GetString(exType.ToString()) ?? "[[" + exType.ToString() + "]]";
     this.ExceptionType = exType.ToString();
 }

 /************************************************************************
  * type:        抛出的异常类型
  * sourceType:  抛出异常所在的类
  * sourceID:    抛出异常所在的控件ID,没有ID则为null
  * key:         参数的名称(参数错误)
  *              属性的名称(属性错误)
  *              方法的名称(方法错误)
  *              控件的类型名(控件错误)
  *              字段的名称(字段错误)
  * value:       参数的值(参数错误)
  *              属性的值(属性错误)
  *              null(方法错误)
  *              控件的ID(Component没有ID则为null)(控件错误)
  *              字段的值(字段错误)
 ************************************************************************/
 /// <summary>
 /// 
 /// </summary>
 /// <param name="type"></param>
 /// <param name="sourceType"></param>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <param name="controlID"></param>
 public EEPException(ExceptionType type, Type sourceType, string sourceID, string key, string value)
 {
     _type = type;
     _sourceType = sourceType;
     _sourceID = sourceID;
     _key = key;
     _value = value;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:StylesSheetException"/> class.
 /// </summary>
 /// <param name="type">The type.</param>
 /// <param name="controlName">Name of the control.</param>
 /// <param name="styleName">Name of the style.</param>
 public StylesSheetException(ExceptionType type, string styleName, string controlName, string propertyName, string propertyValue)
 {
     this.type = type;
     this.styleName = styleName;
     this.controlName = controlName;
     this.propertyName = propertyName;
     this.propertyValue = propertyValue;
 }

 public EngineException(ExceptionType type, string message, Token token)
 {
     Type = type;
     Message = message;
     Token = token;
     Line = token.Line;
     Position = token.Position;
 }

 internal static Exception CreateException(string res, string[] args, ExceptionType exceptionType, int lineNo, int linePos)
 {
     switch (exceptionType)
     {
         case ExceptionType.ArgumentException:
             return new ArgumentException(Res.GetString(res, args));
     }
     return new XmlException(res, args, lineNo, linePos);
 }

        public static RemotingException Read(Serializer iprot)
        {
            string message = null;
            ExceptionType type = ExceptionType.Unknown;

            message = iprot.ReadString();
            type = (ExceptionType)iprot.ReadI32();

            return new RemotingException(type, message);
        }

 public void LogException(Exception exception, HttpRequest httpRequest, ExceptionType exceptionType = ExceptionType.Handled)
 {
     if (exceptionType == ExceptionType.Unhandled)
     {
         Fatal(ExceptionToString(exception), exception, httpRequest);
     }
     else
     {
         Error(ExceptionToString(exception), exception, httpRequest);
     }
 }

 public HotCitException(ExceptionType type, string msg = "")
 {
     switch (type) {
         case ExceptionType.BadAction: throw new BadActionException(msg);
         case ExceptionType.IllegalInput: throw new IllegalInputException(msg);
         case ExceptionType.IllegalState: throw new IllegalStateException(msg);
         case ExceptionType.Impossible: throw new ImpossibleException(msg);
         case ExceptionType.NotEnoughGold: throw new NotEnoughGoldException(msg);
         case ExceptionType.NotFound: throw new NotFoundException(msg);
         case ExceptionType.Timeout: throw new TimeoutException(msg);
     }
 }

		public static TApplicationException Read(TProtocol iprot)
		{
			TField field;

			string message = null;
			ExceptionType type = ExceptionType.Unknown;

			iprot.ReadStructBegin();
			while (true)
			{
				field = iprot.ReadFieldBegin();
				if (field.Type == TType.Stop)
				{
					break;
				}

				switch (field.ID)
				{
					case 1:
						if (field.Type == TType.String)
						{
							message = iprot.ReadString();
						}
						else
						{
							TProtocolUtil.Skip(iprot, field.Type);
						}
						break;
					case 2:
						if (field.Type == TType.I32)
						{
							type = (ExceptionType)iprot.ReadI32();
						}
						else
						{
							TProtocolUtil.Skip(iprot, field.Type);
						}
						break;
					default:
						TProtocolUtil.Skip(iprot, field.Type);
						break;
				}

				iprot.ReadFieldEnd();
			}

			iprot.ReadStructEnd();

			return new TApplicationException(type, message);
		}

 private void SetMessageOnType(ExceptionType type, string message)
 {
     switch (type)
     {
         case ExceptionType.MethodChainingException:
             _template = "You can not chain these methods : {0}";
             break;
         case ExceptionType.ArgumentNotMatchException:
             _template = "argument not match : {0}";
             break;
         case ExceptionType.MemberSerializeException:
             _template = "the colum member can not be serialized to string: {0}";
             break;
         default:
             _template = "{0}";
             break;
     }
     _message = string.Format(_template, message);
 }

        public QStrategyException(string message, Exception innerException, ExceptionType exceptionType, string sourceLocation)
            : base(message, innerException)
        {
            this.exceptionType = exceptionType;
            this.sourceLocation = sourceLocation;
            string messageDetail = message;
            message = exceptionType.ToString();
            if (innerException != null)
            {
                while (innerException.InnerException != null)
                {
                    innerException = innerException.InnerException;
                }
                message = innerException.Message;
                messageDetail = innerException.StackTrace;
            }

            string messageLog = string.Format("ExceptionType: {0}, Source:{1}, Exception:{2} MessageDetails: {3}", ExceptionType.ToString(), sourceLocation, message, messageDetail);
            LogUtil.WriteLog(LogLevel.ERROR, messageLog);
        }

        internal static void BroadcastExceptionNotification(ExceptionType type, int token)
        {
            switch (type)
            {
                case ExceptionType.StandardException:
                    {
                        BroadcastMessage("exception:id=1," + token);
                        break;
                    }

                case ExceptionType.FatalException:
                    {
                        BroadcastMessage("exception:id=2," + token);
                        break;
                    }

                case ExceptionType.SQLException:
                    {
                        BroadcastMessage("exception:id=3," + token);
                        break;
                    }

                case ExceptionType.ThreadedException:
                    {
                        BroadcastMessage("exception:id=4," + token);
                        break;
                    }

                case ExceptionType.UserException:
                    {
                        BroadcastMessage("exception:id=5," + token);
                        break;
                    }

                case ExceptionType.DDOSException:
                    {
                        BroadcastMessage("exception:id=6," + token);
                        break;
                    }
            }
        }

		internal Exception(Thread thread)
		{
			creationTime = DateTime.Now;
			this.process = thread.Process;
			this.thread = thread;
			corValue = thread.CorThread.CurrentException;
			exceptionType = thread.CurrentExceptionType;
			Value runtimeValue = new Value(process,
			                               new IExpirable[] {process.PauseSession},
			                               new IMutable[] {},
			                               delegate { return corValue; } );
			NamedValue nv = runtimeValue.GetMember("_message");
			if (!nv.IsNull)
			message = nv.AsString;
			else message = runtimeValue.Type.FullName;
			if (thread.LastFunctionWithLoadedSymbols != null) {
				location = thread.LastFunctionWithLoadedSymbols.NextStatement;
			}
			
			callstack = "";
			int callstackItems = 0;
			if (!nv.IsNull)
			foreach(Function function in thread.Callstack) {
				if (callstackItems >= 100) {
					callstack += "...\n";
					break;
				}
				
				SourcecodeSegment loc = function.NextStatement;
				callstack += function.Name + "()";
				if (loc != null) {
					callstack += " - " + loc.SourceFullFilename + ":" + loc.StartLine + "," + loc.StartColumn;
				}
				callstack += "\n";
				callstackItems++;
			}
			
			type = runtimeValue.Type.FullName;
		}

        public static string GetString(ExceptionType exceptionType)
        {
            string lValue = string.Empty;

              switch(exceptionType)
              {
               case ExceptionType.ExistingVariableInCalcMemory:
                    lValue = "Variável '{0}' duplicada na memória de cálculo";
                    break;
               case ExceptionType.NumberOfAssigmentTokens:
                    lValue = "Número de símbolos de atribuição (=) inconsistente na expressão '{0}'";
                    break;
               case ExceptionType.VariableNotFoundInCalcMemory:
                    lValue = "Variável '{0}' não encontrada na memória de cálculo";
                    break;
              default:
                  lValue = "Exceção não definida";
                  break;
              }

              return lValue;
        }

        private static void HandleException(ExceptionType exceptionType, Exception exception, string source)
        {
            using (var eventLog = new EventLog())
            {
                if (!System.Diagnostics.EventLog.SourceExists(source))
                {
                    System.Diagnostics.EventLog.CreateEventSource(source, "Application");
                }
                eventLog.Source = source;
                eventLog.Log = "Application";

                StringBuilder message = new StringBuilder();
                message.AppendLine("A " + source + " " + exceptionType.ToString() + " occurred with the following details:");
                message.AppendLine();
                message.AppendLine(exception.Message);
                if (exception.InnerException != null)
                {
                    message.AppendLine();
                    message.AppendLine("InnerException:");
                    message.AppendLine(exception.InnerException.ToString());
                }
                message.AppendLine();
                message.AppendLine("StackTrace:");
                message.AppendLine(exception.StackTrace);

                eventLog.WriteEntry(message.ToString(), System.Diagnostics.EventLogEntryType.Error);

                StringBuilder returnMessage = new StringBuilder();
                returnMessage.AppendLine("Exception:");
                returnMessage.AppendLine(exception.Message);
                if (exception.InnerException != null)
                {
                    returnMessage.AppendLine();
                    returnMessage.AppendLine("Inner Exception:");
                    returnMessage.AppendLine(exception.InnerException.Message);
                }
            }
        }

        public ExceptionForm(ExceptionType type, string title, string message, string stackTrace, bool continueButton)
        {
            InitializeComponent();

            this.Text = title;
            this.exceptionMessage.Text = message;
            this.stackTrace.Text = stackTrace;

            if (type == ExceptionType.Unhandled)
            {
                if (continueButton == false)
                {
                    this.continueButton.Visible = false;
                    this.quitButton.Location = this.continueButton.Location;
                }

                this.label.Text = Localization.Text_UnhandledException;
            }
            else if (type == ExceptionType.Handled)
            {
                this.quitButton.Visible = false;
                this.label.Text = Localization.Text_HandledException;
            }
        }

		void TriggerException(ExceptionType type)
		{
			if (type == ExceptionType.BRK)
				PC++;
			WriteMemory((ushort)(S-- + 0x100), (byte)(PC >> 8));
			WriteMemory((ushort)(S-- + 0x100), (byte)PC);
			FlagB = type == ExceptionType.BRK;
			WriteMemory((ushort)(S-- + 0x100), P);
			FlagI = true;
			switch (type)
			{
				case ExceptionType.NMI:
					PC = ReadWord(NMIVector);
					break;
				case ExceptionType.IRQ:
					PC = ReadWord(IRQVector);
					break;
				case ExceptionType.BRK:
					PC = ReadWord(BRKVector);
					break;
				default: throw new Exception();
			}
			PendingCycles -= 7;
		}