ErrorHandling
using Microsoft.CSharp.RuntimeBinder.Semantics;
using System;
using System.Globalization;
namespace Microsoft.CSharp.RuntimeBinder.Errors
{
internal sealed class ErrorHandling
{
private readonly IErrorSink _errorSink;
private readonly UserStringBuilder _userStringBuilder;
private readonly CErrorFactory _errorFactory;
public void Error(ErrorCode id, params ErrArg[] args)
{
ErrorTreeArgs(id, args);
}
public void ErrorRef(ErrorCode id, params ErrArgRef[] args)
{
ErrorTreeArgs(id, args);
}
public void SubmitError(CParameterizedError error)
{
_errorSink?.SubmitError(error);
}
private void MakeErrorLocArgs(out CParameterizedError error, ErrorCode id, ErrArg[] prgarg)
{
error = new CParameterizedError();
error.Initialize(id, prgarg);
}
public void AddRelatedSymLoc(CParameterizedError err, Symbol sym)
{
}
public void AddRelatedTypeLoc(CParameterizedError err, CType pType)
{
}
private void MakeErrorTreeArgs(out CParameterizedError error, ErrorCode id, ErrArg[] prgarg)
{
MakeErrorLocArgs(out error, id, prgarg);
}
public void MakeError(out CParameterizedError error, ErrorCode id, params ErrArg[] args)
{
MakeErrorTreeArgs(out error, id, args);
}
public ErrorHandling(UserStringBuilder strBldr, IErrorSink sink, CErrorFactory factory)
{
_userStringBuilder = strBldr;
_errorSink = sink;
_errorFactory = factory;
}
private CError CreateError(ErrorCode iErrorIndex, string[] args)
{
return _errorFactory.CreateError(iErrorIndex, args);
}
private void ErrorTreeArgs(ErrorCode id, ErrArg[] prgarg)
{
MakeErrorTreeArgs(out CParameterizedError error, id, prgarg);
SubmitError(error);
}
public CError RealizeError(CParameterizedError parameterizedError)
{
string[] array = new string[parameterizedError.GetParameterCount()];
int[] array2 = new int[parameterizedError.GetParameterCount()];
int num = 0;
int num2 = 0;
int num3 = 0;
_userStringBuilder.ResetUndisplayableStringFlag();
for (int i = 0; i < parameterizedError.GetParameterCount(); i++) {
ErrArg parameter = parameterizedError.GetParameter(i);
if ((parameter.eaf & ErrArgFlags.NoStr) == ErrArgFlags.None) {
bool fUserStrings = false;
if (!_userStringBuilder.ErrArgToString(out array[num], parameter, out fUserStrings) && parameter.eak == ErrArgKind.Int)
array[num] = parameter.n.ToString(CultureInfo.InvariantCulture);
num++;
int num4;
if (!fUserStrings || (parameter.eaf & ErrArgFlags.Unique) == ErrArgFlags.None)
num4 = -1;
else {
num4 = i;
num3++;
}
array2[num2] = num4;
num2++;
}
}
if (_userStringBuilder.HadUndisplayableString())
return null;
int num5 = num;
if (num3 > 1) {
string[] array3 = new string[num5];
Array.Copy(array, 0, array3, 0, num5);
for (int j = 0; j < num5; j++) {
if (array2[j] >= 0 && !(array3[j] != array[j])) {
ErrArg parameter2 = parameterizedError.GetParameter(array2[j]);
Symbol symbol = null;
CType cType = null;
bool flag;
switch (parameter2.eak) {
case ErrArgKind.Sym:
symbol = parameter2.sym;
goto IL_0182;
case ErrArgKind.Type:
cType = parameter2.pType;
goto IL_0182;
case ErrArgKind.SymWithType:
symbol = parameter2.swtMemo.sym;
goto IL_0182;
case ErrArgKind.MethWithInst:
{
symbol = parameter2.mpwiMemo.sym;
goto IL_0182;
}
IL_0182:
flag = false;
for (int k = j + 1; k < num5; k++) {
if (array2[k] >= 0 && !(array[j] != array[k])) {
if (array3[k] != array[k])
flag = true;
else {
ErrArg parameter3 = parameterizedError.GetParameter(array2[k]);
Symbol symbol2 = null;
CType cType2 = null;
switch (parameter3.eak) {
case ErrArgKind.Sym:
symbol2 = parameter3.sym;
goto IL_0232;
case ErrArgKind.Type:
cType2 = parameter3.pType;
goto IL_0232;
case ErrArgKind.SymWithType:
symbol2 = parameter3.swtMemo.sym;
goto IL_0232;
case ErrArgKind.MethWithInst:
{
symbol2 = parameter3.mpwiMemo.sym;
goto IL_0232;
}
IL_0232:
if (symbol2 != symbol || cType2 != cType || flag) {
array3[k] = array[k];
flag = true;
}
break;
}
}
}
}
if (flag)
array3[j] = array[j];
break;
}
}
}
array = array3;
}
return CreateError(parameterizedError.GetErrorNumber(), array);
}
}
}