BSYMMGR
class BSYMMGR
using Microsoft.CSharp.RuntimeBinder.Syntax;
using System;
using System.Collections.Generic;
using System.Globalization;
namespace Microsoft.CSharp.RuntimeBinder.Semantics
{
internal class BSYMMGR
{
protected struct TypeArrayKey : IEquatable<TypeArrayKey>
{
private CType[] _types;
private int _hashCode;
public TypeArrayKey(CType[] types)
{
_types = types;
_hashCode = 0;
int i = 0;
for (int num = types.Length; i < num; i++) {
_hashCode ^= types[i].GetHashCode();
}
}
public bool Equals(TypeArrayKey other)
{
if (other._types == _types)
return true;
if (other._types.Length != _types.Length)
return false;
if (other._hashCode != _hashCode)
return false;
int i = 0;
for (int num = _types.Length; i < num; i++) {
if (!_types[i].Equals(other._types[i]))
return false;
}
return true;
}
public override bool Equals(object obj)
{
if (obj is TypeArrayKey)
return Equals((TypeArrayKey)obj);
return false;
}
public override int GetHashCode()
{
return _hashCode;
}
}
internal HashSet<KAID> bsetGlobalAssemblies;
public PropertySymbol propNubValue;
public MethodSymbol methNubCtor;
private SymFactory _symFactory;
private MiscSymFactory _miscSymFactory;
private NamespaceSymbol _rootNS;
protected List<AidContainer> ssetAssembly;
protected NameManager m_nameTable;
protected SYMTBL tableGlobal;
protected Dictionary<TypeArrayKey, TypeArray> tableTypeArrays;
private InputFile _infileUnres;
private const int LOG2_SYMTBL_INITIAL_BUCKET_CNT = 13;
private static readonly TypeArray s_taEmpty = new TypeArray(Array.Empty<CType>());
public BSYMMGR(NameManager nameMgr, TypeManager typeManager)
{
m_nameTable = nameMgr;
tableGlobal = new SYMTBL();
_symFactory = new SymFactory(tableGlobal, m_nameTable);
_miscSymFactory = new MiscSymFactory(tableGlobal);
ssetAssembly = new List<AidContainer>();
_infileUnres = new InputFile();
_infileUnres.isSource = false;
_infileUnres.SetAssemblyID(KAID.kaidUnresolved);
ssetAssembly.Add(new AidContainer(_infileUnres));
bsetGlobalAssemblies = new HashSet<KAID>();
bsetGlobalAssemblies.Add(KAID.kaidThisAssembly);
tableTypeArrays = new Dictionary<TypeArrayKey, TypeArray>();
_rootNS = _symFactory.CreateNamespace(m_nameTable.Add(""), null);
GetNsAid(_rootNS, KAID.kaidGlobal);
}
public void Init()
{
InitPreLoad();
}
public NameManager GetNameManager()
{
return m_nameTable;
}
public SYMTBL GetSymbolTable()
{
return tableGlobal;
}
public static TypeArray EmptyTypeArray()
{
return s_taEmpty;
}
public AssemblyQualifiedNamespaceSymbol GetRootNsAid(KAID aid)
{
return GetNsAid(_rootNS, aid);
}
public NamespaceSymbol GetRootNS()
{
return _rootNS;
}
public KAID AidAlloc(InputFile sym)
{
ssetAssembly.Add(new AidContainer(sym));
return (KAID)(ssetAssembly.Count - 1 + 3);
}
public BetterType CompareTypes(TypeArray ta1, TypeArray ta2)
{
if (ta1 == ta2)
return BetterType.Same;
if (ta1.Size != ta2.Size) {
if (ta1.Size <= ta2.Size)
return BetterType.Right;
return BetterType.Left;
}
BetterType betterType = BetterType.Neither;
for (int i = 0; i < ta1.Size; i++) {
CType cType = ta1.Item(i);
CType cType2 = ta2.Item(i);
BetterType betterType2 = BetterType.Neither;
while (true) {
if (cType.GetTypeKind() != cType2.GetTypeKind()) {
if (cType.IsTypeParameterType())
betterType2 = BetterType.Right;
else if (cType2.IsTypeParameterType()) {
betterType2 = BetterType.Left;
}
break;
}
switch (cType.GetTypeKind()) {
case TypeKind.TK_ArrayType:
case TypeKind.TK_PointerType:
case TypeKind.TK_ParameterModifierType:
case TypeKind.TK_NullableType:
break;
case TypeKind.TK_AggregateType:
betterType2 = CompareTypes(cType.AsAggregateType().GetTypeArgsAll(), cType2.AsAggregateType().GetTypeArgsAll());
goto end_IL_0042;
default:
goto end_IL_0042;
}
cType = cType.GetBaseOrParameterOrElementType();
cType2 = cType2.GetBaseOrParameterOrElementType();
continue;
continue;
end_IL_0042:
break;
}
if (betterType2 == BetterType.Right || betterType2 == BetterType.Left) {
if (betterType == BetterType.Same || betterType == BetterType.Neither)
betterType = betterType2;
else if (betterType2 != betterType) {
return BetterType.Neither;
}
}
}
return betterType;
}
public SymFactory GetSymFactory()
{
return _symFactory;
}
public MiscSymFactory GetMiscSymFactory()
{
return _miscSymFactory;
}
private void InitPreLoad()
{
for (int i = 0; i < 124; i++) {
NamespaceSymbol parent = GetRootNS();
string name = PredefinedTypeFacts.GetName((PredefinedType)i);
string text;
for (int j = 0; j < name.Length; j += text.Length + 1) {
int num = name.IndexOf('.', j);
if (num == -1)
break;
text = ((num > j) ? name.Substring(j, num - j) : name.Substring(j));
Name name2 = GetNameManager().Add(text);
NamespaceSymbol namespaceSymbol = LookupGlobalSymCore(name2, parent, symbmask_t.MASK_NamespaceSymbol).AsNamespaceSymbol();
parent = ((namespaceSymbol != null) ? namespaceSymbol : _symFactory.CreateNamespace(name2, parent));
}
}
}
public Symbol LookupGlobalSymCore(Name name, ParentSymbol parent, symbmask_t kindmask)
{
return tableGlobal.LookupSym(name, parent, kindmask);
}
public Symbol LookupAggMember(Name name, AggregateSymbol agg, symbmask_t mask)
{
return tableGlobal.LookupSym(name, agg, mask);
}
public static Symbol LookupNextSym(Symbol sym, ParentSymbol parent, symbmask_t kindmask)
{
for (sym = sym.nextSameName; sym != null; sym = sym.nextSameName) {
if ((kindmask & sym.mask()) > (symbmask_t)0)
return sym;
}
return null;
}
public Name GetNameFromPtrs(object u1, object u2)
{
if (u2 != null)
return m_nameTable.Add(string.Format(CultureInfo.InvariantCulture, "{0:X}-{1:X}", u1.GetHashCode(), u2.GetHashCode()));
return m_nameTable.Add(string.Format(CultureInfo.InvariantCulture, "{0:X}", u1.GetHashCode()));
}
public AssemblyQualifiedNamespaceSymbol GetNsAid(NamespaceSymbol ns, KAID aid)
{
Name nameFromPtrs = GetNameFromPtrs(aid, 0);
AssemblyQualifiedNamespaceSymbol assemblyQualifiedNamespaceSymbol = LookupGlobalSymCore(nameFromPtrs, ns, symbmask_t.MASK_AssemblyQualifiedNamespaceSymbol).AsAssemblyQualifiedNamespaceSymbol();
if (assemblyQualifiedNamespaceSymbol == null)
assemblyQualifiedNamespaceSymbol = _symFactory.CreateNamespaceAid(nameFromPtrs, ns, aid);
return assemblyQualifiedNamespaceSymbol;
}
public TypeArray AllocParams(int ctype, CType[] prgtype)
{
if (ctype == 0)
return s_taEmpty;
return AllocParams(prgtype);
}
public TypeArray AllocParams(int ctype, TypeArray array, int offset)
{
CType[] sourceArray = array.ToArray();
CType[] array2 = new CType[ctype];
Array.ConstrainedCopy(sourceArray, offset, array2, 0, ctype);
return AllocParams(array2);
}
public TypeArray AllocParams(params CType[] types)
{
if (types == null || types.Length == 0)
return s_taEmpty;
TypeArrayKey key = new TypeArrayKey(types);
if (!tableTypeArrays.TryGetValue(key, out TypeArray value)) {
value = new TypeArray(types);
tableTypeArrays.Add(key, value);
}
return value;
}
public TypeArray ConcatParams(CType[] prgtype1, CType[] prgtype2)
{
CType[] array = new CType[prgtype1.Length + prgtype2.Length];
Array.Copy(prgtype1, 0, array, 0, prgtype1.Length);
Array.Copy(prgtype2, 0, array, prgtype1.Length, prgtype2.Length);
return AllocParams(array);
}
public TypeArray ConcatParams(TypeArray pta1, TypeArray pta2)
{
return ConcatParams(pta1.ToArray(), pta2.ToArray());
}
}
}