public CError CreateError(ErrorCode iErrorIndex, params string[] args)
{
CError output = new CError();
output.Initialize(iErrorIndex, args);
return output;
}
public CError RealizeError(CParameterizedError parameterizedError)
{
// Create an arg array manually using the type information in the ErrArgs.
string[] prgpsz = new string[parameterizedError.GetParameterCount()];
int[] prgiarg = new int[parameterizedError.GetParameterCount()];
int ppsz = 0;
int piarg = 0;
int cargUnique = 0;
m_userStringBuilder.ResetUndisplayableStringFlag();
for (int iarg = 0; iarg < parameterizedError.GetParameterCount(); iarg++)
{
ErrArg arg = parameterizedError.GetParameter(iarg);
// If the NoStr bit is set we don't add it to prgpsz.
if (0 != (arg.eaf & ErrArgFlags.NoStr))
{
continue;
}
bool fUserStrings = false;
if (!m_userStringBuilder.ErrArgToString(out prgpsz[ppsz], arg, out fUserStrings))
{
if (arg.eak == ErrArgKind.Int)
{
prgpsz[ppsz] = arg.n.ToString(CultureInfo.InvariantCulture);
}
}
ppsz++;
int iargRec;
if (!fUserStrings || 0 == (arg.eaf & ErrArgFlags.Unique))
{
iargRec = -1;
}
else
{
iargRec = iarg;
cargUnique++;
}
prgiarg[piarg] = iargRec;
piarg++;
}
// don't ever display undisplayable strings to the user
// if this happens we should track down the caller to not display the error
// this should only ever occur in a cascading error situation due to
// error tolerance
if (m_userStringBuilder.HadUndisplayableString())
{
return(null);
}
int cpsz = ppsz;
if (cargUnique > 1)
{
// Copy the strings over to another buffer.
string[] prgpszNew = new string[cpsz];
Array.Copy(prgpsz, 0, prgpszNew, 0, cpsz);;
for (int i = 0; i < cpsz; i++)
{
if (prgiarg[i] < 0 || prgpszNew[i] != prgpsz[i])
{
continue;
}
ErrArg arg = parameterizedError.GetParameter(prgiarg[i]);
Debug.Assert(0 != (arg.eaf & ErrArgFlags.Unique) && 0 == (arg.eaf & ErrArgFlags.NoStr));
Symbol sym = null;
CType pType = null;
switch (arg.eak)
{
case ErrArgKind.Sym:
sym = arg.sym;
break;
case ErrArgKind.Type:
pType = arg.pType;
break;
case ErrArgKind.SymWithType:
sym = arg.swtMemo.sym;
break;
case ErrArgKind.MethWithInst:
sym = arg.mpwiMemo.sym;
break;
default:
Debug.Assert(false, "Shouldn't be here!");
continue;
}
bool fMunge = false;
for (int j = i + 1; j < cpsz; j++)
{
if (prgiarg[j] < 0)
{
continue;
}
Debug.Assert(0 != (parameterizedError.GetParameter(prgiarg[j]).eaf & ErrArgFlags.Unique));
if (prgpsz[i] != prgpsz[j])
{
continue;
}
// The strings are identical. If they are the same symbol, leave them alone.
// Otherwise, munge both strings. If j has already been munged, just make
// sure we munge i.
if (prgpszNew[j] != prgpsz[j])
{
fMunge = true;
continue;
}
ErrArg arg2 = parameterizedError.GetParameter(prgiarg[j]);
Debug.Assert(0 != (arg2.eaf & ErrArgFlags.Unique) && 0 == (arg2.eaf & ErrArgFlags.NoStr));
Symbol sym2 = null;
CType pType2 = null;
switch (arg2.eak)
{
case ErrArgKind.Sym:
sym2 = arg2.sym;
break;
case ErrArgKind.Type:
pType2 = arg2.pType;
break;
case ErrArgKind.SymWithType:
sym2 = arg2.swtMemo.sym;
break;
case ErrArgKind.MethWithInst:
sym2 = arg2.mpwiMemo.sym;
break;
default:
Debug.Assert(false, "Shouldn't be here!");
continue;
}
if (sym2 == sym && pType2 == pType && !fMunge)
{
continue;
}
prgpszNew[j] = prgpsz[j];
fMunge = true;
}
if (fMunge)
{
prgpszNew[i] = prgpsz[i];
}
}
prgpsz = prgpszNew;
}
CError err = CreateError(parameterizedError.GetErrorNumber(), prgpsz);
return(err);
}
public override void SubmitError(CError pError)
{
throw new RuntimeBinderException(pError.Text);
}