public Namespace(Namespace parent, MemberName name)
{
Parent = parent;
MemberName = name;
childNamespaces = new List<Namespace>();
types = new List<TypeDef>();
}
protected FieldDef(Namespace ns, string name, Modifier modifiers)
: base(
null,
(ns is GlobalRootNamespace
? new MemberName(name)
: new MemberName(ns.MemberName, Separators.DoubleColon, name)), modifiers)
{
}
public NamespaceEntry(Namespace ns)
{
Name = ns.Name;
Children = new List<NamespaceEntry>();
FileNamespaceEntries = new List<FileNamespaceEntry>();
Namespace = ns;
}
public TypeDef(Namespace ns, string name, MemberName baseClass, MemberName[] inplements, Modifier modifiers)
: base(
null,
(ns is GlobalRootNamespace ? new MemberName(name) : new MemberName(ns.MemberName, Separators.Dot, name)),
modifiers)
{
Initialize(baseClass, inplements);
Namespace = ns;
ns.AddType(this);
}
//public void ResolveNestedTypes()
//{
// this.RootNamespace.ResolveNestedTypes();
//}
private IEnumerable<TypeDef> getTypes(Namespace ns)
{
return ns.Types.Union(ns.ChildNamespaces.SelectMany(x => getTypes(x)));
}
public ClassStructOrModuleDef(Namespace ns, string name, MemberName baseClass, MemberName[] inherits,
Modifier modifiers)
: base(ns, name, baseClass, inherits, modifiers)
{
}
public EnumDef(Namespace ns, string name, MemberName baseClass, MemberName[] inherits, Modifier modifiers)
: base(ns, name, baseClass, inherits, modifiers)
{
}
public void AddNamespace(Namespace ns)
{
childNamespaces.Add(ns);
}
private void OpenNamespace(Namespace ns)
{
NamespaceEntry entry = namespaceEntry.Children.Find(x => x.Name == ns.Name);
if (entry == null)
{
namespaceEntry = new NamespaceEntry(ns, namespaceEntry);
}
else
{
namespaceEntry = entry;
}
fileNamespaceEntry = new FileNamespaceEntry(namespaceEntry, fileNamespaceEntry, string.Empty, fileEntry);
}
private void ParseNamespace()
{
TokenInfo token, token2;
token = default(TokenInfo);
token2 = default(TokenInfo);
bool flag = false;
Modifier modifiers;
token = tokenQueue.Dequeue();
modifiers = ParseModuleModifiers();
flag = Expect(Token.Identifier, ref token2);
ns = new RootNamespace(ns, token2.Value);
OpenNamespace(ns);
//TokenInfo token = tokenQueue.Dequeue();
//Report.AddError("?", "Namespaces are not yet supported by the compiler.", Tokenizer.SourceFile,
// new SourceSpan(token.GetSourceLocation(), default(SourceLocation)), null);
TokenList symbols = statementSymbols;
ExpectEndOfStatementOrEat();
flag = ParseNamespaceMembers();
if (!flag)
{
Report.AddItem(VBErrors.ModuleStatementMustEndWithAMatchingEndModule, SourceFile, token.GetSpan(token2),
symbols);
}
CloseNamespace();
}
private void initialize()
{
//Stacks
operatorStack = new Stack<Operator>();
modifierStack = new Stack<Modifier>();
tokenQueue = new Queue<TokenInfo>();
//Tree
GlobalNamespace = RootContext.Module.RootNamespace;
NamespaceEntryRoot = RootContext.Module.RootNamespaceEntry;
//ParserContext
ns = GlobalNamespace;
namespaceEntry = NamespaceEntryRoot;
//Statement symbols
statementSymbols = new TokenList();
}
private Namespace CloseNamespace()
{
//if (fileNamespaceEntry.Parent == null)
// throw new InternalCompilerException("");
if (namespaceEntry.Parent == null)
{
namespaceEntry = null;
}
else
{
namespaceEntry = namespaceEntry.Parent;
}
Namespace ns = this.ns;
this.ns = this.ns.Parent;
return ns;
}
public static ITypeDefinition ResolveType(Namespace ns, string typeName)
{
return ResolveType(ns.Name + '.' + typeName);
}
public NamespaceEntry(Namespace ns, NamespaceEntry parent)
: this(ns)
{
Parent = parent;
Parent.Children.Add(this);
}
private IEnumerable<MethodDef> GetMethodDefs(Namespace ns)
{
var methods = new List<MethodDef>();
foreach (TypeDef t in ns.Types)
{
foreach (MethodDef m in t.Methods)
{
methods.Add(m);
}
//Properties
}
foreach (Namespace t in ns.ChildNamespaces)
{
methods.AddRange(GetMethodDefs(t));
}
return methods;
}
