public ANTLRMessage([NotNull] ErrorType errorType, [Nullable] Exception e, IToken offendingToken, params object[] args)
 {
     this.errorType = errorType;
     this.e = e;
     this.args = args;
     this.offendingToken = offendingToken;
 }

 public NoViableAltException(string message, string grammarDecisionDescription, int decisionNumber, int stateNumber, IIntStream input, Exception innerException)
     : base(message, input, innerException)
 {
     this._grammarDecisionDescription = grammarDecisionDescription;
     this._decisionNumber = decisionNumber;
     this._stateNumber = stateNumber;
 }

 public Exception(System.Exception ex)
 {
     InitializeComponent();
     _exception = ex;
     lblContent.Text = ex.ToString();
     Activate();
 }

        IToken templateToken; // overall token pulled from group file

        #endregion Fields

        #region Constructors

        public TemplateLexerMessage(string srcName, string msg, IToken templateToken, Exception cause)
            : base(ErrorType.LEXER_ERROR, null, cause, null)
        {
            this.msg = msg;
            this.templateToken = templateToken;
            this.srcName = srcName;
        }

        private readonly IToken _templateToken; // overall token pulled from group file

        #endregion Fields

        #region Constructors

        public TemplateLexerMessage(string sourceName, string message, IToken templateToken, Exception cause)
            : base(ErrorType.LEXER_ERROR, null, cause, null)
        {
            this._message = message;
            this._templateToken = templateToken;
            this._sourceName = sourceName;
        }

 public TemplateCompiletimeMessage(ErrorType error, string sourceName, IToken templateToken, IToken token, Exception cause, object arg, object arg2)
     : base(error, null, cause, arg, arg2)
 {
     this._templateToken = templateToken;
     this._token = token;
     this._sourceName = sourceName;
 }

        /// <summary>
        /// True the specified shouldBeTrue and message.
        /// </summary>
        /// <param name="shouldBeTrue">If set to <c>true</c> should be true.</param>
        /// <param name="message">Message.</param>
        public static void True(bool shouldBeTrue, string message = null, AssertLevel assertLevel = AssertLevel.Warning, params string[] tags)
        {
            if(!shouldBeTrue)
            {
                if(string.IsNullOrEmpty(message))
                    message = "(No Message)";

                var logType = LogType.Warning;
                var fatalException = default(System.Exception);
                if(assertLevel == AssertLevel.Critical)
                {
                    logType = LogType.Error;
                }
                else if(assertLevel == AssertLevel.Fatal)
                {
                    logType = LogType.Exception;
                    fatalException = new System.Exception("Fatal Assert : " + message);
                }

                Logger.LogAssert("Assert Fail : " + message, logType, fatalException, tags);

                // just quit application if fatal assert is found
            //				if(assertLevel == AssertLevel.Fatal)
            //				{
            //					throw fatalException;
            //				}
            }
        }

 public TemplateMessage(ErrorType error, Template template, Exception source, object arg1, object arg2)
 {
     this.ErrorType = error;
     this.Template = template;
     this.Source = source;
     this.Argument1 = arg1;
     this.Argument2 = arg2;
 }

        public Exception(System.Exception ex)
        {
            InitializeComponent();
            DwmDropShadow.DropShadowToWindow(this);
            _exception = ex;

            lblContent.Text = ex.ToString();
        }

        public MismatchedTokenException(string message, int expecting, IIntStream input, IList<string> tokenNames, Exception innerException)
            : base(message, input, innerException)
        {
            this._expecting = expecting;

            if (tokenNames != null)
                this._tokenNames = new List<string>(tokenNames).AsReadOnly();
        }

 public static void PrintStackTrace( Exception e, TextWriter writer )
 {
     writer.WriteLine( e.ToString() );
     string trace = e.StackTrace ?? string.Empty;
     foreach ( string line in trace.Split( '\n', '\r' ) )
     {
         if ( !string.IsNullOrEmpty( line ) )
             writer.WriteLine( "        " + line );
     }
 }

        public static void TrackAppException(string activity, String method, Exception exception, Boolean isFatalException)
        {
            var builder = new HitBuilders.ExceptionBuilder();
            var exceptionMessageToTrack = string.Format("{0}, Method : {1}\nException type : {2}, Exception Message : {3}\nStack Trace : \n{4}", activity, method,
                exception.GetType(),exception.Message, exception.StackTrace);

            builder.SetDescription(exceptionMessageToTrack);
            builder.SetFatal(isFatalException);

            Rep.Instance.GaTracker.Send(builder.Build());
        }

 public void HandleExpected(Exception ex)
 {
     EasyTracker.Tracker.SendException(ex.Message, Throwable.FromException(ex), false);
     FlurryAgent.OnError(ex.GetType().Name, ex.Message, Throwable.FromException(ex));
     Crittercism.LogHandledException(Throwable.FromException(ex));
     Log.Error(_context.GetType().Name, ex.Message);
     string errorMessage = _context.Resources.GetString(Resource.String.CommonErrorMessage);
     AlertDialog dialog = new AlertDialog.Builder(_context).SetMessage(errorMessage).Create();
     dialog.SetCanceledOnTouchOutside(true);
     dialog.Show();
 }

		public XmlPullParserException(string msg, org.xmlpull.v1.XmlPullParser parser, System.Exception
			 chain) : base((msg == null ? string.Empty : msg + " ") + (parser == null ? string.Empty
			 : "(position:" + parser.getPositionDescription() + ") ") + (chain == null ? string.Empty
			 : "caused by: " + chain))
		{
			// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)
			if (parser != null)
			{
				this.row = parser.getLineNumber();
				this.column = parser.getColumnNumber();
			}
			this.detail = chain;
		}

		private void BkgEnd(System.Exception e = null)
		{
			lock(this)
			{
				// if canceled and run again, maybe thread is not CurrentThread but running is true
				if (Thread.CurrentThread == thread)
				{
					// 1.
					thread = null;
					if (null != e)
					{
						exception = e;
					}
					// 2.
					running = false;
				}
			}
		}

        private static Protobuf.Exception GetExceptionResponse(Exception exc)
        {
            Alachisoft.NCache.Common.Protobuf.Exception ex = new Alachisoft.NCache.Common.Protobuf.Exception();
            ex.message = exc.Message;
            ex.exception = exc.ToString();

            if (exc is OperationFailedException)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.OPERATIONFAILED;
            else if (exc is Runtime.Exceptions.AggregateException)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.AGGREGATE;
            else if (exc is ConfigurationException)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.CONFIGURATION;
            else if (exc is OperationNotSupportedException)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.NOTSUPPORTED;
            else if (exc is TypeIndexNotDefined)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.TYPE_INDEX_NOT_FOUND;
            else if (exc is AttributeIndexNotDefined)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.ATTRIBUTE_INDEX_NOT_FOUND;
            else if (exc is StateTransferInProgressException)
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.STATE_TRANSFER_EXCEPTION;
            else
                ex.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.GENERALFAILURE;
            return ex;
        }

 /// <summary>Record that an exception occurred while executing
 /// this merge 
 /// </summary>
 internal virtual void SetException(System.Exception error)
 {
     lock (this)
     {
         this.error = error;
     }
 }

 public MismatchedNotSetException(string message, BitSet expecting, IIntStream input, Exception innerException)
     : base(message, expecting, input, innerException)
 {
 }

        public RecognitionException(string message, IIntStream input, Exception innerException)
            : base(message, innerException)
        {
            this._input = input;
            if (input != null)
            {
                this._index = input.Index;
                if (input is ITokenStream)
                {
                    this._token = ((ITokenStream)input).LT(1);
                    this._line = _token.Line;
                    this._charPositionInLine = _token.CharPositionInLine;
                }

                ITreeNodeStream tns = input as ITreeNodeStream;
                if (tns != null)
                {
                    ExtractInformationFromTreeNodeStream(tns);
                }
                else
                {
                    ICharStream charStream = input as ICharStream;
                    if (charStream != null)
                    {
                        this._c = input.LA(1);
                        this._line = ((ICharStream)input).Line;
                        this._charPositionInLine = ((ICharStream)input).CharPositionInLine;
                    }
                    else
                    {
                        this._c = input.LA(1);
                    }
                }
            }
        }

 public ToolMessage(ErrorType errorType, Exception e, params object[] args)
     : base(errorType, e, new CommonToken(TokenTypes.Invalid), args)
 {
 }