private static void ValidateBackgroundImage(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageSource, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageValue, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundImageMIMEType, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo backgroundEmbeddingMode, Microsoft.ReportingServices.ReportIntermediateFormat.Style style, ObjectType objectType, string objectName, ErrorContext errorContext)
{
if (backgroundImageSource == null)
{
return;
}
bool flag = true;
Global.Tracer.Assert(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == backgroundImageSource.Type);
Microsoft.ReportingServices.OnDemandReportRendering.Image.SourceType intValue = (Microsoft.ReportingServices.OnDemandReportRendering.Image.SourceType)backgroundImageSource.IntValue;
Global.Tracer.Assert(backgroundImageValue != null);
if (Microsoft.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue && Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == backgroundImageValue.Type)
{
errorContext.Register(ProcessingErrorCode.rsBinaryConstant, Severity.Error, objectType, objectName, "BackgroundImageValue");
flag = false;
}
if (Microsoft.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue && !ValidateMimeType(backgroundImageMIMEType, objectType, objectName, "BackgroundImageMIMEType", errorContext))
{
flag = false;
}
if (flag)
{
style.AddAttribute("BackgroundImageSource", backgroundImageSource);
style.AddAttribute("BackgroundImageValue", backgroundImageValue);
if (backgroundEmbeddingMode != null)
{
style.AddAttribute("EmbeddingMode", backgroundEmbeddingMode);
}
if (Microsoft.ReportingServices.OnDemandReportRendering.Image.SourceType.Database == intValue)
{
style.AddAttribute("BackgroundImageMIMEType", backgroundImageMIMEType);
}
}
}
internal static void AddGroupNameValuePair(OnDemandProcessingContext odpContext, Microsoft.ReportingServices.ReportIntermediateFormat.Grouping grouping, Dictionary <string, object> nameValuePairs)
{
if (grouping == null)
{
return;
}
Global.Tracer.Assert(grouping.GroupExpressions != null && 0 < grouping.GroupExpressions.Count);
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = grouping.GroupExpressions[0];
if (expressionInfo.Type != Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Field)
{
return;
}
try
{
FieldImpl fieldImpl = odpContext.ReportObjectModel.FieldsImpl[expressionInfo.IntValue];
if (fieldImpl.FieldDef != null)
{
object value = fieldImpl.Value;
if (!nameValuePairs.ContainsKey(fieldImpl.FieldDef.DataField))
{
nameValuePairs.Add(fieldImpl.FieldDef.DataField, (value is DBNull) ? null : value);
}
}
}
catch (Exception e)
{
if (AsynchronousExceptionDetection.IsStoppingException(e))
{
throw;
}
}
}
private void ProcessAggregateParam(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, ExpressionParser.ExpressionContext context)
{
if (expression != null && expression.Type == Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Expression)
{
RegisterExpression(new ExprCompileTimeInfo(expression, context));
}
}
internal ReportBoolProperty(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, bool value)
: base(expression?.IsExpression ?? false, expression?.OriginalText)
{
if (expression != null && !expression.IsExpression)
{
m_value = value;
}
}
internal CustomProperty Add(RenderingContext renderingContext, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo nameExpr, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo valueExpr)
{
CustomProperty customProperty = new CustomProperty(m_reportElementOwner, renderingContext, nameExpr, valueExpr, null, null, TypeCode.Empty);
Global.Tracer.Assert(customProperty.Instance != null, "prop.Instance != null");
m_list.Add(customProperty);
return(customProperty);
}
internal bool IsRestrictedNaturalGroupSort(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo)
{
if (expressionInfo.Type != Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Field)
{
return(m_publishingVersioning.IsRdlFeatureRestricted(RdlFeatures.SortGroupExpression_OnlySimpleField));
}
return(false);
}
internal static bool ValidateEmbeddedImageName(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo embeddedImageName, Dictionary <string, Microsoft.ReportingServices.ReportIntermediateFormat.ImageInfo> embeddedImages, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(embeddedImageName != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == embeddedImageName.Type)
{
return(ValidateEmbeddedImageName(embeddedImageName.StringValue, embeddedImages, objectType, objectName, propertyName, errorContext));
}
return(true);
}
internal ExprCompileTimeInfo(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, ExpressionParser.ExpressionContext context)
{
ExpressionInfo = expression;
OwnerObjectType = context.ObjectType;
OwnerObjectName = context.ObjectName;
OwnerPropertyName = context.PropertyName;
NumErrors = 0;
NumWarnings = 0;
}
private static bool ValidateNumeralVariant(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo numeralVariant, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(numeralVariant != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == numeralVariant.Type && !Validator.ValidateNumeralVariant(numeralVariant.IntValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidNumeralVariant, Severity.Error, objectType, objectName, propertyName, numeralVariant.IntValue.ToString(CultureInfo.InvariantCulture));
return(false);
}
return(true);
}
private static bool ValidateCalendar(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo calendar, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(calendar != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == calendar.Type && !Validator.ValidateCalendar(calendar.StringValue))
{
errorContext.Register(ProcessingErrorCode.rsInvalidCalendar, Severity.Error, objectType, objectName, propertyName, calendar.StringValue);
return(false);
}
return(true);
}
private static bool ValidateBackgroundRepeat(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo repeat, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(repeat != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == repeat.Type && !Validator.ValidateBackgroundRepeat(repeat.StringValue, objectType))
{
errorContext.Register(ProcessingErrorCode.rsInvalidBackgroundRepeat, Severity.Error, objectType, objectName, propertyName, repeat.StringValue);
return(false);
}
return(true);
}
internal void AddAttribute(string name, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, ValueType valueType)
{
Global.Tracer.Assert(name != null);
Global.Tracer.Assert(expression != null);
m_attributes.Add(new StyleInformationAttribute
{
Name = name,
Value = expression,
ValueType = valueType
});
}
internal static bool ValidateSpecificLanguage(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo language, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext, out CultureInfo culture)
{
culture = null;
Global.Tracer.Assert(language != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == language.Type && !Validator.ValidateSpecificLanguage(language.StringValue, out culture))
{
errorContext.Register(ProcessingErrorCode.rsInvalidLanguage, Severity.Error, objectType, objectName, propertyName, language.StringValue);
return(false);
}
return(true);
}
internal static bool ValidateSize(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo size, double minValue, double maxValue, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(size != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == size.Type)
{
bool allowNegative = false;
double validSizeInMM;
string newSize;
return(ValidateSize(size.StringValue, allowNegative, minValue, maxValue, objectType, objectName, propertyName, errorContext, out validSizeInMM, out newSize));
}
return(true);
}
private void Init(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo nameExpr, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo valueExpr, string name, object value, TypeCode typeCode)
{
m_name = new ReportStringProperty(nameExpr);
m_value = new ReportVariantProperty(valueExpr);
if (nameExpr.IsExpression || valueExpr.IsExpression)
{
m_instance = new CustomPropertyInstance(this, name, value, typeCode);
}
else
{
m_instance = null;
}
}
internal static bool ValidateMimeType(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo mimeType, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
if (mimeType == null)
{
errorContext.Register(ProcessingErrorCode.rsMissingMIMEType, Severity.Error, objectType, objectName, propertyName);
return(false);
}
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == mimeType.Type)
{
return(ValidateMimeType(mimeType.StringValue, objectType, objectName, propertyName, errorContext));
}
return(true);
}
internal static bool ValidateColor(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo color, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(color != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == color.Type)
{
if (!Validator.ValidateColor(color.StringValue, out string newColor, Validator.IsDynamicImageReportItem(objectType)))
{
errorContext.Register(ProcessingErrorCode.rsInvalidColor, Severity.Error, objectType, objectName, propertyName, color.StringValue);
return(false);
}
color.StringValue = newColor;
}
return(true);
}
private static bool ValidateTransparency(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo transparency, ObjectType objectType, string objectName, string propertyName, ErrorContext errorContext)
{
Global.Tracer.Assert(transparency != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == transparency.Type)
{
double floatValue = transparency.FloatValue;
if (floatValue < 0.0 || floatValue > 100.0)
{
errorContext.Register(ProcessingErrorCode.rsOutOfRangeSize, Severity.Error, objectType, objectName, propertyName, transparency.OriginalText, "0", "100");
return(false);
}
}
return(true);
}
private static bool ValidateBorderStyle(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo borderStyle, ObjectType objectType, string objectName, bool isDynamicElementSubElement, string propertyName, bool isDefaultBorder, ErrorContext errorContext)
{
Global.Tracer.Assert(borderStyle != null);
if (Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant == borderStyle.Type)
{
if (!Validator.ValidateBorderStyle(borderStyle.StringValue, isDefaultBorder, objectType, isDynamicElementSubElement, out string validatedStyle))
{
errorContext.Register(ProcessingErrorCode.rsInvalidBorderStyle, Severity.Error, objectType, objectName, propertyName, borderStyle.StringValue);
return(false);
}
borderStyle.StringValue = validatedStyle;
}
return(true);
}
public override List <ScopeValueFieldName> GetScopeValueFieldNameCollection(Microsoft.ReportingServices.ReportIntermediateFormat.DataSet dataSet)
{
List <ScopeValueFieldName> list = new List <ScopeValueFieldName>();
int num = 0;
foreach (ScopeValue item in m_scopeID.QueryRestartPosition)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = Expressions[num];
string dataField = dataSet.Fields[expressionInfo.FieldIndex].DataField;
list.Add(new ScopeValueFieldName(dataField, item.Value));
num++;
}
return(list);
}
internal ReportDoubleProperty(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo)
: base(expressionInfo?.IsExpression ?? false, expressionInfo?.OriginalText)
{
if (expressionInfo != null && !expressionInfo.IsExpression)
{
if (expressionInfo.ConstantType == DataType.Float)
{
m_value = expressionInfo.FloatValue;
}
else if (!double.TryParse(expressionInfo.StringValue, out m_value))
{
m_value = 0.0;
}
}
}
internal ReportStringProperty(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression)
: base(expression?.IsExpression ?? false, expression?.OriginalText)
{
if (expression != null && !expression.IsExpression)
{
if (expression.ConstantType != DataType.String)
{
m_value = expression.OriginalText;
}
else
{
m_value = expression.StringValue;
}
}
}
public override RowSkippingControlFlag DoesNotMatchRowRecordField(OnDemandProcessingContext odpContext, Microsoft.ReportingServices.ReportIntermediateFormat.RecordField[] recordFields)
{
for (int i = 0; i < m_expressions.Length; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = m_expressions[i];
object value = m_values[i].Value;
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField field = recordFields[expressionInfo.FieldIndex];
bool isSortedAscending = m_sortDirections[i] == SortDirection.Ascending;
RowSkippingControlFlag rowSkippingControlFlag = CompareFieldWithScopeValueAndStopOnInequality(odpContext, field, value, isSortedAscending, ObjectType.DataSet, m_idcDataSet.Name, "Relationship.QueryRestart");
if (rowSkippingControlFlag != 0)
{
return(rowSkippingControlFlag);
}
}
return(RowSkippingControlFlag.ExactMatch);
}
public override RowSkippingControlFlag DoesNotMatchRowRecordField(OnDemandProcessingContext odpContext, Microsoft.ReportingServices.ReportIntermediateFormat.RecordField[] recordFields)
{
int num = 0;
foreach (ScopeValue item in m_scopeID.QueryRestartPosition)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = Expressions[num];
Microsoft.ReportingServices.ReportIntermediateFormat.RecordField field = recordFields[expressionInfo.FieldIndex];
RowSkippingControlFlag rowSkippingControlFlag = CompareFieldWithScopeValueAndStopOnInequality(odpContext, field, item.Value, SortDirections[num], ObjectType.DataSet, m_memberDef.DataScopeInfo.DataSet.Name, "ScopeID.QueryRestart");
if (rowSkippingControlFlag != 0)
{
return(rowSkippingControlFlag);
}
num++;
}
return(RowSkippingControlFlag.ExactMatch);
}
private void ProcessAggregateParams(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, ExpressionParser.ExpressionContext context)
{
if (expression.Aggregates != null)
{
for (int num = expression.Aggregates.Count - 1; num >= 0; num--)
{
ProcessAggregateParam(expression.Aggregates[num], context);
}
}
if (expression.RunningValues != null)
{
for (int num2 = expression.RunningValues.Count - 1; num2 >= 0; num2--)
{
ProcessAggregateParam(expression.RunningValues[num2], context);
}
}
}
private void ProcessExpression(Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression, ExpressionParser.ExpressionContext context)
{
if (expression.Type == Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Expression)
{
RegisterExpression(new ExprCompileTimeInfo(expression, context));
ProcessAggregateParams(expression, context);
}
else if (expression.Type == Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Aggregate)
{
ProcessAggregateParams(expression, context);
}
else if (expression.Type == Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Field && context.Location == Microsoft.ReportingServices.ReportPublishing.LocationFlags.None)
{
if (m_reportLevelFieldReferences == null)
{
m_reportLevelFieldReferences = new ArrayList();
}
m_reportLevelFieldReferences.Add(new ExprCompileTimeInfo(expression, context));
}
}
public bool ShouldSkipCurrentRow()
{
FieldsImpl fieldsImpl = m_odpContext.ReportObjectModel.FieldsImpl;
bool flag = true;
for (int i = 0; i < m_expressions.Count && flag; i++)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = m_expressions[i];
if (expressionInfo.FieldIndex < 0)
{
flag = false;
continue;
}
FieldImpl fieldImpl = fieldsImpl[expressionInfo.FieldIndex];
if (fieldImpl.FieldStatus != 0)
{
return(false);
}
flag = (m_odpContext.CompareAndStopOnError(m_values[i], fieldImpl.Value, m_scope.DataScopeObjectType, m_scope.Name, "GroupExpression", extendedTypeComparisons: false) == 0);
}
return(flag);
}
private ReportSizeProperty GetOrCreateMarginProperty(ref ReportSizeProperty property, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expression)
{
if (m_isOldSnapshot || expression == null)
{
return(null);
}
if (property == null)
{
property = new ReportSizeProperty(expression);
}
return(property);
}
internal Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo ParseExpression(string expression, ExpressionParser.ExpressionContext context, ExpressionParser.EvaluationMode evaluationMode, out bool userCollectionReferenced)
{
Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = m_langParser.ParseExpression(expression, context, evaluationMode, out userCollectionReferenced);
ProcessExpression(expressionInfo, context);
return(expressionInfo);
}
internal static void ParseRDLConstant(string expression, Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo, DataType constantType, ErrorContext errorContext, ObjectType objectType, string objectName, string propertyName)
{
expressionInfo.Type = Microsoft.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Constant;
expressionInfo.ConstantType = constantType;
switch (constantType)
{
case DataType.String:
expressionInfo.StringValue = expression;
break;
case DataType.Boolean:
{
bool boolValue;
try
{
if (string.Compare(expression, "0", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(expression, "1", StringComparison.OrdinalIgnoreCase) == 0)
{
errorContext.Register(ProcessingErrorCode.rsInvalidBooleanConstant, Severity.Warning, objectType, objectName, propertyName, expression);
}
boolValue = XmlConvert.ToBoolean(expression);
}
catch (Exception e3)
{
if (AsynchronousExceptionDetection.IsStoppingException(e3))
{
throw;
}
boolValue = false;
errorContext.Register(ProcessingErrorCode.rsInvalidBooleanConstant, Severity.Error, objectType, objectName, propertyName, expression);
}
expressionInfo.BoolValue = boolValue;
break;
}
case DataType.Integer:
{
int intValue;
try
{
intValue = XmlConvert.ToInt32(expression);
}
catch (Exception e2)
{
if (AsynchronousExceptionDetection.IsStoppingException(e2))
{
throw;
}
intValue = 0;
errorContext.Register(ProcessingErrorCode.rsInvalidIntegerConstant, Severity.Error, objectType, objectName, propertyName, expression.MarkAsPrivate());
}
expressionInfo.IntValue = intValue;
break;
}
case DataType.Float:
{
double floatValue;
try
{
floatValue = XmlConvert.ToDouble(expression);
}
catch (Exception e)
{
if (AsynchronousExceptionDetection.IsStoppingException(e))
{
throw;
}
floatValue = 0.0;
errorContext.Register(ProcessingErrorCode.rsInvalidFloatConstant, Severity.Error, objectType, objectName, propertyName, expression);
}
expressionInfo.FloatValue = floatValue;
break;
}
case DataType.DateTime:
{
if (DateTimeUtil.TryParseDateTime(expression, CultureInfo.InvariantCulture, out DateTimeOffset dateTimeOffset, out bool hasTimeOffset))
{
if (hasTimeOffset)
{
expressionInfo.SetDateTimeValue(dateTimeOffset);
}
else
{
expressionInfo.SetDateTimeValue(dateTimeOffset.DateTime);
}
}
