Inheritance: System.Exception
        private static WrapperException WrapJsException(OriginalException originalException)
        {
            WrapperException wrapperException;
            string           message      = originalException.Message;
            string           description  = message;
            string           type         = originalException.Type;
            string           documentName = originalException.Resource;
            int lineNumber   = originalException.Line;
            int columnNumber = originalException.Column;

            if (originalException is OriginalInteropException)
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion, originalException);
            }
            else if (type == null && message.Equals(":  at line: 0 column: 1.", StringComparison.Ordinal))
            {
                wrapperException = new WrapperInterruptedException(CoreStrings.Runtime_ScriptInterrupted,
                                                                   EngineName, EngineVersion, originalException);
            }
            else
            {
                Match scriptErrorMessageMatch = _scriptErrorMessageRegex.Match(message);
                if (scriptErrorMessageMatch.Success)
                {
                    WrapperScriptException wrapperScriptException;
                    description = scriptErrorMessageMatch.Groups["description"].Value;
                    message     = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                            lineNumber, columnNumber);

                    if (type == JsErrorType.Syntax)
                    {
                        wrapperScriptException = new WrapperCompilationException(message,
                                                                                 EngineName, EngineVersion, originalException);
                    }
                    else
                    {
                        wrapperScriptException = new WrapperRuntimeException(message,
                                                                             EngineName, EngineVersion, originalException);
                    }
                    wrapperScriptException.Type         = type;
                    wrapperScriptException.DocumentName = documentName;
                    wrapperScriptException.LineNumber   = lineNumber;
                    wrapperScriptException.ColumnNumber = columnNumber;

                    wrapperException = wrapperScriptException;
                }
                else
                {
                    wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                            originalException);
                }
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
        private static WrapperException WrapJavaScriptException(
            OriginalJavaScriptException originalJavaScriptException)
        {
            WrapperException wrapperException;
            string           message = originalJavaScriptException.Message;

            if (string.IsNullOrWhiteSpace(message))
            {
                message = "An unknown error occurred";
            }
            string description  = message;
            string type         = string.Empty;
            string documentName = originalJavaScriptException.Location.Source;
            int    lineNumber   = originalJavaScriptException.LineNumber;
            int    columnNumber = originalJavaScriptException.Column + 1;

            OriginalValue errorValue = originalJavaScriptException.Error;

            if (errorValue.IsObject())
            {
                OriginalObjectInstance errorObject = errorValue.AsObject();

                OriginalValue namePropertyValue = errorObject.Get("name");
                if (namePropertyValue.IsString())
                {
                    type = namePropertyValue.AsString();
                }
            }

            if (!string.IsNullOrEmpty(type))
            {
                message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName, lineNumber,
                                                                    columnNumber);

                var wrapperRuntimeException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                          originalJavaScriptException)
                {
                    Type         = type,
                    DocumentName = documentName,
                    LineNumber   = lineNumber,
                    ColumnNumber = columnNumber
                };

                wrapperException = wrapperRuntimeException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                        originalJavaScriptException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
Exemplo n.º 3
0
        private static WrapperException WrapJsException(OriginalException originalException)
        {
            WrapperException wrapperException;
            string           message     = originalException.Message;
            string           description = message;
            string           type        = string.Empty;
            int    lineNumber            = 0;
            int    columnNumber          = 0;
            string sourceFragment        = string.Empty;

            var errorValue = originalException.Error?.Value as OriginalError;

            if (errorValue != null)
            {
                message     = errorValue.message.As <string>();
                description = message;
                type        = errorValue.name.As <string>();
            }

            if (!string.IsNullOrEmpty(type))
            {
                WrapperScriptException wrapperScriptException;
                if (type == JsErrorType.Syntax)
                {
                    Match messageMatch = _syntaxErrorMessageRegex.Match(message);
                    if (messageMatch.Success)
                    {
                        GroupCollection messageGroups = messageMatch.Groups;
                        description  = messageGroups["description"].Value;
                        lineNumber   = int.Parse(messageGroups["lineNumber"].Value);
                        columnNumber = int.Parse(messageGroups["columnNumber"].Value);
                    }
                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty,
                                                                        lineNumber, columnNumber);

                    wrapperScriptException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                             originalException);
                }
                else
                {
                    string sourceCode = originalException.Code;
                    OriginalCodeCoordinates codeCoordinates = originalException.CodeCoordinates;
                    if (codeCoordinates != null)
                    {
                        lineNumber   = codeCoordinates.Line;
                        columnNumber = codeCoordinates.Column;
                    }
                    sourceFragment = TextHelpers.GetTextFragment(sourceCode, lineNumber, columnNumber);
                    message        = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty,
                                                                               lineNumber, columnNumber, sourceFragment);

                    wrapperScriptException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                         originalException);
                }
                wrapperScriptException.Type           = type;
                wrapperScriptException.LineNumber     = lineNumber;
                wrapperScriptException.ColumnNumber   = columnNumber;
                wrapperScriptException.SourceFragment = sourceFragment;

                wrapperException = wrapperScriptException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion, originalException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
        private static WrapperException WrapJavaScriptException(
            OriginalJavaScriptException originalJavaScriptException)
        {
            WrapperException wrapperException;
            string           message = originalJavaScriptException.Message;
            string           messageWithCallStack = string.Empty;
            string           description          = message;
            string           type         = originalJavaScriptException.Name;
            string           documentName = originalJavaScriptException.SourcePath ?? string.Empty;
            int    lineNumber             = originalJavaScriptException.LineNumber;
            string callStack = string.Empty;

            var errorValue = originalJavaScriptException.ErrorObject as OriginalErrorInstance;

            if (errorValue != null)
            {
                messageWithCallStack = errorValue.Stack;
                description          = !string.IsNullOrEmpty(errorValue.Message) ?
                                       errorValue.Message : description;
            }

            if (!string.IsNullOrEmpty(type))
            {
                WrapperScriptException wrapperScriptException;
                if (type == JsErrorType.Syntax)
                {
                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                        lineNumber, 0);

                    wrapperScriptException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                             originalJavaScriptException);
                }
                else
                {
                    if (message.Length < messageWithCallStack.Length)
                    {
                        string rawCallStack = messageWithCallStack
                                              .TrimStart(message)
                                              .TrimStart(new char[] { '\n', '\r' })
                        ;
                        ErrorLocationItem[] callStackItems = JsErrorHelpers.ParseErrorLocation(rawCallStack);

                        if (callStackItems.Length > 0)
                        {
                            FixCallStackItems(callStackItems);
                            callStack = JsErrorHelpers.StringifyErrorLocationItems(callStackItems);

                            if (string.IsNullOrWhiteSpace(documentName))
                            {
                                documentName = callStackItems[0].DocumentName;
                            }
                        }
                    }

                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, callStack);

                    wrapperScriptException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                         originalJavaScriptException)
                    {
                        CallStack = callStack
                    };
                }
                wrapperScriptException.Type         = type;
                wrapperScriptException.DocumentName = documentName;
                wrapperScriptException.LineNumber   = lineNumber;

                wrapperException = wrapperScriptException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                        originalJavaScriptException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
Exemplo n.º 5
0
        private static WrapperException WrapScriptEngineException(OriginalException originalException)
        {
            WrapperException wrapperException;
            string           message = originalException.Message;
            string           messageWithErrorLocation = originalException.ErrorDetails;
            string           description  = message;
            string           type         = string.Empty;
            string           documentName = string.Empty;
            int    lineNumber             = 0;
            int    columnNumber           = 0;
            string callStack      = string.Empty;
            string sourceFragment = string.Empty;

            if (originalException.IsFatal)
            {
                if (message == "The V8 runtime has exceeded its memory limit")
                {
                    wrapperException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                   originalException);
                }
                else
                {
                    wrapperException = new WrapperFatalException(message, EngineName, EngineVersion,
                                                                 originalException);
                }
            }
            else
            {
                Match messageWithTypeMatch = _errorMessageWithTypeRegex.Match(message);
                if (messageWithTypeMatch.Success)
                {
                    GroupCollection messageWithTypeGroups = messageWithTypeMatch.Groups;
                    type        = messageWithTypeGroups["type"].Value;
                    description = messageWithTypeGroups["description"].Value;
                    var errorLocationItems = new ErrorLocationItem[0];

                    if (message.Length < messageWithErrorLocation.Length)
                    {
                        string errorLocation = messageWithErrorLocation
                                               .TrimStart(message)
                                               .TrimStart(new char[] { '\n', '\r' })
                        ;

                        errorLocationItems = JsErrorHelpers.ParseErrorLocation(errorLocation);
                        if (errorLocationItems.Length > 0)
                        {
                            ErrorLocationItem firstErrorLocationItem = errorLocationItems[0];

                            documentName = firstErrorLocationItem.DocumentName;
                            lineNumber   = firstErrorLocationItem.LineNumber;
                            columnNumber = firstErrorLocationItem.ColumnNumber;
                            string sourceLine = firstErrorLocationItem.SourceFragment;
                            sourceFragment = TextHelpers.GetTextFragmentFromLine(sourceLine, columnNumber);

                            firstErrorLocationItem.SourceFragment = sourceFragment;
                        }
                    }

                    WrapperScriptException wrapperScriptException;
                    if (type == JsErrorType.Syntax)
                    {
                        message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                            lineNumber, columnNumber, sourceFragment);

                        wrapperScriptException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                                 originalException);
                    }
                    else
                    {
                        callStack = JsErrorHelpers.StringifyErrorLocationItems(errorLocationItems, true);
                        string callStackWithSourceFragment = JsErrorHelpers.StringifyErrorLocationItems(
                            errorLocationItems);
                        message = JsErrorHelpers.GenerateScriptErrorMessage(type, description,
                                                                            callStackWithSourceFragment);

                        wrapperScriptException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                             originalException)
                        {
                            CallStack = callStack
                        };
                    }

                    wrapperScriptException.Type           = type;
                    wrapperScriptException.DocumentName   = documentName;
                    wrapperScriptException.LineNumber     = lineNumber;
                    wrapperScriptException.ColumnNumber   = columnNumber;
                    wrapperScriptException.SourceFragment = sourceFragment;

                    wrapperException = wrapperScriptException;
                }
                else
                {
                    wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                            originalException);
                }
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
		private static JsEvaluationErrorViewModel GetJsEvaluationErrorFromException(JsException jsException)
		{
			var jsError = new JsEvaluationErrorViewModel
			{
				EngineName = GetEngineDisplayName(jsException.EngineName),
				EngineVersion = jsException.EngineVersion,
				Message = jsException.Message
			};

			return jsError;
		}
Exemplo n.º 7
0
        private static WrapperException WrapJsException(OriginalException originalException,
                                                        string defaultDocumentName = null)
        {
            WrapperException wrapperException;
            JsErrorCode      errorCode    = originalException.ErrorCode;
            string           description  = originalException.Message;
            string           message      = description;
            string           type         = string.Empty;
            string           documentName = defaultDocumentName ?? string.Empty;
            int    lineNumber             = 0;
            int    columnNumber           = 0;
            string callStack      = string.Empty;
            string sourceFragment = string.Empty;

            var originalScriptException = originalException as OriginalScriptException;

            if (originalScriptException != null)
            {
                JsValue metadataValue = originalScriptException.Metadata;

                if (metadataValue.IsValid)
                {
                    JsValue     errorValue     = metadataValue.GetProperty("exception");
                    JsValueType errorValueType = errorValue.ValueType;

                    if (errorValueType == JsValueType.Error ||
                        errorValueType == JsValueType.Object)
                    {
                        JsPropertyId innerErrorPropertyId = JsPropertyId.FromString("innerException");
                        if (errorValue.HasProperty(innerErrorPropertyId))
                        {
                            JsValue      innerErrorValue    = errorValue.GetProperty(innerErrorPropertyId);
                            JsPropertyId metadataPropertyId = JsPropertyId.FromString("metadata");

                            if (innerErrorValue.HasProperty(metadataPropertyId))
                            {
                                errorValue    = innerErrorValue;
                                metadataValue = innerErrorValue.GetProperty(metadataPropertyId);
                            }
                        }

                        JsValue messagePropertyValue = errorValue.GetProperty("message");
                        string  localDescription     = messagePropertyValue.ConvertToString().ToString();
                        if (!string.IsNullOrWhiteSpace(localDescription))
                        {
                            description = localDescription;
                        }

                        JsValue namePropertyValue = errorValue.GetProperty("name");
                        type = namePropertyValue.ValueType == JsValueType.String ?
                               namePropertyValue.ToString() : string.Empty;

                        JsPropertyId descriptionPropertyId = JsPropertyId.FromString("description");
                        if (errorValue.HasProperty(descriptionPropertyId))
                        {
                            JsValue descriptionPropertyValue = errorValue.GetProperty(descriptionPropertyId);
                            localDescription = descriptionPropertyValue.ConvertToString().ToString();
                            if (!string.IsNullOrWhiteSpace(localDescription))
                            {
                                description = localDescription;
                            }
                        }

                        if (type == JsErrorType.Syntax)
                        {
                            errorCode = JsErrorCode.ScriptCompile;
                        }
                        else
                        {
                            JsPropertyId numberPropertyId = JsPropertyId.FromString("number");
                            if (errorValue.HasProperty(numberPropertyId))
                            {
                                JsValue numberPropertyValue = errorValue.GetProperty(numberPropertyId);
                                int     errorNumber         = numberPropertyValue.ValueType == JsValueType.Number ?
                                                              numberPropertyValue.ToInt32() : 0;
                                errorCode = (JsErrorCode)errorNumber;
                            }
                        }

                        JsPropertyId urlPropertyId = JsPropertyId.FromString("url");
                        if (metadataValue.HasProperty(urlPropertyId))
                        {
                            JsValue urlPropertyValue = metadataValue.GetProperty(urlPropertyId);
                            string  url = urlPropertyValue.ValueType == JsValueType.String ?
                                          urlPropertyValue.ToString() : string.Empty;
                            if (url != "undefined")
                            {
                                documentName = url;
                            }
                        }

                        JsPropertyId linePropertyId = JsPropertyId.FromString("line");
                        if (metadataValue.HasProperty(linePropertyId))
                        {
                            JsValue linePropertyValue = metadataValue.GetProperty(linePropertyId);
                            lineNumber = linePropertyValue.ValueType == JsValueType.Number ?
                                         linePropertyValue.ToInt32() + 1 : 0;
                        }

                        JsPropertyId columnPropertyId = JsPropertyId.FromString("column");
                        if (metadataValue.HasProperty(columnPropertyId))
                        {
                            JsValue columnPropertyValue = metadataValue.GetProperty(columnPropertyId);
                            columnNumber = columnPropertyValue.ValueType == JsValueType.Number ?
                                           columnPropertyValue.ToInt32() + 1 : 0;
                        }

                        string       sourceLine       = string.Empty;
                        JsPropertyId sourcePropertyId = JsPropertyId.FromString("source");
                        if (metadataValue.HasProperty(sourcePropertyId))
                        {
                            JsValue sourcePropertyValue = metadataValue.GetProperty(sourcePropertyId);
                            sourceLine = sourcePropertyValue.ValueType == JsValueType.String ?
                                         sourcePropertyValue.ToString() : string.Empty;
                            sourceFragment = TextHelpers.GetTextFragmentFromLine(sourceLine, columnNumber);
                        }

                        JsPropertyId stackPropertyId = JsPropertyId.FromString("stack");
                        if (errorValue.HasProperty(stackPropertyId))
                        {
                            JsValue stackPropertyValue          = errorValue.GetProperty(stackPropertyId);
                            string  messageWithTypeAndCallStack = stackPropertyValue.ValueType == JsValueType.String ?
                                                                  stackPropertyValue.ToString() : string.Empty;
                            string messageWithType = errorValue.ConvertToString().ToString();
                            string rawCallStack    = messageWithTypeAndCallStack
                                                     .TrimStart(messageWithType)
                                                     .TrimStart("Error")
                                                     .TrimStart(new char[] { '\n', '\r' })
                            ;
                            string callStackWithSourceFragment = string.Empty;

                            ErrorLocationItem[] callStackItems = CoreErrorHelpers.ParseErrorLocation(rawCallStack);
                            if (callStackItems.Length > 0)
                            {
                                ErrorLocationItem firstCallStackItem = callStackItems[0];
                                firstCallStackItem.SourceFragment = sourceFragment;

                                documentName = firstCallStackItem.DocumentName;
                                lineNumber   = firstCallStackItem.LineNumber;
                                columnNumber = firstCallStackItem.ColumnNumber;
                                callStack    = CoreErrorHelpers.StringifyErrorLocationItems(callStackItems, true);
                                callStackWithSourceFragment = CoreErrorHelpers.StringifyErrorLocationItems(callStackItems);
                            }

                            message = CoreErrorHelpers.GenerateScriptErrorMessage(type, description,
                                                                                  callStackWithSourceFragment);
                        }
                        else
                        {
                            message = CoreErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                                  lineNumber, columnNumber, sourceFragment);
                        }
                    }
                    else if (errorValueType == JsValueType.String)
                    {
                        message     = errorValue.ToString();
                        description = message;
                    }
                    else
                    {
                        message     = errorValue.ConvertToString().ToString();
                        description = message;
                    }
                }

                WrapperScriptException wrapperScriptException;
                if (errorCode == JsErrorCode.ScriptCompile)
                {
                    wrapperScriptException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                             originalScriptException);
                }
                else if (errorCode == JsErrorCode.ScriptTerminated)
                {
                    message     = CoreStrings.Runtime_ScriptInterrupted;
                    description = message;

                    wrapperScriptException = new WrapperInterruptedException(message,
                                                                             EngineName, EngineVersion, originalScriptException)
                    {
                        CallStack = callStack
                    };
                }
                else
                {
                    wrapperScriptException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                         originalScriptException)
                    {
                        CallStack = callStack
                    };
                }
                wrapperScriptException.Type           = type;
                wrapperScriptException.DocumentName   = documentName;
                wrapperScriptException.LineNumber     = lineNumber;
                wrapperScriptException.ColumnNumber   = columnNumber;
                wrapperScriptException.SourceFragment = sourceFragment;

                wrapperException = wrapperScriptException;
            }
            else
            {
                if (originalException is OriginalUsageException)
                {
                    wrapperException = new WrapperUsageException(message, EngineName, EngineVersion,
                                                                 originalException);
                }
                else if (originalException is OriginalEngineException)
                {
                    wrapperException = new WrapperEngineException(message, EngineName, EngineVersion,
                                                                  originalException);
                }
                else if (originalException is OriginalFatalException)
                {
                    wrapperException = new WrapperFatalException(message, EngineName, EngineVersion,
                                                                 originalException);
                }
                else
                {
                    wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                            originalException);
                }
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
Exemplo n.º 8
0
        private static JsValue CreateErrorFromWrapperException(WrapperException exception)
        {
            var         originalException = exception.InnerException as JsException;
            JsErrorCode errorCode         = originalException != null ?
                                            originalException.ErrorCode : JsErrorCode.NoError;
            string description = exception.Description;

            JsValue innerErrorValue = JsErrorHelpers.CreateError(description);

            innerErrorValue.SetProperty("description", JsValue.FromString(description), true);

            JsValue metadataValue = JsValue.CreateObject();

            var scriptException = exception as WrapperScriptException;

            if (scriptException != null)
            {
                string type         = scriptException.Type;
                string documentName = scriptException.DocumentName;
                int    lineNumber   = scriptException.LineNumber;
                if (lineNumber > 0)
                {
                    lineNumber--;
                }
                int columnNumber = scriptException.ColumnNumber;
                if (columnNumber > 0)
                {
                    columnNumber--;
                }
                string sourceFragment = scriptException.SourceFragment;

                innerErrorValue.SetProperty("name", JsValue.FromString(type), true);

                var runtimeException = scriptException as WrapperRuntimeException;
                if (runtimeException != null)
                {
                    var    errorNumber = (int)errorCode;
                    string callStack   = runtimeException.CallStack;
                    string messageWithTypeAndCallStack = CoreErrorHelpers.GenerateScriptErrorMessage(type,
                                                                                                     description, callStack);

                    innerErrorValue.SetProperty("number", JsValue.FromInt32(errorNumber), true);
                    if (!string.IsNullOrWhiteSpace(callStack))
                    {
                        innerErrorValue.SetProperty("stack", JsValue.FromString(messageWithTypeAndCallStack), true);
                    }
                }
                else
                {
                    innerErrorValue.SetProperty("url", JsValue.FromString(documentName), true);
                    innerErrorValue.SetProperty("line", JsValue.FromInt32(lineNumber), true);
                    innerErrorValue.SetProperty("column", JsValue.FromInt32(columnNumber), true);
                    innerErrorValue.SetProperty("source", JsValue.FromString(sourceFragment), true);
                }

                metadataValue.SetProperty("url", JsValue.FromString(documentName), true);
                metadataValue.SetProperty("line", JsValue.FromInt32(lineNumber), true);
                metadataValue.SetProperty("column", JsValue.FromInt32(columnNumber), true);
                metadataValue.SetProperty("source", JsValue.FromString(sourceFragment), true);
            }

            innerErrorValue.SetProperty("metadata", metadataValue, true);

            JsValue errorValue = JsErrorHelpers.CreateError(description);

            errorValue.SetProperty("innerException", innerErrorValue, true);

            return(errorValue);
        }
        private WrapperException WrapInvocationException(InvocationException originalException)
        {
            WrapperException wrapperException;
            string           message     = originalException.Message;
            string           description = string.Empty;

            if (_timeoutErrorMessage.IsMatch(message))
            {
                message     = CoreStrings.Runtime_ScriptTimeoutExceeded;
                description = message;

                var wrapperTimeoutException = new WrapperTimeoutException(message, EngineName, _engineVersion,
                                                                          originalException)
                {
                    Description = description
                };

                return(wrapperTimeoutException);
            }

            string documentName = string.Empty;
            int    lineNumber   = 0;
            int    columnNumber = 0;
            string sourceLine   = string.Empty;

            Match detailsMatch  = _errorDetailsRegex.Match(message);
            int   detailsLength = 0;

            if (detailsMatch.Success)
            {
                GroupCollection detailsGroups = detailsMatch.Groups;
                description  = detailsGroups["description"].Value;
                documentName = detailsGroups["documentName"].Success ?
                               detailsGroups["documentName"].Value : string.Empty;
                lineNumber = detailsGroups["lineNumber"].Success ?
                             int.Parse(detailsGroups["lineNumber"].Value) : 0;
                columnNumber = NodeJsErrorHelpers.GetColumnCountFromLine(detailsGroups["pointer"].Value);
                sourceLine   = detailsGroups["sourceLine"].Value;

                detailsLength = detailsMatch.Length;
            }

            message = detailsLength > 0 ? message.Substring(detailsLength) : message;

            Match messageWithTypeMatch = _errorMessageWithTypeRegex.Match(message);

            if (messageWithTypeMatch.Success)
            {
                GroupCollection messageWithTypeGroups = messageWithTypeMatch.Groups;
                string          type = messageWithTypeGroups["type"].Value;
                description = messageWithTypeGroups["description"].Value;
                string sourceFragment = TextHelpers.GetTextFragmentFromLine(sourceLine, columnNumber);

                WrapperScriptException wrapperScriptException;
                if (type == JsErrorType.Syntax)
                {
                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                        lineNumber, columnNumber, sourceFragment);

                    wrapperScriptException = new WrapperCompilationException(message, EngineName, _engineVersion,
                                                                             originalException);
                }
                else if (type == "UsageError")
                {
                    wrapperException = new WrapperUsageException(description, EngineName, _engineVersion,
                                                                 originalException);
                    wrapperException.Description = description;

                    return(wrapperException);
                }
                else
                {
                    var errorLocationItems    = new ErrorLocationItem[0];
                    int messageLength         = message.Length;
                    int messageWithTypeLength = messageWithTypeMatch.Length;

                    if (messageWithTypeLength < messageLength)
                    {
                        string errorLocation = message.Substring(messageWithTypeLength);
                        errorLocationItems = NodeJsErrorHelpers.ParseErrorLocation(errorLocation);
                        errorLocationItems = FilterErrorLocationItems(errorLocationItems);

                        if (errorLocationItems.Length > 0)
                        {
                            ErrorLocationItem firstErrorLocationItem = errorLocationItems[0];
                            documentName = firstErrorLocationItem.DocumentName;
                            lineNumber   = firstErrorLocationItem.LineNumber;
                            columnNumber = firstErrorLocationItem.ColumnNumber;

                            firstErrorLocationItem.SourceFragment = sourceFragment;
                        }
                    }

                    string callStack = JsErrorHelpers.StringifyErrorLocationItems(errorLocationItems, true);
                    string callStackWithSourceFragment = JsErrorHelpers.StringifyErrorLocationItems(
                        errorLocationItems);
                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description,
                                                                        callStackWithSourceFragment);

                    wrapperScriptException = new WrapperRuntimeException(message, EngineName, _engineVersion,
                                                                         originalException)
                    {
                        CallStack = callStack
                    };
                }

                wrapperScriptException.Type           = type;
                wrapperScriptException.DocumentName   = documentName;
                wrapperScriptException.LineNumber     = lineNumber;
                wrapperScriptException.ColumnNumber   = columnNumber;
                wrapperScriptException.SourceFragment = sourceFragment;

                wrapperException = wrapperScriptException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, _engineVersion,
                                                        originalException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
        private WrapperException WrapJsException(OriginalException originalException)
        {
            WrapperException wrapperException;

            var originalScriptException = originalException as OriginalScriptException;

            if (originalScriptException != null)
            {
                WrapperScriptException wrapperScriptException;

                var originalRuntimeException = originalScriptException as OriginalRuntimeException;
                if (originalRuntimeException != null)
                {
                    WrapperRuntimeException wrapperRuntimeException;
                    if (originalRuntimeException is OriginalInterruptedException)
                    {
                        wrapperRuntimeException = new WrapperInterruptedException(originalScriptException.Message,
                                                                                  EngineName, _engineVersion, originalRuntimeException);
                    }
                    else
                    {
                        wrapperRuntimeException = new WrapperRuntimeException(originalScriptException.Message,
                                                                              EngineName, _engineVersion, originalRuntimeException);
                    }
                    wrapperRuntimeException.CallStack = originalRuntimeException.CallStack;

                    wrapperScriptException = wrapperRuntimeException;
                }
                else if (originalScriptException is OriginalCompilationException)
                {
                    wrapperScriptException = new WrapperCompilationException(originalScriptException.Message,
                                                                             EngineName, _engineVersion, originalScriptException);
                }
                else
                {
                    wrapperScriptException = new WrapperScriptException(originalScriptException.Message,
                                                                        EngineName, _engineVersion, originalScriptException);
                }

                wrapperScriptException.Type           = originalScriptException.Type;
                wrapperScriptException.DocumentName   = originalScriptException.DocumentName;
                wrapperScriptException.LineNumber     = originalScriptException.LineNumber;
                wrapperScriptException.ColumnNumber   = originalScriptException.ColumnNumber;
                wrapperScriptException.SourceFragment = originalScriptException.SourceFragment;

                wrapperException = wrapperScriptException;
            }
            else
            {
                if (originalException is OriginalUsageException)
                {
                    wrapperException = new WrapperUsageException(originalException.Message,
                                                                 EngineName, _engineVersion, originalException);
                }
                else if (originalException is OriginalEngineException)
                {
                    if (originalException is OriginalEngineLoadException)
                    {
                        wrapperException = new WrapperEngineLoadException(originalException.Message,
                                                                          EngineName, _engineVersion, originalException);
                    }
                    else
                    {
                        wrapperException = new WrapperEngineException(originalException.Message,
                                                                      EngineName, _engineVersion, originalException);
                    }
                }
                else if (originalException is OriginalFatalException)
                {
                    wrapperException = new WrapperFatalException(originalException.Message,
                                                                 EngineName, _engineVersion, originalException);
                }
                else
                {
                    wrapperException = new WrapperException(originalException.Message,
                                                            EngineName, _engineVersion, originalException);
                }
            }

            wrapperException.Description = originalException.Description;

            return(wrapperException);
        }