public string MangleType(TypeSpec ts)
{
StringBuilder sb = new StringBuilder("_Z");
ManglerState ms = new ManglerState();
MangleType(ts, sb, ms);
return(sb.ToString());
}
public TypeSpec DemangleType(string s)
{
ManglerState ms = new ManglerState();
int i = 0;
if (!Munch(s, ref i, "_Z"))
{
throw new ArgumentException();
}
return(DemangleType(s, ref i, ms));
}
public static string MangleMethod(System.Reflection.MethodInfo method)
{
StringBuilder sb = new StringBuilder("_Z");
ManglerState ms = new ManglerState();
MangleType(method.DeclaringType as TysosType, sb, ms);
sb.Append("M_");
if ((method.CallingConvention & System.Reflection.CallingConventions.VarArgs) == System.Reflection.CallingConventions.VarArgs)
{
throw new Exception("Unsupported calling convention (VarArgs)");
}
else
{
sb.Append("0");
}
sb.Append("_");
AppendStringWithLength(sb, EncodeString(method.Name));
sb.Append("_R");
MangleType(method.ReturnType as TysosType, sb, ms);
sb.Append("_P");
System.Reflection.ParameterInfo[] ps = method.GetParameters();
bool has_this = false;
if ((method.CallingConvention & System.Reflection.CallingConventions.HasThis) == System.Reflection.CallingConventions.HasThis)
{
has_this = true;
}
if ((method.CallingConvention & System.Reflection.CallingConventions.ExplicitThis) == System.Reflection.CallingConventions.ExplicitThis)
{
has_this = false;
}
sb.Append(ps.Length + (has_this ? 1 : 0));
if (has_this)
{
sb.Append("u1t");
}
foreach (System.Reflection.ParameterInfo p in ps)
{
MangleType(p.ParameterType as TysosType, sb, ms);
}
// TODO: determine if this is a generic method
return(sb.ToString());
}
private void MangleTypeSig(ref int type_idx, StringBuilder sb, ManglerState ms)
{
uint p_token;
int p_type = GetType(ref type_idx, out p_token);
switch (p_type)
{
case 0x1d:
/* SZARRAY */
sb.Append("u1Z");
MangleTypeSig(ref type_idx, sb, ms);
break;
default:
MangleTypeSig(p_type, p_token, sb, ms);
break;
}
}
public Spec DemangleObject(string s)
{
ManglerState ms = new ManglerState();
int i = 0;
if (!Munch(s, ref i, "_Z"))
{
throw new ArgumentException();
}
var ts = DemangleType(s, ref i, ms);
if (!Munch(s, ref i, "_"))
{
return(ts);
}
return(DemangleMethod(s, ref i, ms, ts, s));
}
private MethodSpec DemangleMethod(string s, ref int i, ManglerState ms, TypeSpec ts, string mangled_name)
{
MethodSpec ret = new MethodSpec();
ret.m = ts.m;
ret.type = ts;
ret.mangle_override = mangled_name;
ret.name_override = MunchString(s, ref i);
if (Munch(s, ref i, "_g"))
{
var gm_count = MunchNumber(s, ref i);
ret.gmparams = new TypeSpec[gm_count];
for (int idx = 0; idx < gm_count; idx++)
{
ret.gmparams[idx] = DemangleType(s, ref i, ms);
}
}
if (!Munch(s, ref i, "_R"))
{
throw new ArgumentException();
}
var rettype = DemangleType(s, ref i, ms);
if (!Munch(s, ref i, "_P"))
{
throw new ArgumentException();
}
var pcount = MunchNumber(s, ref i);
var ps = new TypeSpec[pcount];
for (int idx = 0; idx < pcount; idx++)
{
ps[idx] = DemangleType(s, ref i, ms);
}
return(ret);
}
/** <summary>Returns true if the provided string is a mangled method, false if a type and an exception otherwise</summary> */
public bool IsMangledMethod(string s)
{
ManglerState ms = new ManglerState();
int i = 0;
if (!Munch(s, ref i, "_Z"))
{
throw new ArgumentException();
}
try
{
var ts = DemangleType(s, ref i, ms);
}
catch (Exception)
{
return(false);
}
var ret = Munch(s, ref i, "_");
return(ret);
}
static void MangleType(TysosType t, StringBuilder sb, ManglerState ms)
{
bool cont = true;
while (cont)
{
if (t.IsBoxed)
{
sb.Append("B");
t = t.GetUnboxedType();
}
else if (t.IsManagedPointer)
{
sb.Append("R");
t = t.GetUnboxedType();
}
else if (t.IsUnmanagedPointer)
{
sb.Append("P");
t = t.GetUnboxedType();
}
else if (t.IsZeroBasedArray)
{
sb.Append("u1Z");
MangleType(t.GetElementType() as TysosType, sb, ms);
return;
}
else if (t.IsArray)
{
sb.Append("u1A");
MangleType(t.GetElementType() as TysosType, sb, ms);
sb.Append(t.GetArrayRank());
sb.Append("_");
// TODO: work out how to extract array lobounds and sizes
return;
}
else
{
cont = false;
}
}
if (t.IsSimpleType)
{
switch (t.SimpleTypeElementType)
{
case 1:
// void
sb.Append("v");
break;
case 2:
// bool
sb.Append("b");
break;
case 3:
// char
sb.Append("c");
break;
case 4:
// i1
sb.Append("a");
break;
case 5:
// u1
sb.Append("h");
break;
case 6:
// i2
sb.Append("s");
break;
case 7:
// u2
sb.Append("t");
break;
case 8:
// i4
sb.Append("i");
break;
case 9:
// u4
sb.Append("j");
break;
case 0xa:
// i8
sb.Append("x");
break;
case 0xb:
// u8
sb.Append("y");
break;
case 0xc:
// r4
sb.Append("f");
break;
case 0xd:
// r8
sb.Append("d");
break;
case 0xe:
// string
sb.Append("u1S");
break;
case 0x18:
// intptr
sb.Append("u1I");
break;
case 0x19:
// uintptr
sb.Append("u1U");
break;
case 0x1c:
// object
sb.Append("u1O");
break;
case 0x16:
// TypedByRef
sb.Append("u1T");
break;
case 0xfe:
// VirtFtnPtr
sb.Append("u1V");
break;
case 0xfd:
// UninstantiatedGenericParam
sb.Append("u1P");
break;
case 0xfc:
// RefGenericParam
sb.Append("u1R");
break;
default:
throw new NotSupportedException();
}
}
else if (t.IsGenericType)
{
MangleType(t.GetGenericTypeDefinition() as TysosType, sb, ms);
sb.Append("_G");
sb.Append(t.GetGenericArguments().Length);
foreach (Type p in t.GetGenericArguments())
{
MangleType(p as TysosType, sb, ms);
}
}
else if (t.IsUninstantiatedGenericTypeParameter)
{
sb.Append("u1G");
sb.Append(t.UgtpIdx);
}
else if (t.IsUninstantiatedGenericMethodParameter)
{
sb.Append("u1g");
sb.Append(t.UgmpIdx);
}
else
{
string mod = EncodeString(t.Module.Name);
string nspace = EncodeString(t.Namespace);
string name = EncodeString(t.Name);
if (mod == ms.cur_module)
{
if (nspace == ms.cur_nspace)
{
sb.Append("V");
AppendStringWithLength(sb, name);
}
else
{
sb.Append("U");
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_nspace = nspace;
}
}
else if (mod == "mscorlib")
{
sb.Append("W");
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
else if ((mod == "libsupcs") && (nspace == "libsupcs"))
{
sb.Append("X");
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
else
{
sb.Append("N");
AppendStringWithLength(sb, mod);
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
}
}
private void MangleTypeDef(int td_idx, StringBuilder sb, ManglerState ms)
{
// Is this a simple type?
if (is_corlib && simple_type_idx[td_idx] != -1)
{
MangleTypeSig(simple_type_idx[td_idx], 0, sb, ms);
return;
}
// Get module, type name
string mod = EncodeString(GetStringEntry(tid_Module, 1, 1));
if (mod == "CommonLanguageRuntimeLibrary")
{
/* This is the framework-agnostic .netstandard 2.0 way of referring to
* either mscorlib.dll or System.Private.CoreLib.dll
*
* We rename the latter to the former in the build script, so do the
* same here */
mod = "mscorlib#2Edll";
}
// Get namespace of outermost enclosing type
int outermost = td_idx;
while (nested_parent[outermost] != 0)
{
outermost = nested_parent[outermost];
}
string nspace = EncodeString(GetStringEntry(tid_TypeDef, outermost, 2));
StringBuilder name_sb = new StringBuilder();
AppendEnclosingType(td_idx, name_sb);
string name = EncodeString(name_sb.ToString());
if (mod == ms.cur_module)
{
if (nspace == ms.cur_nspace)
{
sb.Append("V");
AppendStringWithLength(sb, name);
}
else
{
sb.Append("U");
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_nspace = nspace;
}
}
else if (mod == "mscorlib#2Edll")
{
sb.Append("W");
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
else if ((mod == "libsupcs#2E") && (nspace == "libsupcs#2E"))
{
sb.Append("X");
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
else
{
sb.Append("N");
AppendStringWithLength(sb, mod);
AppendStringWithLength(sb, nspace);
AppendStringWithLength(sb, name);
ms.cur_module = mod;
ms.cur_nspace = nspace;
}
}
private void MangleTypeSig(int ret_type, uint ret_token, StringBuilder sb, ManglerState ms)
{
switch (ret_type)
{
case 1:
// void
sb.Append("v");
break;
case 2:
// bool
sb.Append("b");
break;
case 3:
// char
sb.Append("c");
break;
case 4:
// i1
sb.Append("a");
break;
case 5:
// u1
sb.Append("h");
break;
case 6:
// i2
sb.Append("s");
break;
case 7:
// u2
sb.Append("t");
break;
case 8:
// i4
sb.Append("i");
break;
case 9:
// u4
sb.Append("j");
break;
case 0xa:
// i8
sb.Append("x");
break;
case 0xb:
// u8
sb.Append("y");
break;
case 0xc:
// r4
sb.Append("f");
break;
case 0xd:
// r8
sb.Append("d");
break;
case 0xe:
// string
sb.Append("u1S");
break;
case 0x11:
// ValueType
sb.Append("u1L");
break;
case 0x18:
// intptr
sb.Append("u1I");
break;
case 0x19:
// uintptr
sb.Append("u1U");
break;
case 0x1c:
// object
sb.Append("u1O");
break;
case 0x16:
// TypedByRef
sb.Append("u1T");
break;
default:
throw new NotSupportedException();
}
}
private string MangleMethod(TypeSpec t, string mname, int msig,
TypeSpec[] gtparams = null, TypeSpec[] gmparams = null,
bool is_spec = false, bool is_boxed = false,
bool ret_type_needs_boxing = false)
{
StringBuilder sb = new StringBuilder("_Z");
ManglerState ms = new ManglerState();
if (msig == 0)
{
throw new Exception("invalid method signature");
}
if (gtparams == null)
{
gtparams = t.gtparams;
}
/* Get declaring type */
MangleType(t, sb, ms);
sb.Append("_");
/* Get method name */
AppendStringWithLength(sb, mname);
/* Generic method params */
if (gmparams != null)
{
sb.Append("_g");
sb.Append(gmparams.Length.ToString());
foreach (var gmp in gmparams)
{
MangleType(gmp, sb, ms);
}
}
if (is_spec)
{
sb.Append("_MS");
}
/* Return type */
sb.Append("_R");
int ret_idx = GetMethodDefSigRetTypeIndex(msig);
var ret_ts = GetTypeSpec(ref ret_idx, gtparams,
gmparams);
MangleType(ret_ts, sb, ms);
/* Params */
sb.Append("_P");
var pcount = GetMethodDefSigParamCount(msig);
var pcountthis = GetMethodDefSigParamCountIncludeThis(msig);
sb.Append(pcountthis);
if (pcountthis != pcount)
{
sb.Append("u1t");
}
for (int i = 0; i < pcount; i++)
{
var p_ts = GetTypeSpec(ref ret_idx, gtparams, gmparams);
MangleType(p_ts, sb, ms);
}
if (is_boxed)
{
sb.Append("B");
}
if (ret_type_needs_boxing)
{
sb.Append("b");
}
return(sb.ToString());
}
void MangleType(TypeSpec ts, StringBuilder sb,
ManglerState ms)
{
if (ts == null)
{
sb.Append("v");
return;
}
switch (ts.stype)
{
case TypeSpec.SpecialType.None:
ts.m.MangleTypeDef(ts.tdrow, sb, ms);
if (ts.IsGeneric && ts.gtparams != null)
{
sb.Append("_G");
sb.Append(ts.gtparams.Length.ToString());
foreach (var gtparam in ts.gtparams)
{
MangleType(gtparam, sb, ms);
}
}
break;
case TypeSpec.SpecialType.SzArray:
sb.Append("u1Z");
MangleType(ts.other, sb, ms);
break;
case TypeSpec.SpecialType.Ptr:
sb.Append("P");
MangleType(ts.other, sb, ms);
break;
case TypeSpec.SpecialType.MPtr:
sb.Append("R");
MangleType(ts.other, sb, ms);
break;
case TypeSpec.SpecialType.Var:
sb.Append("u1P");
sb.Append(ts.idx.ToString());
break;
case TypeSpec.SpecialType.MVar:
sb.Append("u1p");
sb.Append(ts.idx.ToString());
break;
case TypeSpec.SpecialType.Boxed:
MangleType(ts.other, sb, ms);
break;
case TypeSpec.SpecialType.Array:
sb.Append("u1A");
MangleType(ts.other, sb, ms);
sb.Append(ts.arr_rank.ToString());
foreach (var lb in ts.arr_lobounds)
{
sb.Append("_");
sb.Append(lb.ToString());
}
sb.Append("_");
foreach (var s in ts.arr_sizes)
{
sb.Append("_");
sb.Append(s.ToString());
}
break;
default:
throw new NotImplementedException();
}
}
private TypeSpec DemangleType(string s, ref int i, ManglerState ms)
{
string module = ms.cur_module, nspace = ms.cur_nspace, name;
if (Munch(s, ref i, "P"))
{
return(new TypeSpec
{
stype = TypeSpec.SpecialType.Ptr,
other = DemangleType(s, ref i, ms)
});
}
else if (Munch(s, ref i, "R"))
{
return(new TypeSpec
{
stype = TypeSpec.SpecialType.MPtr,
other = DemangleType(s, ref i, ms)
});
}
else if (Munch(s, ref i, "u1Z"))
{
return(new TypeSpec
{
stype = TypeSpec.SpecialType.SzArray,
other = DemangleType(s, ref i, ms)
});
}
else if (Munch(s, ref i, "u1A"))
{
throw new NotImplementedException();
}
else if (Munch(s, ref i, "v"))
{
return(SystemVoid);
}
else if (Munch(s, ref i, "c"))
{
return(SystemChar);
}
else if (Munch(s, ref i, "b"))
{
throw new NotImplementedException(); //bool
}
else if (Munch(s, ref i, "a"))
{
return(SystemInt8);
}
else if (Munch(s, ref i, "h"))
{
return(SystemByte);
}
else if (Munch(s, ref i, "s"))
{
return(SystemInt16);
}
else if (Munch(s, ref i, "t"))
{
return(SystemUInt16);
}
else if (Munch(s, ref i, "i"))
{
return(SystemInt32);
}
else if (Munch(s, ref i, "j"))
{
return(SystemUInt32);
}
else if (Munch(s, ref i, "x"))
{
return(SystemInt64);
}
else if (Munch(s, ref i, "y"))
{
return(SystemUInt64);
}
else if (Munch(s, ref i, "f"))
{
throw new NotImplementedException(); //r4
}
else if (Munch(s, ref i, "d"))
{
throw new NotImplementedException(); //r8
}
else if (Munch(s, ref i, "u1I"))
{
return(SystemIntPtr);
}
else if (Munch(s, ref i, "u1U"))
{
throw new NotImplementedException(); //uintptr
}
else if (Munch(s, ref i, "u1S"))
{
return(SystemString);
}
else if (Munch(s, ref i, "u1O"))
{
return(SystemObject);
}
else if (Munch(s, ref i, "u1L"))
{
return(SystemValueType);
}
else if (Munch(s, ref i, "u1T"))
{
return(SystemTypedByRef);
}
else if (Munch(s, ref i, "N"))
{
module = MunchString(s, ref i);
nspace = MunchString(s, ref i);
name = MunchString(s, ref i);
}
else if (Munch(s, ref i, "U"))
{
nspace = MunchString(s, ref i);
name = MunchString(s, ref i);
}
else if (Munch(s, ref i, "V"))
{
name = MunchString(s, ref i);
}
else if (Munch(s, ref i, "W"))
{
module = "mscorlib";
nspace = MunchString(s, ref i);
name = MunchString(s, ref i);
}
else if (Munch(s, ref i, "X"))
{
module = "libsupcs";
nspace = "libsupcs";
name = MunchString(s, ref i);
}
else if (Munch(s, ref i, "u1t"))
{
return(null);
}
else
{
throw new NotImplementedException();
}
if (Munch(s, ref i, "_G"))
{
throw new NotImplementedException();
}
ms.cur_module = module;
ms.cur_nspace = nspace;
var mod = al.GetAssembly(module);
if (mod == null)
{
throw new DllNotFoundException(module);
}
return(mod.GetTypeSpec(nspace, name));
}
