mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
338 lines
12 KiB
C#
338 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="MobileErrorInfo.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.Text.RegularExpressions;
|
|
using System.Security.Permissions;
|
|
|
|
namespace System.Web.Mobile
|
|
{
|
|
/*
|
|
* Mobile Error Info
|
|
* Contains information about an error that occurs in a mobile application.
|
|
* This information can be used to format the error for the target device.
|
|
*
|
|
*
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
|
|
[Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
|
|
public class MobileErrorInfo
|
|
{
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.ContextKey"]/*' />
|
|
public static readonly String ContextKey = "MobileErrorInfo";
|
|
private static object _lockObject = new object();
|
|
|
|
private const String _errorType = "Type";
|
|
private const String _errorDescription = "Description";
|
|
private const String _errorMiscTitle = "MiscTitle";
|
|
private const String _errorMiscText = "MiscText";
|
|
private const String _errorFile = "File";
|
|
private const String _errorLineNumber = "LineNumber";
|
|
private static Regex[] _searchExpressions = null;
|
|
private static bool _searchExpressionsBuilt = false;
|
|
private const int _expressionCount = 3;
|
|
|
|
private StringDictionary _dictionary = new StringDictionary();
|
|
|
|
internal MobileErrorInfo(Exception e)
|
|
{
|
|
// Don't want any failure to escape here...
|
|
try
|
|
{
|
|
// For some reason, the compile exception lives in the
|
|
// InnerException.
|
|
HttpCompileException compileException =
|
|
e.InnerException as HttpCompileException;
|
|
|
|
if (compileException != null)
|
|
{
|
|
this.Type = SR.GetString(SR.MobileErrorInfo_CompilationErrorType);
|
|
this.Description = SR.GetString(SR.MobileErrorInfo_CompilationErrorDescription);
|
|
this.MiscTitle = SR.GetString(SR.MobileErrorInfo_CompilationErrorMiscTitle);
|
|
|
|
CompilerErrorCollection errors = compileException.Results.Errors;
|
|
|
|
if (errors != null && errors.Count >= 1)
|
|
{
|
|
CompilerError error = errors[0];
|
|
this.LineNumber = error.Line.ToString(CultureInfo.InvariantCulture);
|
|
this.File = error.FileName;
|
|
this.MiscText = error.ErrorNumber + ":" + error.ErrorText;
|
|
}
|
|
else
|
|
{
|
|
this.LineNumber = SR.GetString(SR.MobileErrorInfo_Unknown);
|
|
this.File = SR.GetString(SR.MobileErrorInfo_Unknown);
|
|
this.MiscText = SR.GetString(SR.MobileErrorInfo_Unknown);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
HttpParseException parseException = e as HttpParseException;
|
|
if (parseException != null)
|
|
{
|
|
this.Type = SR.GetString(SR.MobileErrorInfo_ParserErrorType);
|
|
this.Description = SR.GetString(SR.MobileErrorInfo_ParserErrorDescription);
|
|
this.MiscTitle = SR.GetString(SR.MobileErrorInfo_ParserErrorMiscTitle);
|
|
this.LineNumber = parseException.Line.ToString(CultureInfo.InvariantCulture);
|
|
this.File = parseException.FileName;
|
|
this.MiscText = parseException.Message;
|
|
return;
|
|
}
|
|
|
|
// We try to use the hacky way of parsing an HttpException of an
|
|
// unknown subclass.
|
|
HttpException httpException = e as HttpException;
|
|
if (httpException != null && ParseHttpException(httpException))
|
|
{
|
|
return;
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
// Don't need to do anything here, just continue to base case
|
|
// below.
|
|
}
|
|
|
|
// Default to the most basic if none of the above succeed.
|
|
this.Type = e.GetType().FullName;
|
|
this.Description = e.Message;
|
|
this.MiscTitle = SR.GetString(SR.MobileErrorInfo_SourceObject);
|
|
String s = e.StackTrace;
|
|
if(s != null) {
|
|
int i = s.IndexOf('\r');
|
|
if (i != -1)
|
|
{
|
|
s = s.Substring(0, i);
|
|
}
|
|
this.MiscText = s;
|
|
}
|
|
}
|
|
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.this"]/*' />
|
|
public String this[String key]
|
|
{
|
|
get
|
|
{
|
|
String s = _dictionary[key];
|
|
return (s == null) ? String.Empty : s;
|
|
}
|
|
set
|
|
{
|
|
_dictionary[key] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.Type"]/*' />
|
|
public String Type
|
|
{
|
|
get
|
|
{
|
|
return this[_errorType];
|
|
}
|
|
set
|
|
{
|
|
this[_errorType] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.Description"]/*' />
|
|
public String Description
|
|
{
|
|
get
|
|
{
|
|
return this[_errorDescription];
|
|
}
|
|
set
|
|
{
|
|
this[_errorDescription] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.MiscTitle"]/*' />
|
|
public String MiscTitle
|
|
{
|
|
get
|
|
{
|
|
return this[_errorMiscTitle];
|
|
}
|
|
set
|
|
{
|
|
this[_errorMiscTitle] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.MiscText"]/*' />
|
|
public String MiscText
|
|
{
|
|
get
|
|
{
|
|
return this[_errorMiscText];
|
|
}
|
|
set
|
|
{
|
|
this[_errorMiscText] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.File"]/*' />
|
|
public String File
|
|
{
|
|
get
|
|
{
|
|
return this[_errorFile];
|
|
}
|
|
set
|
|
{
|
|
this[_errorFile] = value;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\MobileErrorInfo.uex' path='docs/doc[@for="MobileErrorInfo.LineNumber"]/*' />
|
|
public String LineNumber
|
|
{
|
|
get
|
|
{
|
|
return this[_errorLineNumber];
|
|
}
|
|
set
|
|
{
|
|
this[_errorLineNumber] = value;
|
|
}
|
|
}
|
|
|
|
// Return true if we succeed
|
|
private bool ParseHttpException(HttpException e)
|
|
{
|
|
int i;
|
|
Match match = null;
|
|
|
|
String errorMessage = e.GetHtmlErrorMessage();
|
|
if (errorMessage == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Use regular expressions to scrape the message output
|
|
// for meaningful data. One problem: Some parts of the
|
|
// output are optional, and any regular expression that
|
|
// uses the ()? syntax doesn't pick it up. So, we have
|
|
// to have all the different combinations of expressions,
|
|
// and use each one in order.
|
|
|
|
EnsureSearchExpressions();
|
|
for (i = 0; i < _expressionCount; i++)
|
|
{
|
|
match = _searchExpressions[i].Match(errorMessage);
|
|
if (match.Success)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == _expressionCount)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
this.Type = TrimAndClean(match.Result("${title}"));
|
|
this.Description = TrimAndClean(match.Result("${description}"));
|
|
if (i <= 1)
|
|
{
|
|
// These expressions were able to match the miscellaneous
|
|
// title/text section.
|
|
this.MiscTitle = TrimAndClean(match.Result("${misctitle}"));
|
|
this.MiscText = TrimAndClean(match.Result("${misctext}"));
|
|
}
|
|
if (i == 0)
|
|
{
|
|
// This expression was able to match the file/line #
|
|
// section.
|
|
this.File = TrimAndClean(match.Result("${file}"));
|
|
this.LineNumber = TrimAndClean(match.Result("${linenumber}"));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static void EnsureSearchExpressions()
|
|
{
|
|
// Create precompiled search expressions. They're here
|
|
// rather than in static variables, so that we can load
|
|
// them from resources on demand. But once they're loaded,
|
|
// they're compiled and always available.
|
|
|
|
if (!_searchExpressionsBuilt)
|
|
{
|
|
lock(_lockObject)
|
|
{
|
|
if (!_searchExpressionsBuilt)
|
|
{
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Why three similar expressions? See ParseHttpException above.
|
|
|
|
_searchExpressions = new Regex[_expressionCount];
|
|
|
|
_searchExpressions[0] = new Regex(
|
|
"<title>(?'title'.*?)</title>.*?" +
|
|
": </b>(?'description'.*?)<br>.*?" +
|
|
"(<b>(?'misctitle'.*?): </b>(?'misctext'.*?)<br)+.*?" +
|
|
"(Source File:</b>(?'file'.*?) <b>Line:</b>(?'linenumber'.*?)<br)+",
|
|
RegexOptions.Singleline |
|
|
RegexOptions.IgnoreCase |
|
|
RegexOptions.CultureInvariant |
|
|
RegexOptions.Compiled);
|
|
|
|
_searchExpressions[1] = new Regex(
|
|
"<title>(?'title'.*?)</title>.*?" +
|
|
": </b>(?'description'.*?)<br>.*?" +
|
|
"(<b>(?'misctitle'.*?): </b>(?'misctext'.*?)<br)+.*?",
|
|
RegexOptions.Singleline |
|
|
RegexOptions.IgnoreCase |
|
|
RegexOptions.CultureInvariant |
|
|
RegexOptions.Compiled);
|
|
|
|
_searchExpressions[2] = new Regex(
|
|
"<title>(?'title'.*?)</title>.*?: </b>(?'description'.*?)<br>",
|
|
RegexOptions.Singleline |
|
|
RegexOptions.IgnoreCase |
|
|
RegexOptions.CultureInvariant |
|
|
RegexOptions.Compiled);
|
|
|
|
_searchExpressionsBuilt = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static String TrimAndClean(String s)
|
|
{
|
|
return s.Replace("\r\n", " ").Trim();
|
|
}
|
|
}
|
|
}
|
|
|
|
|