static private void HandleError(int eOffset, string eValue, ErrorKind ekind)
{
Error e = new Error();
e.line = SourceViewModel.GetLine(eOffset);
e.lineOffset = SourceViewModel.GetLineOffset(eOffset);
e.length = eValue.Length;
e.kind = ekind;
switch (ekind)
{
case ErrorKind.ANNONOTCLOSED:
e.infomation = "注释未闭合";
break;
case ErrorKind.NUMBERERROR:
e.infomation = string.Format("数字 {0} 格式错误", eValue);
break;
case ErrorKind.INVALIDCHAR:
e.infomation = string.Format("无法识别的字符: {0}", eValue);
break;
case ErrorKind.NESTBRA:
e.infomation = "出现嵌套的注释";
break;
default:
e.infomation = string.Format("未知类型错误: {0}", eValue);
break;
}
}
private string GetError(ErrorKind kind)
{
switch (kind)
{
case ErrorKind.BeforeOpeningBrace:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorBeforeOpeningBrace));
case ErrorKind.AfterOpeningBrace:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorAfterOpeningBrace));
case ErrorKind.BeforeClosingBrace:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorBeforeClosingInnerBrace));
case ErrorKind.Operator:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorOperator));
case ErrorKind.BeforePipe:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorSpaceBeforePipe));
case ErrorKind.AfterPipe:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorSpaceAfterPipe));
case ErrorKind.SeparatorComma:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorSeparatorComma));
case ErrorKind.SeparatorSemi:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorSeparatorSemi));
default:
return(string.Format(CultureInfo.CurrentCulture, Strings.UseConsistentWhitespaceErrorBeforeParen));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ErrorDialog"/> class.
/// </summary>
/// <param name="message">The error message to display.</param>
/// <param name="kind">The <see cref="ErrorKind"/> of the error.</param>
public ErrorDialog(string message, ErrorKind kind = ErrorKind.Nonfatal)
{
InitializeComponent();
Kind = kind;
Message = message;
ProceedButton.Content = kind == ErrorKind.Fatal ? "Quit LASI" : "Continue";
}
public Error(string message, int line, int column, ErrorKind errorKind)
{
_message = message;
_line = line;
_column = column;
_errorKind = errorKind;
}
private async Task SetErrorViewAsync()
{
Debug.WriteLine("NewsViewModel - SetServiceError()");
if (ErrorKind == ServiceErrorKind.None)
{
return;
}
if (IsRefreshing)
{
IsRefreshing = false;
}
var eventPage = ErrorKind.ToNewsServiceErrorPage();
_eventTracker.Display(eventPage);
ErrorTitle = ErrorKind.ToTitle();
ErrorDescription = ErrorKind.ToMessage();
if (HasEmptyData)
{
ShowErrorView = true;
}
else
{
await UserDialogs.Instance.AlertAsync(ErrorDescription, ErrorTitle, "OK");
}
}
//------------------------------------------------------------
// 型が２つあるコンストラクタ。
public ErrorInfo(ErrorKind aErrorKind, ModuleContext aModuleContext, Token aErrorToken, TypeInfo aTypeInfoA, TypeInfo aTypeInfoB)
{
Kind = aErrorKind;
ModuleContext = aModuleContext;
Token = aErrorToken;
TypeInfoA = aTypeInfoA;
TypeInfoB = aTypeInfoB;
}
public Error(Token token, ErrorKind kind, string message)
{
Token = token;
Kind = kind;
ErrorMessage = message;
}
static ProgramException Throwable(ErrorKind kind, string source, string message)
{
return(new ProgramException(message)
{
Kind = kind,
Source = source,
});
}
//------------------------------------------------------------
// 指定できない属性のチェック。trueが返ってきたらエラー扱い。
bool checkErrorSymbolDefIllegalAttr(Token aToken, ErrorKind aErrorKind)
{
if (aToken != null)
{
setErrorKind(aErrorKind, aToken);
return(true);
}
return(false);
}
//------------------------------------------------------------
/// <summary>
/// 指定のトークンの種類であることを期待する。
/// 期待通りであればトークンを次に進めtrueを返す。
/// 期待通りでなければ指定のエラーを設定しfalseを返す。
/// </summary>
/// <param name="kind"></param>
/// <param name="errorKind"></param>
/// <returns></returns>
bool expectToken(Token.Kind aKind, ErrorKind aErrorKind)
{
if (currentToken().Value != aKind)
{
setErrorKind(aErrorKind);
return(false);
}
nextToken();
return(true);
}
public AzPSResourceNotFoundCloudException(
string message,
ErrorKind errorKind,
string desensitizedMessage = null,
Exception innerException = null,
[CallerLineNumber] int lineNumber = 0,
[CallerFilePath] string filePath = null)
: base(message, errorKind, desensitizedMessage, innerException, lineNumber, filePath)
{
}
/// <summary>
/// Shortcut for creating unknown error
/// </summary>
/// <param name="kind">The kind of error</param>
/// <param name="code">The code of error</param>
/// <param name="message">The error message</param>
/// <param name="payload">The payload</param>
/// <returns></returns>
public static ErrorDefinition From(ErrorKind kind, string code, string message, Dictionary <string, object> payload = null)
{
return(new ErrorDefinition
{
Kind = kind,
Code = code ?? Errors.UNKNOWN_ERROR,
Message = message ?? string.Empty,
Payload = payload
});
}
private void defaultErrorDelegate(ErrorKind error, ErrorLevel level, string errormessage)
{
if (level == ErrorLevel.K_LWARN) {
// TODO: use a user supplied callback here or provide some other mechanism to override this
// NOTE: if using a callback here, the user _must not_ throw exceptions in that callback
/* Console.WriteLine("nlibk warning: {0}", errormessage); */
return;
}
LastError = error;
LastErrorMessage = errormessage;
}
public void RaiseError(ErrorKind kind)
{
switch (kind)
{
case ErrorKind.PortError:
this.PortError();
break;
default:
break;
}
}
public ErrorLogEntry(OperationContext context, string message, string details, ErrorKind kind = ErrorKind.Internal,
string appName = null, string userName = null, DateTime?remoteTime = null)
: base(context, LogEntryType.Error)
{
Message = message;
Details = details;
Kind = kind;
LogContents = context?.GetLogContents();
AppName = appName ?? context?.App?.AppName;
this.RemoteUserName = userName;
RemoteTime = remoteTime;
}
private void CheckUndefinedState(string name, ErrorKind errorKind)
{
if (name == null)
{
return;
}
if (!ast.States.ContainsKey(name))
{
ast.Errors.Add(new AnalysisError(errorKind, name));
}
}
protected override void Decode(byte[] Data)
{
if ((Data[0] >> 7) == 0)
{
Error = ErrorKind.NoError;
base.Decode(Data);
}
else
{
Index = Data[0] & 0x7F;
Error = (ErrorKind)(Data[1]);
}
}
// Remote/client error, or error without explicit exception
public ErrorLogEntry(LogContext context, string message, string details, ErrorKind kind = ErrorKind.Internal,
DateTime?remoteTime = null)
: base(context)
{
Message = message;
Details = details;
Kind = kind;
if (remoteTime != null)
{
this.CreatedOn = remoteTime.Value;
}
Exception = new Exception(message);
ExceptionType = kind.ToString();
}
private DiagnosticRecord getDiagnosticRecord(
Token token,
ErrorKind errKind,
List <CorrectionExtent> corrections)
{
return(new DiagnosticRecord(
GetError(errKind),
token.Extent,
GetName(),
GetDiagnosticSeverity(),
token.Extent.File,
null,
corrections));
}
private static string GetErrorMessage(ErrorKind type)
{
var reason = type switch
{
ErrorKind.NoIdClaim => Resource.ExceptionJwtUserTokenBadFormatReasonIdMissing,
ErrorKind.IdClaimBadFormat => Resource.ExceptionJwtUserTokenBadFormatReasonIdBadFormat,
ErrorKind.NoVersionClaim => Resource.ExceptionJwtUserTokenBadFormatReasonVersionMissing,
ErrorKind.VersionClaimBadFormat => Resource.ExceptionJwtUserTokenBadFormatReasonVersionBadFormat,
ErrorKind.Other => Resource.ExceptionJwtUserTokenBadFormatReasonOthers,
_ => Resource.ExceptionJwtUserTokenBadFormatReasonUnknown
};
return(string.Format(CultureInfo.CurrentCulture, Resource.ExceptionJwtUserTokenBadFormat, reason));
}
}
private async Task RetryAsync()
{
Debug.WriteLine("NewsViewModel - RetryAsync()");
var eventName = ErrorKind.ToEventName();
_eventTracker?.Click(eventName, EventPage.NewsPage, EventPage.NewsPage);
try
{
await GetNewsAsync(false);
}
catch (Exception ex)
{
_eventTracker.Error(ex);
}
}
private void Retry(object sender)
{
Debug.WriteLine($"BookingViewModel - Retry()");
var eventName = ErrorKind.ToEventName();
_eventTracker?.Click(eventName, EventPage.BookingPage, EventPage.BookingPage);
try
{
var webView = sender as CustomWebView;
ReloadWebview(webView, true);
}
catch (Exception ex)
{
_eventTracker.Error(ex);
}
}
// common code for errors that can be handled
static void Raise(ErrorKind kind, string source, string message)
{
bool handled = (kind != ErrorKind.Panic && ErrorEvent != null && ErrorEvent(source, message)) ||
kind == ErrorKind.Warn;
if (!handled)
{
//string msg = "Fatal error " + source + ": " + message;
if (kind == ErrorKind.Warn)
{
Logger.WriteLine("Program error ({0}): {1}", source, message);
}
else
{
throw Throwable(kind, source, message);
}
}
}
private void SetErrorView()
{
Debug.WriteLine($"BookingViewModel - SetErrorView()");
if (ErrorKind == ServiceErrorKind.None)
{
return;
}
var eventPage = ErrorKind.ToBookingWebviewErrorPage();
_eventTracker.Display(eventPage);
ErrorTitle = ErrorKind.ToTitle();
ErrorDescription = ErrorKind.ToMessage();
ShowErrorView = true;
}
private void OnSocketConnectedOrSent(object sender, SocketAsyncEventArgs e)
{
try
{
if (e.SocketError != SocketError.Success)
{
Debug.LogWarning(LogPrefix + "Could not get NTP time from " + timeServer + " =/\n" + e.SocketError);
asyncError = ErrorKind.Unknown;
}
}
catch (Exception exception)
{
Debug.LogWarning(LogPrefix + "Could not get NTP time from " + timeServer + " =/\n" + exception);
asyncError = ErrorKind.Unknown;
}
finally
{
gettingOnlineTimeAsync = false;
}
}
public void Report(ErrorKind level, Cursor cursor, string text)
{
Report(level, cursor, 0, text);
}
public PacketHeader(MessageKind kind, ErrorKind error, uint responseTo)
{
Kind = kind;
Error = error;
SequenceNumberResponseTo = responseTo;
}
public void RaiseError(ErrorKind kind)
{
switch (kind)
{
case ErrorKind.PortError:
this.PortError();
break;
default:
break;
}
}
static public Token LexNext()
{
int state = 0;
string value = string.Empty;
int startOffset = 0;
ErrorKind errorKind = ErrorKind.DEFAULT;
char? cQuestion;
char c;
while (true)
{
cQuestion = SourceViewModel.NextChar();
if (cQuestion.HasValue)
{
c = cQuestion.Value;
switch (state)
{
case 0:
startOffset = SourceViewModel.GetOffset();
if (char.IsLetter(c) || c == '_')
{
state = 1;
value += c;
break;
}
if (char.IsDigit(c))
{
state = 2;
value += c;
break;
}
if (char.IsWhiteSpace(c))
{
break;
}
if (c == '>')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.GT));
}
if (c == '+')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.ADD));;
}
if (c == '-')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.SUB));
}
if (c == '*')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.MULT));
}
if (c == '/')
{
state = 7;
value += c;
break;
}
if (c == '=')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.EQU));
}
if (c == '<')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.LT));
}
if (c == '{')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.LBRA));
}
if (c == '}')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.RBRA));
}
if (c == '(')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.LPAR));
}
if (c == ')')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.RPAR));
}
if (c == ';')
{
value = c.ToString();
return(new Token(startOffset, value, TokenKind.SEMI));
}
if (c == '.')
{
state = 4;
value += c;
errorKind = ErrorKind.NUMBERERROR;
break;
}
//ERROR
state = 4;
value += c;
errorKind = ErrorKind.INVALIDCHAR;
break;
case 1:
if (char.IsLetterOrDigit(c))
{
value += c;
break;
}
SourceViewModel.putBack();
if (KeyWords.ContainsKey(value))
{
return(new Token(startOffset, value, KeyWords[value]));
}
else
{
return(new Token(startOffset, value, TokenKind.ID));
}
case 2:
if (char.IsDigit(c))
{
value += c;
break;
}
if (c == '.')
{
state = 5;
value += c;
break;
}
SourceViewModel.putBack();
return(new Token(startOffset, value, TokenKind.NUM));
case 3:
if (c == '*')
{
state = 9;
}
value += c;
break;
case 4:
switch (errorKind)
{
case ErrorKind.NUMBERERROR:
if (char.IsDigit(c) || c == '.')
{
value += c;
}
else
{
SourceViewModel.putBack();
HandleError(startOffset, value, errorKind);
return(new Token(startOffset, value, TokenKind.ERROR));
}
break;
case ErrorKind.INVALIDCHAR:
if (char.IsLetterOrDigit(c) || symbols.Contains(c) || char.IsWhiteSpace(c))
{
SourceViewModel.putBack();
HandleError(startOffset, value, errorKind);
return(new Token(startOffset, value, TokenKind.ERROR));
}
else
{
value += c;
}
break;
default:
if (char.IsWhiteSpace(c))
{
HandleError(startOffset, value, errorKind);
return(new Token(startOffset, value, TokenKind.ERROR));
}
else
{
value += c;
}
break;
}
break;
case 5:
if (char.IsDigit(c))
{
state = 6;
value += c;
break;
}
if (c == '.')
{
state = 4;
value += c;
errorKind = ErrorKind.NUMBERERROR;
break;
}
SourceViewModel.putBack();
HandleError(startOffset, value, ErrorKind.NUMBERERROR);
return(new Token(startOffset, value, TokenKind.ERROR));
case 6:
if (char.IsDigit(c))
{
state = 6;
value += c;
break;
}
if (c == '.')
{
state = 4;
value += c;
errorKind = ErrorKind.NUMBERERROR;
break;
}
SourceViewModel.putBack();
return(new Token(startOffset, value, TokenKind.NUM));
case 7:
if (c == '*')
{
value += c;
state = 3;
break;
}
if (c == '/')
{
value += c;
state = 8;
break;
}
SourceViewModel.putBack();
return(new Token(startOffset, value, TokenKind.DIV));
case 8:
if (c == '\r' || c == '\n') //for the case "\r\n" and "\n";
{
return(new Token(startOffset, value, TokenKind.ANNO));
}
value += c;
break;
case 9:
if (c == '/')
{
value += c;
return(new Token(startOffset, value, TokenKind.ANNO));
}
value += c;
state = 3;
break;
}
}
else
{
switch (state)
{
case 0:
return(new Token(SourceViewModel.GetEndOffset(), value, TokenKind.END));
case 1:
if (KeyWords.ContainsKey(value))
{
return(new Token(startOffset, value, KeyWords[value]));
}
else
{
return(new Token(startOffset, value, TokenKind.ID));
}
case 2:
case 6:
return(new Token(startOffset, value, TokenKind.NUM));
case 3:
case 9:
HandleError(startOffset, value, ErrorKind.ANNONOTCLOSED);
return(new Token(startOffset, value, TokenKind.ERROR));
case 4:
HandleError(startOffset, value, errorKind);
return(new Token(startOffset, value, TokenKind.ERROR));
case 5:
HandleError(startOffset, value, ErrorKind.NUMBERERROR);
return(new Token(startOffset, value, TokenKind.ERROR));
case 7:
return(new Token(startOffset, value, TokenKind.DIV));
case 8:
return(new Token(startOffset, value, TokenKind.ANNO));
}
}
}
}
public void PrintError(Cursor cursor, ErrorKind kind, int code, string text)
{
throw new ScannerError(cursor, string.Format("{0} {1}: {2}", kind.ToString(), code, text));
}
public Error(ErrorKind kind, string additionalData = null)
{
ErrorKind = kind;
AdditionalData = additionalData;
}
public Error(ErrorKind kind, string message = "")
{
this.Kind = kind;
this.Message = message;
}
public void Report(ErrorKind level, string text)
{
Report(level, null, 0, text);
}
public LogOnRequestResult(ErrorKind kind, UserInfo info, IEnumerable<int> onlineUsers)
{
Error = kind;
Info = info;
OnlineUsers = onlineUsers == null ? null : new List<int>(onlineUsers);
}
public LogOnRequestResult(ErrorKind kind, UserInfo info, IEnumerable <int> onlineUsers)
{
Error = kind;
Info = info;
OnlineUsers = onlineUsers == null ? null : new List <int>(onlineUsers);
}
/** Constructor for the \c Error class. */
public Error(ErrorKind level, Cursor cursor, int code, string text)
: base(cursor, text)
{
_level = level;
_code = code;
}
public void Report(ErrorKind level, int code, string text)
{
Report(level, null, code, text);
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="kind">The error kind.</param>
/// <param name="additional">Additional info.</param>
public ImageConversionException(ErrorKind kind, object additional)
: base($"Image Conversion Error kind={kind} {additional}")
{
}
public static BabelException FromServiceError(ServiceError error, ErrorKind kind)
{
BabelException res;
switch(kind)
{
//case ErrorKind.InvalidArgument: res = new BabelIllegalArgException(error.Details, error.Inner == null ? null : FromServiceError(error.Inner)); break;
case ErrorKind.InvalidRequest: res = new BabelApplicationException(error.Details, error.Inner == null ? null : FromServiceError(error.Inner, ErrorKind.Unknown)); break; //Inner errors are unknown kind
default: res = new BabelException(error.Details, error.Inner == null ? null : FromServiceError(error.Inner, ErrorKind.Unknown)); break; //Inner errors are unknown kind
}
if(error.Context != null)
{
foreach(var kv in error.Context)
{
res.Context.Add(kv.Key, kv.Value);
}
}
if(error.Errors != null)
{
res.m_errors.AddRange(error.Errors);
}
return res;
}
private IEnumerator GetOnlineTimeInternal()
{
gettingOnlineTimeAsync = false;
lastOnlineTime = 0;
asyncError = ErrorKind.NoError;
IPAddress[] addresses = null;
try
{
addresses = Dns.GetHostEntry(timeServer).AddressList;
}
catch (Exception exception)
{
Debug.LogWarning(LogPrefix + "Could not resolve host " + timeServer + " =/\n" + exception);
LastError = ErrorKind.CantResolveHost;
}
if (addresses == null || addresses.Length == 0)
{
Debug.LogWarning(LogPrefix + "Could not resolve IP from the host " + timeServer + " =/");
LastError = ErrorKind.CantResolveHost;
}
if (LastError != ErrorKind.NoError)
{
yield break;
}
#region socket create and connect
var timeBeforeAsyncCall = Time.unscaledTime;
try
{
if (asyncSocket == null)
{
asyncSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
asyncSocket.SendTimeout = 3000;
asyncSocket.ReceiveTimeout = 3000;
}
var ip = addresses[0];
var ipBytes = ip.GetAddressBytes();
if (ipBytes != targetIP)
{
targetEndpoint = new IPEndPoint(ip, 123);
targetIP = ipBytes;
}
if (connectArgs == null)
{
connectArgs = new SocketAsyncEventArgs();
connectArgs.Completed += OnSocketConnectedOrSent;
}
connectArgs.RemoteEndPoint = targetEndpoint;
gettingOnlineTimeAsync = true;
if (!asyncSocket.ConnectAsync(connectArgs))
{
OnSocketConnectedOrSent(asyncSocket, connectArgs);
}
}
catch (Exception exception)
{
HandleSocketException(exception);
}
while (gettingOnlineTimeAsync)
{
if (Time.unscaledTime - timeBeforeAsyncCall > 4)
{
Debug.LogWarning(LogPrefix + "Socket didn't respond in time.");
LastError = ErrorKind.Unknown;
CloseSocket();
yield break;
}
yield return(cachedEndOfFrame);
}
if (asyncError != ErrorKind.NoError)
{
LastError = asyncError;
}
if (LastError != ErrorKind.NoError)
{
CloseSocket();
yield break;
}
#endregion
#region socket send
ntpData[0] = 0x1B;
if (sendArgs == null)
{
sendArgs = new SocketAsyncEventArgs();
sendArgs.Completed += OnSocketConnectedOrSent;
sendArgs.UserToken = asyncSocket;
sendArgs.SetBuffer(ntpData, 0, NtpDataBufferLength);
}
sendArgs.RemoteEndPoint = targetEndpoint;
timeBeforeAsyncCall = Time.unscaledTime;
try
{
gettingOnlineTimeAsync = true;
if (!asyncSocket.SendAsync(sendArgs))
{
OnSocketConnectedOrSent(asyncSocket, sendArgs);
}
}
catch (Exception exception)
{
HandleSocketException(exception);
}
while (gettingOnlineTimeAsync)
{
if (Time.unscaledTime - timeBeforeAsyncCall > 4)
{
Debug.LogWarning(LogPrefix + "Socket didn't respond in time.");
LastError = ErrorKind.Unknown;
CloseSocket();
yield break;
}
yield return(cachedEndOfFrame);
}
if (asyncError != ErrorKind.NoError)
{
LastError = asyncError;
}
if (LastError != ErrorKind.NoError)
{
CloseSocket();
yield break;
}
#endregion
#region socket receive
if (receiveArgs == null)
{
receiveArgs = new SocketAsyncEventArgs();
receiveArgs.Completed += OnSocketReceive;
receiveArgs.UserToken = asyncSocket;
receiveArgs.SetBuffer(ntpData, 0, NtpDataBufferLength);
}
receiveArgs.RemoteEndPoint = targetEndpoint;
timeBeforeAsyncCall = Time.unscaledTime;
try
{
gettingOnlineTimeAsync = true;
if (!asyncSocket.ReceiveAsync(receiveArgs))
{
OnSocketReceive(asyncSocket, receiveArgs);
}
}
catch (Exception exception)
{
HandleSocketException(exception);
}
while (gettingOnlineTimeAsync)
{
if (Time.unscaledTime - timeBeforeAsyncCall > 4)
{
Debug.LogWarning(LogPrefix + "Socket didn't respond in time.");
LastError = ErrorKind.Unknown;
CloseSocket();
yield break;
}
yield return(cachedEndOfFrame);
}
if (asyncError != ErrorKind.NoError)
{
LastError = asyncError;
}
if (LastError != ErrorKind.NoError)
{
CloseSocket();
yield break;
}
#endregion
var intc = (ulong)ntpData[40] << 24 | (ulong)ntpData[41] << 16 | (ulong)ntpData[42] << 8 | ntpData[43];
var frac = (ulong)ntpData[44] << 24 | (ulong)ntpData[45] << 16 | (ulong)ntpData[46] << 8 | ntpData[47];
lastOnlineTime = intc * 1000d + frac * 1000d / 0x100000000L;
}
public ErrorIn(ErrorKind ek) : base(String.Format("error in parsing: {0}", ek.ToString()))
{
}
public void Report(ErrorKind level, Cursor cursor, int code, string text)
{
Error error = new Error(level, cursor, code, text);
_lock.Acquire();
_errors.Add(error);
_lock.Release();
// update Failed property that indicates whether one or more errors have occured
switch (level)
{
case ErrorKind.Debug : break;
case ErrorKind.Error : _failed = true; break;
case ErrorKind.Fatal : _failed = true; break;
case ErrorKind.Internal : _failed = true; break;
case ErrorKind.Notice : break;
case ErrorKind.Unhandled: _failed = true; break;
case ErrorKind.Warning : break;
default:
throw new InternalError("Unknown ErrorKind value encountered: " + level.ToString());
}
// don't report the event if the trace level does not allow it
if (level > _level)
return;
System.Text.StringBuilder result = new System.Text.StringBuilder();
if (cursor != null)
result.Append(cursor.ToString());
if (result.Length > 0)
result.Append(' ');
string name = null;
switch (level)
{
case ErrorKind.Debug : name = "DEBUG"; break;
case ErrorKind.Error : name = "Error"; break;
case ErrorKind.Fatal : name = "Fatal error"; break;
case ErrorKind.Internal : name = "Internal error"; break;
case ErrorKind.Notice : name = null; break;
case ErrorKind.Unhandled: name = "Unhandled error"; break;
case ErrorKind.Warning : name = "Warning"; break;
default:
throw new InternalError("Unknown ErrorKind value encountered: " + level.ToString());
}
if (name != null)
result.Append(name);
if (code != 0)
result.Append(" " + code.ToString());
if (name != null)
result.Append(": ");
result.Append(text);
_writer.WriteLine(result.ToString());
}
public Logger(ErrorKind level, System.IO.TextWriter writer)
{
_level = level;
_writer = writer;
}
public override bool Extract()
{
using (var parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader("class Tmp { void Test() {\n " + this.textEditor.SelectedText + "\n}}"))) {
parser.Parse();
if (parser.Errors.Count > 0)
{
MessageService.ShowError("${res:AddIns.SharpRefactoring.ExtractMethod.ParseErrors}");
return(false);
}
this.specialsList = parser.Lexer.SpecialTracker.RetrieveSpecials();
}
this.currentProjectContent = ParserService.GetProjectContent(ProjectService.CurrentProject);
MethodDeclaration newMethod = new MethodDeclaration();
List <VariableDeclaration> possibleReturnValues = new List <VariableDeclaration>();
List <VariableDeclaration> otherReturnValues = new List <VariableDeclaration>();
// Initialise new method
newMethod.Body = GetBlock(this.textEditor.SelectedText);
newMethod.Body.StartLocation = new Location(0, 0);
this.parentNode = GetParentMember(start, end);
Dom.IMember member = GetParentMember(textEditor, textEditor.Caret.Line, textEditor.Caret.Column);
if (parentNode == null || member == null)
{
MessageService.ShowError("${res:AddIns.SharpRefactoring.ExtractMethod.InvalidSelection}");
return(false);
}
this.currentClass = member.DeclaringType;
ErrorKind kind = CheckForJumpInstructions(newMethod);
if (kind != ErrorKind.None)
{
switch (kind)
{
case ErrorKind.ContainsBreak:
MessageService.ShowError("${res:AddIns.SharpRefactoring.ExtractMethod.ContainsBreakError}");
break;
case ErrorKind.ContainsContinue:
MessageService.ShowError("${res:AddIns.SharpRefactoring.ExtractMethod.ContainsContinueError}");
break;
case ErrorKind.ContainsGoto:
MessageService.ShowError("${res:AddIns.SharpRefactoring.ExtractMethod.ContainsGotoError}");
break;
}
return(false);
}
newMethod.Modifier = parentNode.Modifier;
newMethod.Modifier &= ~(Modifiers.Internal | Modifiers.Protected | Modifiers.Private | Modifiers.Public | Modifiers.Override);
LookupTableVisitor ltv = new LookupTableVisitor(SupportedLanguage.CSharp);
parentNode.AcceptVisitor(ltv, null);
var variablesList = (from list in ltv.Variables.Values from item in list select new Variable(item))
.Where(v => !(v.StartPos > end || v.EndPos < start) &&
(HasReferencesInSelection(newMethod, v) ||
HasOccurrencesAfter(CSharpNameComparer, this.parentNode, end, v.Name, v.StartPos, v.EndPos)))
.Union(FromParameters(newMethod))
.Select(va => ResolveVariable(va));
foreach (var variable in variablesList)
{
LoggingService.Debug(variable);
bool hasOccurrencesAfter = HasOccurrencesAfter(CSharpNameComparer, this.parentNode, end, variable.Name, variable.StartPos, variable.EndPos);
bool isInitialized = (variable.Initializer != null) ? !variable.Initializer.IsNull : false;
bool hasAssignment = HasAssignment(newMethod, variable);
if (IsInCurrentSelection(variable.StartPos) && hasOccurrencesAfter)
{
possibleReturnValues.Add(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type));
otherReturnValues.Add(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type));
}
if (!(IsInCurrentSelection(variable.StartPos) || IsInCurrentSelection(variable.EndPos)))
{
ParameterDeclarationExpression newParam = null;
if ((hasOccurrencesAfter && isInitialized) || variable.WasRefParam)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.Ref);
}
else
{
if ((hasOccurrencesAfter && hasAssignment) || variable.WasOutParam)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.Out);
}
else
{
if (!hasOccurrencesAfter)
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.None);
}
else
{
if (!hasOccurrencesAfter && !isInitialized)
{
newMethod.Body.Children.Insert(0, new LocalVariableDeclaration(new VariableDeclaration(variable.Name, variable.Initializer, variable.Type)));
}
else
{
newParam = new ParameterDeclarationExpression(variable.Type, variable.Name, ParameterModifiers.In);
}
}
}
}
if (newParam != null)
{
newMethod.Parameters.Add(newParam);
}
}
}
List <VariableDeclaration> paramsAsVarDecls = new List <VariableDeclaration>();
this.beforeCallDeclarations = new List <LocalVariableDeclaration>();
for (int i = 0; i < otherReturnValues.Count - 1; i++)
{
VariableDeclaration varDecl = otherReturnValues[i];
paramsAsVarDecls.Add(varDecl);
ParameterDeclarationExpression p = new ParameterDeclarationExpression(varDecl.TypeReference, varDecl.Name);
p.ParamModifier = ParameterModifiers.Out;
if (!newMethod.Parameters.Contains(p))
{
newMethod.Parameters.Add(p);
}
else
{
this.beforeCallDeclarations.Add(new LocalVariableDeclaration(varDecl));
}
}
CreateReturnStatement(newMethod, possibleReturnValues);
newMethod.Name = "NewMethod";
this.extractedMethod = newMethod;
return(true);
}
/// <summary>
/// Converts exception to the ServiceError
/// </summary>
/// <param name="error"></param>
/// <param name="errorKind"></param>
/// <returns></returns>
public static ServiceError FromException(Exception error, out ErrorKind errorKind)
{
ErrorKind temp;
errorKind = ErrorKind.Unknown;
var res = new ServiceError
{
Inner = error.InnerException == null ? null : FromException(error.InnerException, out temp),
Time = DateTime.UtcNow,
Details = error.Message
};
var be = error as IBabelException;
if(be != null)
{
res.Context = be.Context;
res.Errors = be.Errors.ToList();
errorKind = be.Kind;
return res;
}
string code = "INTERNAL_ERROR";
/*if(error is ArgumentException)
{
code = BAD_ARGUMENT;
errorKind = ErrorKind.InvalidArgument;
}
else*/
if(error is ArgumentException ||error is ApplicationException || error is NotImplementedException)
{
code = INVALID_REQUEST;
errorKind = ErrorKind.InvalidRequest;
}
res.Errors.Add(new Error { Code = code, Message = error.Message });
return res;
}
