public ErrorViewModel(ErrorContext errorContext, IDictionary<string, object> routeValues, WikiDownConfig config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
this.ClientMessage = (errorContext != null) ? errorContext.ClientData : null;
var exception = (errorContext != null) ? errorContext.Exception : null;
if (exception != null)
{
this.ExceptionContent = exception.ToString();
this.ExceptionMessage = exception.Message;
this.ExceptionTypeName = exception.GetType().Name;
}
if (routeValues != null)
{
this.ActionName = routeValues.TryGet("action") as string;
this.ControllerName = routeValues.TryGet("controller") as string;
}
this.config = config;
}
internal GroupKeyAggregateInfo(
GroupAggregateKind aggregateKind, ErrorContext errCtx, GroupAggregateInfo containingAggregate, ScopeRegion definingScopeRegion)
: base(
aggregateKind, null /* there is no AST.GroupAggregateExpression corresponding to the group key */, errCtx,
containingAggregate, definingScopeRegion)
{
}
public void NotifyError(ErrorContext context)
{
Console.WriteLine();
Console.WriteLine("Exception is received.");
try {
RenderException(context.Exception);
} catch {
Console.WriteLine("During exception rendering was obtained unhandled exception. For more information, check the log.");
}
}
//通过menu层传来的消息初始化
public static void InitItemInfo(string frameName, object sender) {
if (sender == null)
return;
selectItem = sender as ITEM_TYPE_C;
DATA_ITEM_C getSetting = DseFunctions.GetSetting(globalDefine.STA_NAME, globalDefine.EQU_NAME, selectItem.MenuPath);
if (getSetting != null)
initSetting = getSetting;
else
initSetting = new ErrorContext("获取定制失败!!!!");
initInfoTitle = selectItem.Name;
}
public static ActionResult Resolve(ErrorContext errorContext, HttpContextBase httpContext)
{
if (errorContext == null)
{
throw new ArgumentNullException("errorContext");
}
if (httpContext == null)
{
throw new ArgumentNullException("httpContext");
}
return ResolveInternal(errorContext, httpContext) ?? GetDefaultErrorResult(errorContext, httpContext);
}
async Task<ErrorHandleResult> MoveToError(ErrorContext errorContext, string errorQueue)
{
var message = errorContext.Message;
Logger.Error($"Moving message '{message.MessageId}' to the error queue '{ errorQueue }' because processing failed due to an exception:", errorContext.Exception);
await moveToErrorsExecutor.MoveToErrorQueue(errorQueue, message, errorContext.Exception, errorContext.TransportTransaction).ConfigureAwait(false);
if (raiseNotifications)
{
await eventAggregator.Raise(new MessageFaulted(errorContext, errorQueue)).ConfigureAwait(false);
}
return ErrorHandleResult.Handled;
}
private static ActionResult GetDefaultErrorResult(ErrorContext errorContext, HttpContextBase httpContext)
{
var model = new ErrorViewModel(errorContext, httpContext.Request.RequestContext.RouteData.Values);
var tempData = (httpContext.Session != null)
? httpContext.Session[TempDataSessionStateKey] as TempDataDictionary
: null;
return new ViewResult
{
ViewName = "~/Views/Shared/Error.cshtml",
MasterName = string.Empty,
ViewData = new ViewDataDictionary<ErrorViewModel>(model),
TempData = tempData ?? new TempDataDictionary()
};
}
async Task<ErrorHandleResult> RaiseImmediateRetryNotifications(ErrorContext errorContext)
{
Logger.Info($"Immediate Retry is going to retry message '{errorContext.Message.MessageId}' because of an exception:", errorContext.Exception);
if (raiseNotifications)
{
await eventAggregator.Raise(
new MessageToBeRetried(
attempt: errorContext.ImmediateProcessingFailures - 1,
delay: TimeSpan.Zero,
immediateRetry: true,
errorContext: errorContext))
.ConfigureAwait(false);
}
return ErrorHandleResult.RetryRequired;
}
private static ActionResult ResolveInternal(ErrorContext errorContext, HttpContextBase httpContext)
{
if (!errorContext.IsHandled)
{
return null;
}
var urlHelper = new UrlHelper(httpContext.Request.RequestContext);
if (errorContext.IsExceptionOfType<ArticleAccessException>() && !httpContext.User.Identity.IsAuthenticated)
{
var returnUrl = httpContext.Request.Url.ToRelativePathAndQuery();
string loginUrl = urlHelper.AccountsLogin(returnUrl);
return new RedirectResult(loginUrl);
}
return null;
}
/// <summary>
/// Invokes the default recovery policy.
/// </summary>
/// <param name="config">The recoverability configuration.</param>
/// <param name="errorContext">The error context.</param>
/// <returns>The recoverability action.</returns>
public static RecoverabilityAction Invoke(RecoverabilityConfig config, ErrorContext errorContext)
{
if (errorContext.Exception is MessageDeserializationException)
{
return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue);
}
if (errorContext.ImmediateProcessingFailures <= config.Immediate.MaxNumberOfRetries)
{
return RecoverabilityAction.ImmediateRetry();
}
TimeSpan delay;
if (TryGetDelay(errorContext.Message, errorContext.DelayedDeliveriesPerformed, config.Delayed, out delay))
{
return RecoverabilityAction.DelayedRetry(delay);
}
return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue);
}
public Task<ErrorHandleResult> Invoke(ErrorContext errorContext)
{
var recoveryAction = recoverabilityPolicy(configuration, errorContext);
// When we can't do immediate retries and policy did not honor MaxNumberOfRetries for ImmediateRetries
if (recoveryAction is ImmediateRetry && !immediateRetriesAvailable)
{
Logger.Warn("Recoverability policy requested ImmediateRetry however immediate retries are not available with the current endpoint configuration. Moving message to error queue instead.");
return MoveToError(errorContext, configuration.Failed.ErrorQueue);
}
if (recoveryAction is ImmediateRetry)
{
return RaiseImmediateRetryNotifications(errorContext);
}
// When we can't do delayed retries, a policy customization probably didn't honor MaxNumberOfRetries for DelayedRetries
if (recoveryAction is DelayedRetry && !delayedRetriesAvailable)
{
Logger.Warn("Recoverability policy requested DelayedRetry however delayed delivery capability is not available with the current endpoint configuration. Moving message to error queue instead.");
return MoveToError(errorContext, configuration.Failed.ErrorQueue);
}
var delayedRetryAction = recoveryAction as DelayedRetry;
if (delayedRetryAction != null)
{
return DeferMessage(delayedRetryAction, errorContext);
}
var moveToError = recoveryAction as MoveToError;
if (moveToError != null)
{
return MoveToError(errorContext, moveToError.ErrorQueue);
}
Logger.Warn("Recoverability policy returned an unsupported recoverability action. Moving message to error queue instead.");
return MoveToError(errorContext, configuration.Failed.ErrorQueue);
}
static RecoverabilityAction RecoverabilityPolicy(RecoverabilityConfig config, ErrorContext errorContext)
{
if (errorContext.ImmediateProcessingFailures <= MaxNumberOfImmediateRetries)
{
return RecoverabilityAction.ImmediateRetry();
}
return RecoverabilityAction.MoveToError(config.Failed.ErrorQueue);
}
public override bool Validate(Severity severity, string propertyName, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext)
{
bool result = true;
if (propertyNameValue == null || !base.IsUnique(propertyNameValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidCustomPropertyName, severity, objectType, objectName, propertyNameValue);
result = false;
}
return(result);
}
public override void CheckContainerJoinForNaturalJoin(IRIFDataScope startScope, ErrorContext errorContext, IRIFDataScope scope)
{
DataSet dataSet = scope.DataScopeInfo.DataSet;
base.CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, this.GetActiveRowRelationship(dataSet));
base.CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, this.GetActiveColumnRelationship(dataSet));
}
public LoopsAndConditions(ErrorContext error)//DecompilerContext context)
{
this.error = error;
}
/// <summary>
/// Converts boolean literal value.
/// </summary>
private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue)
{
bool result = false;
if (!Boolean.TryParse(booleanLiteralValue, out result))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.InvalidLiteralFormat("Boolean", booleanLiteralValue));
}
return result;
}
/// <summary>
/// Converts time literal value.
/// </summary>
private static TimeSpan ConvertTimeLiteralValue(ErrorContext errCtx, string datetimeLiteralValue)
{
string[] datetimeParts = datetimeLiteralValue.Split(_datetimeSeparators, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(datetimeParts.Length >= 2, "time literal value must have at least 2 parts");
int hour;
int minute;
int second;
int ticks;
GetTimeParts(datetimeLiteralValue, datetimeParts, 0, out hour, out minute, out second, out ticks);
Debug.Assert(hour >= 0 && hour <= 24);
Debug.Assert(minute >= 0 && minute <= 59);
Debug.Assert(second >= 0 && second <= 59);
Debug.Assert(ticks >= 0 && ticks <= 9999999);
TimeSpan ts = new TimeSpan(hour, minute, second);
ts = ts.Add(new TimeSpan(ticks));
return ts;
}
bool IParameterDef.ValidateValueForBlank(object newValue, ErrorContext errorContext, string parameterValueProperty)
{
return(ValidateValueForBlank(newValue, errorContext, parameterValueProperty));
}
/// <summary>
/// Performs conversion of numeric strings that have no type suffix hint.
/// </summary>
private static object DefaultNumericConversion(string numericString, ErrorContext errCtx)
{
if (-1
!= numericString.IndexOfAny(_floatTokens))
{
Double value;
if (!Double.TryParse(numericString, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
{
var message = Strings.CannotConvertNumericLiteral(numericString, "double");
throw EntitySqlException.Create(errCtx, message, null);
}
return value;
}
else
{
Int32 int32Value;
if (Int32.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int32Value))
{
return int32Value;
}
Int64 int64Value;
if (!Int64.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int64Value))
{
var message = Strings.CannotConvertNumericLiteral(numericString, "long");
throw EntitySqlException.Create(errCtx, message, null);
}
return int64Value;
}
}
/// <nodoc />
public UndefinedMapKeyException(ErrorContext errorContext)
: base("Undefined map key", errorContext)
{
}
bool IParameterDef.ValidateValueForNull(object newValue, ErrorContext errorContext, string parameterValueProperty)
{
return(ParameterBase.ValidateValueForNull(newValue, base.Nullable, errorContext, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, base.Name, parameterValueProperty));
}
public void Handle(ErrorContext errorContext)
{
action(errorContext);
}
private static RecoverabilityAction SubscriberServiceRetryPolicy(RecoverabilityConfig config, ErrorContext context)
{
var action = DefaultRecoverabilityPolicy.Invoke(config, context);
if (!(action is DelayedRetry delayedRetryAction))
{
return(action);
}
if (context.Exception is UserNotFoundException)
{
return(RecoverabilityAction.MoveToError(config.Failed.ErrorQueue));
}
// Override default delivery delay.
/* var recoverability = endpointConfiguration.Recoverability();
* recoverability.Delayed(
* customizations: delayed =>
* {
* delayed.NumberOfRetries(3);
* delayed.TimeIncrease(TimeSpan.FromMinutes(3));
* });*/
return(RecoverabilityAction.DelayedRetry(TimeSpan.FromMinutes(3)));
}
/// <nodoc />
public UndefinedSetItemException(ErrorContext errorContext)
: base("Undefined set item", errorContext)
{
}
public bool LogValue(DateTime timestamp, long value, List<string> measureMetric, ErrorContext errorContext)
{
if (measureMetric.Count != this.dimensionNames.Length)
{
errorContext.ErrorMessage = $"{measureMetric.Count} dimension values were passed while the metric has {this.dimensionNames.Length} dimensions";
return false;
}
try
{
return this.wrappedMeasureMetric.LogValue(timestamp, value, ref errorContext, measureMetric.ToArray());
}
catch (Exception e)
{
errorContext.ErrorMessage = e.Message;
return false;
}
}
internal void Parse(string name, List <string> defaultValues, string type, string nullable, ExpressionInfo prompt, string promptUser, string allowBlank, string multiValue, string usedInQuery, bool hidden, ErrorContext errorContext, CultureInfo language)
{
base.Parse(name, defaultValues, type, nullable, prompt, promptUser, allowBlank, multiValue, usedInQuery, hidden, errorContext, language);
if (hidden)
{
m_prompt = ExpressionInfo.CreateConstExpression("");
}
else if (prompt == null)
{
m_prompt = ExpressionInfo.CreateConstExpression(name + ":");
}
else
{
m_prompt = prompt;
}
ValidateExpressionDataTypes(m_validValuesValueExpressions, errorContext, name, "ValidValue", fromValidValues: true, language);
ValidateExpressionDataTypes(m_defaultExpressions, errorContext, name, "DefaultValue", fromValidValues: false, language);
}
async Task Process(BasicDeliverEventArgs message)
{
Dictionary <string, string> headers;
try
{
headers = messageConverter.RetrieveHeaders(message);
}
catch (Exception ex)
{
Logger.Error($"Failed to retrieve headers from poison message. Moving message to queue '{settings.ErrorQueue}'...", ex);
await MovePoisonMessage(message, settings.ErrorQueue).ConfigureAwait(false);
return;
}
string messageId;
try
{
messageId = messageConverter.RetrieveMessageId(message, headers);
}
catch (Exception ex)
{
Logger.Error($"Failed to retrieve ID from poison message. Moving message to queue '{settings.ErrorQueue}'...", ex);
await MovePoisonMessage(message, settings.ErrorQueue).ConfigureAwait(false);
return;
}
using (var tokenSource = new CancellationTokenSource())
{
var processed = false;
var errorHandled = false;
var numberOfDeliveryAttempts = 0;
var messageBody = message.Body.ToArray();
while (!processed && !errorHandled)
{
try
{
var contextBag = new ContextBag();
contextBag.Set(message);
var messageContext = new MessageContext(messageId, headers, messageBody ?? Array.Empty <byte>(), transportTransaction, tokenSource, contextBag);
await onMessage(messageContext).ConfigureAwait(false);
processed = true;
}
catch (Exception exception)
{
++numberOfDeliveryAttempts;
headers = messageConverter.RetrieveHeaders(message);
var contextBag = new ContextBag();
contextBag.Set(message);
var errorContext = new ErrorContext(exception, headers, messageId, messageBody ?? Array.Empty <byte>(), transportTransaction, numberOfDeliveryAttempts, contextBag);
try
{
errorHandled = await onError(errorContext).ConfigureAwait(false) == ErrorHandleResult.Handled;
if (!errorHandled)
{
headers = messageConverter.RetrieveHeaders(message);
}
}
catch (Exception ex)
{
criticalError.Raise($"Failed to execute recoverability policy for message with native ID: `{messageId}`", ex);
await consumer.Model.BasicRejectAndRequeueIfOpen(message.DeliveryTag).ConfigureAwait(false);
return;
}
}
}
if (processed && tokenSource.IsCancellationRequested)
{
await consumer.Model.BasicRejectAndRequeueIfOpen(message.DeliveryTag).ConfigureAwait(false);
}
else
{
try
{
await consumer.Model.BasicAckSingle(message.DeliveryTag).ConfigureAwait(false);
}
catch (AlreadyClosedException ex)
{
Logger.Warn($"Failed to acknowledge message '{messageId}' because the channel was closed. The message was returned to the queue.", ex);
}
}
}
}
private void ValidateExpressionDataTypes(List <ExpressionInfo> expressions, ErrorContext errorContext, string paramName, string memberName, bool fromValidValues, CultureInfo language)
{
if (expressions == null)
{
return;
}
int num = expressions.Count - 1;
while (true)
{
if (num < 0)
{
return;
}
ExpressionInfo expressionInfo = expressions[num];
if (fromValidValues && expressionInfo == null && base.MultiValue)
{
m_validValuesValueExpressions.RemoveAt(num);
}
else if (expressionInfo != null && ExpressionInfo.Types.Constant == expressionInfo.Type)
{
if (!ParameterBase.CastFromString(expressionInfo.StringValue, out object newValue, base.DataType, language))
{
if (errorContext == null)
{
break;
}
errorContext.Register(ProcessingErrorCode.rsParameterPropertyTypeMismatch, Severity.Error, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, paramName, memberName);
}
else
{
ValidateValue(newValue, errorContext, Microsoft.ReportingServices.ReportProcessing.ObjectType.ReportParameter, memberName);
if (newValue != null && base.DataType != DataType.String)
{
ExpressionInfo expressionInfo2 = new ExpressionInfo();
expressionInfo2.Type = ExpressionInfo.Types.Constant;
expressionInfo2.OriginalText = expressionInfo.OriginalText;
expressionInfo2.ConstantType = base.DataType;
expressions[num] = expressionInfo2;
switch (base.DataType)
{
case DataType.Boolean:
expressionInfo2.BoolValue = (bool)newValue;
break;
case DataType.DateTime:
if (newValue is DateTimeOffset)
{
expressionInfo2.SetDateTimeValue((DateTimeOffset)newValue);
}
else
{
expressionInfo2.SetDateTimeValue((DateTime)newValue);
}
break;
case DataType.Float:
expressionInfo2.FloatValue = (double)newValue;
break;
case DataType.Integer:
expressionInfo2.IntValue = (int)newValue;
break;
}
}
}
}
num--;
}
private static object ConvertNumericLiteral(ErrorContext errCtx, string numericString)
{
int k = numericString.IndexOfAny(numberSuffixes);
if (-1 != k)
{
string suffix = numericString.Substring(k).ToUpperInvariant();
string numberPart = numericString.Substring(0, numericString.Length - suffix.Length);
switch (suffix)
{
case "U":
{
UInt32 value;
if (!UInt32.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "unsigned int"));
}
return value;
}
;
case "L":
{
long value;
if (!Int64.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "long"));
}
return value;
}
;
case "UL":
case "LU":
{
UInt64 value;
if (!UInt64.TryParse(numberPart, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "unsigned long"));
}
return value;
}
;
case "F":
{
Single value;
if (!Single.TryParse(numberPart, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "float"));
}
return value;
}
;
case "M":
{
Decimal value;
if (!Decimal.TryParse(numberPart, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "decimal"));
}
return value;
}
;
case "D":
{
Double value;
if (!Double.TryParse(numberPart, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "double"));
}
return value;
}
;
}
}
//
// If hit this point, try default conversion
//
return DefaultNumericConversion(numericString, errCtx);
}
internal override void CheckContainerJoinForNaturalJoin(IRIFDataScope startScope, ErrorContext errorContext, IRIFDataScope scope)
{
CheckContainerRelationshipForNaturalJoin(startScope, errorContext, scope, GetActiveRelationship(scope.DataScopeInfo.DataSet));
}
/// <summary>
/// Converts datetime literal value.
/// </summary>
private static DateTime ConvertDateTimeLiteralValue(ErrorContext errCtx, string datetimeLiteralValue)
{
string[] datetimeParts = datetimeLiteralValue.Split(_datetimeSeparators, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(datetimeParts.Length >= 5, "datetime literal value must have at least 5 parts");
int year;
int month;
int day;
GetDateParts(datetimeLiteralValue, datetimeParts, out year, out month, out day);
int hour;
int minute;
int second;
int ticks;
GetTimeParts(datetimeLiteralValue, datetimeParts, 3, out hour, out minute, out second, out ticks);
Debug.Assert(year >= 1 && year <= 9999);
Debug.Assert(month >= 1 && month <= 12);
Debug.Assert(day >= 1 && day <= 31);
Debug.Assert(hour >= 0 && hour <= 24);
Debug.Assert(minute >= 0 && minute <= 59);
Debug.Assert(second >= 0 && second <= 59);
Debug.Assert(ticks >= 0 && ticks <= 9999999);
DateTime dateTime = new DateTime(year, month, day, hour, minute, second, 0);
dateTime = dateTime.AddTicks(ticks);
return dateTime;
}
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId, CancellationToken messageProcessingCancellationToken)
{
var message = await AsyncFile.ReadText(transaction.FileToProcess, messageProcessingCancellationToken)
.ConfigureAwait(false);
var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}");
var headers = HeaderSerializer.Deserialize(message);
if (headers.TryGetValue(LearningTransportHeaders.TimeToBeReceived, out var ttbrString))
{
headers.Remove(LearningTransportHeaders.TimeToBeReceived);
var ttbr = TimeSpan.Parse(ttbrString);
//file.move preserves create time
var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess);
var utcNow = DateTime.UtcNow;
if (sentTime + ttbr < utcNow)
{
await transaction.Commit(messageProcessingCancellationToken)
.ConfigureAwait(false);
log.InfoFormat("Dropping message '{0}' as the specified TimeToBeReceived of '{1}' expired since sending the message at '{2:O}'. Current UTC time is '{3:O}'", messageId, ttbrString, sentTime, utcNow);
return;
}
}
var body = await AsyncFile.ReadBytes(bodyPath, messageProcessingCancellationToken)
.ConfigureAwait(false);
var transportTransaction = new TransportTransaction();
if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive)
{
transportTransaction.Set(transaction);
}
var processingContext = new ContextBag();
var messageContext = new MessageContext(messageId, headers, body, transportTransaction, processingContext);
try
{
await onMessage(messageContext, messageProcessingCancellationToken)
.ConfigureAwait(false);
}
catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested)
{
log.Info("Message processing cancelled. Rolling back transaction.", ex);
transaction.Rollback();
return;
}
catch (Exception exception)
{
transaction.ClearPendingOutgoingOperations();
var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1);
headers = HeaderSerializer.Deserialize(message);
headers.Remove(LearningTransportHeaders.TimeToBeReceived);
var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures, processingContext);
ErrorHandleResult result;
try
{
result = await onError(errorContext, messageProcessingCancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException ex) when(messageProcessingCancellationToken.IsCancellationRequested)
{
log.Info("Message processing cancelled. Rolling back transaction.", ex);
transaction.Rollback();
return;
}
catch (Exception ex)
{
criticalErrorAction($"Failed to execute recoverability policy for message with native ID: `{messageContext.NativeMessageId}`", ex, CancellationToken.None);
result = ErrorHandleResult.RetryRequired;
}
if (result == ErrorHandleResult.RetryRequired)
{
transaction.Rollback();
return;
}
}
await transaction.Commit(messageProcessingCancellationToken).ConfigureAwait(false);
}
public void OnError(ErrorContext context)
{
_writer.NotifyError(context);
}
protected async Task<ErrorHandleResult> HandleError(Message message, Dictionary<string, string> headers, Exception exception, TransportTransaction transportTransaction, int processingAttempts)
{
try
{
var body = await ReadStream(message.BodyStream).ConfigureAwait(false);
var errorContext = new ErrorContext(exception, headers, message.Id, body, transportTransaction, processingAttempts);
return await onError(errorContext).ConfigureAwait(false);
}
catch (Exception ex)
{
criticalError.Raise($"Failed to execute recoverability actions for message `{message.Id}`", ex);
//best thing we can do is roll the message back if possible
return ErrorHandleResult.RetryRequired;
}
}
public RecoverabilityAction Invoke(RecoverabilityConfig config, ErrorContext errorContext)
{
return(actions.Dequeue());
}
internal void OnDerivedErrorMethod(StreamingContext context, ErrorContext errorContext)
{
}
protected MessageProcessingFailed(ErrorContext errorContext)
{
Message = errorContext.Message;
Exception = errorContext.Exception;
ErrorContext = errorContext;
}
/// <summary>
/// Initializes a new instance EntityException with an ErrorContext instance and a given error message.
/// </summary>
internal static EntitySqlException Create(ErrorContext errCtx, string errorMessage, Exception innerException)
{
return(Create(
errCtx.CommandText, errorMessage, errCtx.InputPosition, errCtx.ErrorContextInfo, errCtx.UseContextInfoAsResourceIdentifier,
innerException));
}
async Task ProcessMessage(IMessageReceiverInternal internalReceiver, BrokeredMessage message, int slotNumber)
{
if (stopping)
{
logger.Info($"Received message with ID {message.MessageId} while shutting down. Message will not be processed and will be retried after {message.LockedUntilUtc}.");
return;
}
try
{
IncomingMessageDetailsInternal incomingMessage;
try
{
incomingMessage = brokeredMessageConverter.Convert(message);
}
catch (UnsupportedBrokeredMessageBodyTypeException exception)
{
await message.DeadLetterAsync("BrokeredMessage to IncomingMessageDetails conversion failure", exception.ToString()).ConfigureAwait(false);
return;
}
var context = new BrokeredMessageReceiveContextInternal(message, entity, internalReceiver.Mode);
var scope = wrapInScope
? new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions
{
IsolationLevel = IsolationLevel.Serializable
}, TransactionScopeAsyncFlowOption.Enabled)
: null;
{
using (scope)
{
var wasCompleted = false;
try
{
await incomingCallback(incomingMessage, context).ConfigureAwait(false);
if (context.CancellationToken.IsCancellationRequested)
{
await AbandonOnCancellation(message).ConfigureAwait(false);
}
else
{
wasCompleted = await HandleCompletion(message, context, completionCanBeBatched, slotNumber).ConfigureAwait(false);
}
}
catch (Exception exception) when(!stopping)
{
// and go into recovery mode so that no new messages are added to the transfer queue
context.Recovering = true;
// pass the context into the error pipeline
var transportTransaction = new TransportTransaction();
transportTransaction.Set(context);
var errorContext = new ErrorContext(exception, brokeredMessageConverter.GetHeaders(message), incomingMessage.MessageId, incomingMessage.Body, transportTransaction, message.DeliveryCount);
var result = await processingFailureCallback(errorContext).ConfigureAwait(false);
if (result == ErrorHandleResult.RetryRequired)
{
await Abandon(message, exception).ConfigureAwait(false);
}
else
{
wasCompleted = await HandleCompletion(message, context, completionCanBeBatched, slotNumber).ConfigureAwait(false);
}
}
finally
{
if (wasCompleted)
{
scope?.Complete();
}
}
}
}
}
catch (Exception onErrorException)
{
await Abandon(message, onErrorException).ConfigureAwait(false);
await errorCallback(onErrorException).ConfigureAwait(false);
}
}
public void MergeCollationSettings(ErrorContext errorContext, string dataSourceType, string cultureName, bool caseSensitive, bool accentSensitive, bool kanatypeSensitive, bool widthSensitive)
{
this.m_dataSetCore.MergeCollationSettings(errorContext, dataSourceType, cultureName, caseSensitive, accentSensitive, kanatypeSensitive, widthSensitive);
}
public override bool Validate(Severity severity, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext)
{
Global.Tracer.Assert(false);
return(this.Validate(severity, "", objectType, objectName, propertyNameValue, errorContext));
}
internal void OnErrorMethod(StreamingContext context, ErrorContext errorContext)
{
Messages.Add(errorContext.Path + " - Error message for member " + errorContext.Member + " = " + errorContext.Error.Message);
errorContext.Handled = true;
}
static void Main(string[] args)
{
// Context.doThreads = false;
// Context.doXML = true;
// Context.doAssigmentOffsets = true;
// ugh have to do it here?
string dataWinFileName = args.ElementAtOrDefault(0);
if (string.IsNullOrWhiteSpace(dataWinFileName))
{
InstructionError("Missing data.win file");
}
try
{
File.LoadDataWin(dataWinFileName);
}
catch (Exception e)
{
Context.Error(e);
InstructionError("Could not open data.win file {0}\n Exception:", dataWinFileName, e.Message);
}
List<string> chunks = new List<string>();
byte[] changedData = null;
for(int i=1; i < args.Length; i++) {
string a = args[i];
if (string.IsNullOrWhiteSpace(a)) continue; // does this ever happen?
switch (a)
{
case "-printOffset":
{
Context.saveChangedDataWin = true;
string offset_name = args.ElementAtOrDefault(i + 1);
i += 1;
uint offset_int;
if (!TryParseOffset(offset_name, out offset_int)) Context.FatalError("Cannot parse {0} value in -printOffset", offset_name);
Context.Message(Context.FormatDebugOffset(changedData ?? File.DataWinRaw, (int)offset_int));
}
break;
case "-changeInt":
case "-changeShort":
{
Context.saveChangedDataWin = true;
string offset_name = args.ElementAtOrDefault(i + 1);
string to_value = args.ElementAtOrDefault(i + 2);
i += 2;
uint offset_int;
int to_int;
if (!TryParseOffset(offset_name, out offset_int)) Context.FatalError("Cannot parse {0} value in -changeShort", offset_name);
if (!TryParseHex(to_value, out to_int)) Context.FatalError("Cannot parse {0} value in -changeShort", to_value);
if (changedData == null)
{
changedData = File.CopyData();
File.LoadEveything();
}
if(a == "-changeShort") File.ChangeOffset(changedData, offset_int, (short)to_int);
else File.ChangeOffset(changedData, offset_int, to_int);
}
break;
case "-changeVar":
{
Context.saveChangedDataWin = true;
string code_name = args.ElementAtOrDefault(i + 1);
string var_name = args.ElementAtOrDefault(i + 2) ?? "";
string from_value = args.ElementAtOrDefault(i + 3) ?? "";
string to_value = args.ElementAtOrDefault(i + 4) ?? "";
int from_int;
int to_int;
if (!TryParseHex(from_value, out from_int)) Context.FatalError("Cannot parse {0} value in -change",from_value);
if (!TryParseHex(to_value, out to_int)) Context.FatalError("Cannot parse {0} value in -change", to_value);
i += 4;
if (changedData == null)
{
changedData = File.CopyData();
File.LoadEveything();
}
File.Code code=null;
File.Script script=null;
if (File.TryLookup(code_name, out code) || File.TryLookup(code_name, out script))
{
if (script != null) code = script.Code;
File.ChangeVarValue(changedData, code, var_name, from_int, to_int);
}
else Context.Error("'{0}' code/script not found", code_name);
}
break;
case "-output":
{
i++;
string dir = args.ElementAtOrDefault(i);
if(string.IsNullOrWhiteSpace(dir)) InstructionError("Missing otuput directory");
Context.CheckAndSetOutputDirectory(dir);
}
break;
case "-delete":
Context.deleteDirectorys = true;
break;
case "-lua":
Context.doLua = true;
Context.doXML = false;
break;
case "-oneFile":
Context.oneFile = true;
break;
case "-constOffsets":
Context.doAssigmentOffsets = true;
break;
case "-mask":
Context.saveAllMasks = true;
break;
case "-png":
Context.saveAllPngs = true;
break;
case "-xml":
Context.doXML = true;
break;
case "-search":
Context.doSearch = true;
break;
case "-json":
Context.doXML = false;
break;
case "-old":
Context.Version = UndertaleVersion.V10000;
break;
case "-debug":
Context.Debug = true;
break;
case "-nothread":
Context.doThreads = false;
break;
case "-watch":
Context.debugSearch = true;
break;
default:
if (a[0] == '-') InstructionError("bad flag '{0}'", a);
if (char.IsLetter(a[0])) chunks.Add(a);
break;
}
}
Context.CheckAndSetOutputDirectory();
ErrorContext.StartErrorSystem();
if (Context.saveChangedDataWin)
{
if (changedData != null)
{
using (var file = Context.CreateFileStream("changed_data.win", FileMode.Create, true))
{
file.Write(changedData, 0, changedData.Length);
file.Flush();
}
}
} else
{
File.LoadEveything();
var w = new Writers.AllWriter();
if (Context.doSearch)
{
var results = File.Search(chunks);
if (results.Count == 0) Context.Error("No data found in search");
string path = ".";
if (Context.doThreads)
{
Parallel.ForEach(results, result => AllWriter.DoSingleItem(path, result));
}
else
{
foreach (var result in results) AllWriter.DoSingleItem(path, result);
}
}
else if (Context.debugSearch)
{
Context.doThreads = false;
Context.Debug = true;
var results = File.Search(chunks);
if (results.Count == 0) Context.FatalError("No data found in search");
foreach (var f in new DirectoryInfo(".").GetFiles("*.txt"))
{
if (System.IO.Path.GetFileName(f.Name) != "errors.txt") f.Delete(); // clear out eveything
}
foreach (var a in results)
{
File.Code c = a as File.Code;
if (c != null)
{
var error = new ErrorContext(c.Name);
error.Message("Decompiling");
Context.Debug = true;
var block = c.Block;
if (block != null)
{
using (Writers.BlockToCode to = new Writers.BlockToCode(c.Name + "_watch.js"))
to.Write(block);
error.Message("Finished Decompiling");
}
else error.Message("Block is null");
}
else Context.Error("Code '{0} not found", a);
}
//Context.HackyDebugWatch = new HashSet<string>(chunks);
// w.AddAction("code");
}
else
{
if (chunks.Count == 0) chunks.Add("everything");
foreach (var a in chunks) w.AddAction(a);
}
w.FinishProcessing();
}
GoodExit();
}
internal void RetrieveSubreport()
{
if (!m_isNewContext)
{
return;
}
if (m_isOldSnapshot)
{
Microsoft.ReportingServices.ReportRendering.SubReport subReport = (Microsoft.ReportingServices.ReportRendering.SubReport)m_renderReportItem;
if (subReport.Report != null)
{
if (m_report == null)
{
m_report = new Report(this, m_inSubtotal, subReport, m_renderingContext);
}
else
{
m_report.UpdateSubReportContents(this, subReport);
}
}
m_noRows = subReport.NoRows;
m_processedWithError = subReport.ProcessedWithError;
}
else
{
Microsoft.ReportingServices.ReportIntermediateFormat.SubReport subReport2 = (Microsoft.ReportingServices.ReportIntermediateFormat.SubReport)m_reportItemDef;
RenderingContext renderingContext = null;
try
{
if (subReport2.ExceededMaxLevel)
{
m_errorCode = SubReportErrorCodes.ExceededMaxRecursionLevel;
m_errorMessage = RPRes.rsExceededMaxRecursionLevel(subReport2.Name);
FinalizeErrorMessageAndThrow();
}
else
{
CheckRetrievalStatus(subReport2.RetrievalStatus);
}
if (m_renderingContext.InstanceAccessDisallowed)
{
renderingContext = GetOrCreateRenderingContext(subReport2, null);
renderingContext.SubReportHasNoInstance = true;
}
else
{
m_renderingContext.OdpContext.SetupContext(subReport2, base.Instance.ReportScopeInstance);
if (subReport2.CurrentSubReportInstance == null)
{
renderingContext = GetOrCreateRenderingContext(subReport2, null);
renderingContext.SubReportHasNoInstance = true;
}
else
{
Microsoft.ReportingServices.ReportIntermediateFormat.SubReportInstance subReportInstance = subReport2.CurrentSubReportInstance.Value();
m_noRows = subReportInstance.NoRows;
m_processedWithError = subReportInstance.ProcessedWithError;
if (m_processedWithError)
{
CheckRetrievalStatus(subReportInstance.RetrievalStatus);
}
Microsoft.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance = subReportInstance.ReportInstance.Value();
renderingContext = GetOrCreateRenderingContext(subReport2, reportInstance);
renderingContext.OdpContext.LoadExistingSubReportDataChunkNameModifier(subReportInstance);
renderingContext.OdpContext.SetSubReportContext(subReportInstance, setupReportOM: true);
reportInstance.SetupEnvironment(renderingContext.OdpContext);
}
}
}
catch (Exception e)
{
m_processedWithError = true;
ErrorContext subReportErrorContext = null;
if (subReport2.OdpContext != null)
{
subReportErrorContext = subReport2.OdpContext.ErrorContext;
}
if (renderingContext == null && m_report != null)
{
renderingContext = m_report.RenderingContext;
}
Microsoft.ReportingServices.ReportProcessing.ReportProcessing.HandleSubReportProcessingError(m_renderingContext.OdpContext.TopLevelContext.ErrorContext, subReport2, subReport2.UniqueName, subReportErrorContext, e);
}
if (renderingContext != null)
{
renderingContext.SubReportProcessedWithError = m_processedWithError;
}
}
if (m_processedWithError)
{
m_noRows = false;
if (m_errorCode == SubReportErrorCodes.Success)
{
m_errorCode = SubReportErrorCodes.ProcessingError;
m_errorMessage = RPRes.rsRenderSubreportError;
}
}
m_isNewContext = false;
}
public MessageFaulted(ErrorContext errorContext, string errorQueue) : base(errorContext)
{
ErrorQueue = errorQueue;
}
public MessageToBeRetried(int attempt, TimeSpan delay, bool immediateRetry, ErrorContext errorContext) : base(errorContext)
{
Attempt = attempt;
Delay = delay;
IsImmediateRetry = immediateRetry;
}
/// <summary>
/// Converts boolean literal value.
/// </summary>
private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue)
{
var result = false;
if (!Boolean.TryParse(booleanLiteralValue, out result))
{
var message = Strings.InvalidLiteralFormat("Boolean", booleanLiteralValue);
throw EntitySqlException.Create(errCtx, message, null);
}
return result;
}
async Task ProcessFile(ILearningTransportTransaction transaction, string messageId)
{
string message;
try
{
message = await AsyncFile.ReadText(transaction.FileToProcess)
.ConfigureAwait(false);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
var bodyPath = Path.Combine(bodyDir, $"{messageId}{BodyFileSuffix}");
var headers = HeaderSerializer.Deserialize(message);
if (headers.TryGetValue(Headers.TimeToBeReceived, out var ttbrString))
{
var ttbr = TimeSpan.Parse(ttbrString);
//file.move preserves create time
var sentTime = File.GetCreationTimeUtc(transaction.FileToProcess);
if (sentTime + ttbr < DateTime.UtcNow)
{
await transaction.Commit()
.ConfigureAwait(false);
return;
}
}
var tokenSource = new CancellationTokenSource();
var body = await AsyncFile.ReadBytes(bodyPath, cancellationToken)
.ConfigureAwait(false);
var transportTransaction = new TransportTransaction();
if (transactionMode == TransportTransactionMode.SendsAtomicWithReceive)
{
transportTransaction.Set(transaction);
}
var messageContext = new MessageContext(messageId, headers, body, transportTransaction, tokenSource, new ContextBag());
try
{
await onMessage(messageContext)
.ConfigureAwait(false);
}
catch (Exception exception)
{
transaction.ClearPendingOutgoingOperations();
var processingFailures = retryCounts.AddOrUpdate(messageId, id => 1, (id, currentCount) => currentCount + 1);
var errorContext = new ErrorContext(exception, headers, messageId, body, transportTransaction, processingFailures);
// the transport tests assume that all transports use a circuit breaker to be resillient against exceptions
// in onError. Since we don't need that robustness we just retry onError once should it fail.
ErrorHandleResult actionToTake;
try
{
actionToTake = await onError(errorContext)
.ConfigureAwait(false);
}
catch (Exception)
{
actionToTake = await onError(errorContext)
.ConfigureAwait(false);
}
if (actionToTake == ErrorHandleResult.RetryRequired)
{
transaction.Rollback();
return;
}
}
if (tokenSource.IsCancellationRequested)
{
transaction.Rollback();
return;
}
await transaction.Commit()
.ConfigureAwait(false);
}
/// <summary>
/// Performs conversion of numeric strings that have no type suffix hint.
/// </summary>
private static object DefaultNumericConversion(string numericString, ErrorContext errCtx)
{
if (-1 != numericString.IndexOfAny(floatTokens))
{
Double value;
if (!Double.TryParse(numericString, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "double"));
}
return value;
}
else
{
Int32 int32Value;
if (Int32.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int32Value))
{
return int32Value;
}
Int64 int64Value;
if (!Int64.TryParse(numericString, NumberStyles.Integer, CultureInfo.InvariantCulture, out int64Value))
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.CannotConvertNumericLiteral(numericString, "long"));
}
return int64Value;
}
}
internal void OnError(StreamingContext context, ErrorContext errorContext)
{
errorContext.Handled = true;
}
/// <summary>
/// Converts hex string to byte array.
/// </summary>
private static byte[] ConvertBinaryLiteralValue(ErrorContext errCtx, string binaryLiteralValue)
{
Debug.Assert(null != binaryLiteralValue, "binaryStringLiteral must not be null");
if (String.IsNullOrEmpty(binaryLiteralValue))
{
return _emptyByteArray;
}
int startIndex = 0;
int endIndex = binaryLiteralValue.Length - 1;
Debug.Assert(startIndex <= endIndex, "startIndex <= endIndex");
int binaryStringLen = endIndex - startIndex + 1;
int byteArrayLen = binaryStringLen / 2;
bool hasOddBytes = 0 != (binaryStringLen % 2);
if (hasOddBytes)
{
byteArrayLen++;
}
byte[] binaryValue = new byte[byteArrayLen];
int arrayIndex = 0;
if (hasOddBytes)
{
binaryValue[arrayIndex++] = (byte)HexDigitToBinaryValue(binaryLiteralValue[startIndex++]);
}
while (startIndex < endIndex)
{
binaryValue[arrayIndex++] = (byte)((HexDigitToBinaryValue(binaryLiteralValue[startIndex++]) << 4) | HexDigitToBinaryValue(binaryLiteralValue[startIndex++]));
}
return binaryValue;
}
internal void OnError(StreamingContext context, ErrorContext errorContext)
{
UnityEngine.Debug.LogError("Serialization Error: " + errorContext.Error.Message);
errorContext.Handled = true;
}
private static DateTimeOffset ConvertDateTimeOffsetLiteralValue(ErrorContext errCtx, string datetimeLiteralValue)
{
string[] datetimeParts = datetimeLiteralValue.Split(_datetimeOffsetSeparators, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(datetimeParts.Length >= 7, "datetime literal value must have at least 7 parts");
int year;
int month;
int day;
GetDateParts(datetimeLiteralValue, datetimeParts, out year, out month, out day);
int hour;
int minute;
int second;
int ticks;
//Copy the time parts into a different array since the last two parts will be handled in this method.
string[] timeParts = new String[datetimeParts.Length - 2];
Array.Copy(datetimeParts, timeParts, datetimeParts.Length - 2);
GetTimeParts(datetimeLiteralValue, timeParts, 3, out hour, out minute, out second, out ticks);
Debug.Assert(year >= 1 && year <= 9999);
Debug.Assert(month >= 1 && month <= 12);
Debug.Assert(day >= 1 && day <= 31);
Debug.Assert(hour >= 0 && hour <= 24);
Debug.Assert(minute >= 0 && minute <= 59);
Debug.Assert(second >= 0 && second <= 59);
Debug.Assert(ticks >= 0 && ticks <= 9999999);
int offsetHours = Int32.Parse(datetimeParts[datetimeParts.Length - 2], NumberStyles.Integer, CultureInfo.InvariantCulture);
int offsetMinutes = Int32.Parse(datetimeParts[datetimeParts.Length - 1], NumberStyles.Integer, CultureInfo.InvariantCulture);
TimeSpan offsetTimeSpan = new TimeSpan(offsetHours, offsetMinutes, 0);
//If DateTimeOffset had a negative offset, we should negate the timespan
if (datetimeLiteralValue.IndexOf('+') == -1)
{
offsetTimeSpan = offsetTimeSpan.Negate();
}
DateTime dateTime = new DateTime(year, month, day, hour, minute, second, 0);
dateTime = dateTime.AddTicks(ticks);
try
{
return new DateTimeOffset(dateTime, offsetTimeSpan);
}
catch (ArgumentOutOfRangeException e)
{
throw EntityUtil.EntitySqlError(errCtx, System.Data.Entity.Strings.InvalidDateTimeOffsetLiteral(datetimeLiteralValue), e);
}
}
internal void OnError(StreamingContext context, ErrorContext errorContext)
{
}
/// <summary>
/// Converts guid literal value.
/// </summary>
private static Guid ConvertGuidLiteralValue(ErrorContext errCtx, string guidLiteralValue)
{
return new Guid(guidLiteralValue);
}
public ProcessReportOdpSnapshot(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, OnDemandMetadata odpMetadataFromSnapshot)
: base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext)
{
Global.Tracer.Assert(odpMetadataFromSnapshot != null, "Must provide existing metadata when processing an existing snapshot");
Global.Tracer.Assert(odpMetadataFromSnapshot.OdpChunkManager != null && null != odpMetadataFromSnapshot.ReportSnapshot, "Must provide chunk manager and ReportSnapshot when processing an existing snapshot");
this.m_odpMetadataFromSnapshot = odpMetadataFromSnapshot;
}
public MessageToBeRetried(int attempt, TimeSpan delay, bool immediateRetry, ErrorContext errorContext) : base(errorContext)
{
Attempt = attempt;
Delay = delay;
IsImmediateRetry = immediateRetry;
}
private static void RegisterInvalidCellDataSetNameError(ScopeTree scopeTree, ErrorContext errorContext, IRIFReportDataScope currentScope, DataSet ourDataSet, DataSet parentDataSet)
{
DataRegion parentDataRegion = scopeTree.GetParentDataRegion(currentScope);
errorContext.Register(ProcessingErrorCode.rsInvalidCellDataSetName, Severity.Error, currentScope.DataScopeObjectType, parentDataRegion.Name, "DataSetName", parentDataSet.Name.MarkAsPrivate(), ourDataSet.Name.MarkAsPrivate(), parentDataRegion.ObjectType.ToString());
}
public List<ILNode> Build(File.Code code, ErrorContext error=null)
{
if (code == null) throw new ArgumentNullException("code");
Stream stream = code.Data;
if (stream == null) throw new ArgumentNullException("code.Data");
if (!stream.CanRead) throw new ArgumentException("Must be readable", "code_stream");
if (!stream.CanSeek) throw new ArgumentException("Must be seekable", "code_stream");
if (stream.Length == 0) return new List<ILNode>(); // empty stream
StartingOffset = code.CodePosition;
Error = error ?? new ErrorContext(code.Name);
labels = new Dictionary<int, ILLabel>(); // cause they are all the same
stream.Position = 0;
r = new BinaryReader(stream);
CurrentPC = 0;
List<ILNode> list = new List<ILNode>();
Dictionary<int, int> pcToExpressoin = new Dictionary<int, int>();
Start(list);
while (stream.Position < stream.Length)
{
CurrentPC = (int)stream.Position / 4;
CurrentRaw = r.ReadUInt32();
ILExpression e = CreateExpression(list);
if (e != null)
{
/*
// hack here cause of issues
if (e.Code == GMCode.Conv)
{
var prev = list.Last.Value as ILExpression;
Debug.Assert(prev.Code != GMCode.Pop);
prev.ILRanges.Add(new ILRange(CurrentPC, CurrentPC));
prev.Types = e.Types; // don't add it
}
else
*/
pcToExpressoin.Add(CurrentPC, list.Count);
list.Add(e);
}
}
CurrentPC = (int) stream.Position / 4;
CurrentRaw = 0;
if(labelExists(CurrentPC)) // this is in case we do have a jump but we need to exit clean
{
pcToExpressoin.Add(CurrentPC, list.Count);
list.Add(CreateExpression(GMCode.Exit, null)); // make sure we got an exit as the last code
// we HAVE to have an exit
} else
{
ILExpression last = list.Last() as ILExpression;
if(last.Code != GMCode.Ret && last.Code != GMCode.Exit)
{
pcToExpressoin.Add(CurrentPC, list.Count);
list.Add(CreateExpression(GMCode.Exit, null)); // make sure we got an exit as the last code
}
}
foreach (var l in labels)
{
int n;
if (pcToExpressoin.TryGetValue(l.Key, out n))
list[n].UserData = l.Value;
}
var rlist = new List<ILNode>();
for(int i=0; i < list.Count; i++)
{
ILExpression e = list[i] as ILExpression;
if (e != null) {
if (e.UserData != null) { rlist.Add(e.UserData as ILLabel); e.UserData = null; }
if (e.Code == GMCode.Conv)
{
ILExpression ne = list[i+1] as ILExpression;
ne.ILRanges.AddRange(e.ILRanges);
ne.Types = e.Types;
continue; // skip
}
}
rlist.Add(list[i]);
}
Finish(rlist);
return rlist;
}
public abstract bool Validate(Severity severity, string propertyName, ObjectType objectType, string objectName, string propertyNameValue, ErrorContext errorContext);
