public SymbolNode EnterNew(string name, SymbolType type, SymbolScope scope)
{
var child = new SymbolNode(this, name, type, scope);
Children.Add(name, child);
return(child);
}
public int EnterNamespace(string ns)
{
if (ns == null || ns == "")
{
return(0);
}
var parts = ns.Split('.');
var count = 0;
foreach (var part in parts)
{
if (part == "")
{
Exit(count);
throw new ArgumentException("The given namespace was invalid", "ns");
}
if (!Current.Children.TryGetValue(part, out var symbol))
{
Current = Current.EnterNew(part, SymbolType.Namespace);
}
else if (!symbol.IsLeaf)
{
Current = (SymbolNode)symbol;
}
else
{
Exit(count);
throw new Backend.NameConflictException($"Could not enter the namespace {ns}. Part {part} had a name conflict with symbol {symbol}");
}
count++;
}
return(count);
}
public SymbolNode(SymbolNode parent, string name, SymbolType type, SymbolScope scope)
{
Parent = parent;
Name = name;
Type = type;
Scope = scope;
}
public SymbolLeaf(SymbolNode parent, string name, SymbolType type, SymbolScope scope)
{
Parent = parent ?? throw new ArgumentNullException(nameof(parent));
Name = name ?? throw new ArgumentNullException(nameof(name));
Type = type;
Scope = scope;
}
/// <summary>
/// Exits the current scope, moving up to its parent.
/// </summary>
public void Exit()
{
if (Current.Parent != null)
{
Current = Current.Parent;
}
}
public bool TryEnterNew(string scopeName, SymbolType type, SymbolScope scope)
{
if (!Current.Children.TryGetValue(scopeName, out var symbol))
{
Current = Current.EnterNew(scopeName, type, scope);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Enters an existing scope.
/// </summary>
/// <param name="scopeName">The name of the scope to enter.</param>
public void Enter(string scopeName)
{
var symbol = Current.Children[scopeName];
if (!symbol.IsLeaf)
{
Current = (SymbolNode)symbol;
}
else
{
throw new InvalidOperationException($"Could not enter scope {scopeName}. Was a leaf node.");
}
}
public ObjectSymbol(SymbolNode parent, string name)
: base(parent, name, SymbolType.Object)
{
}
public ImportObjectLeaf(SymbolNode parent, string name, ImportObjectNode importObject)
: base(parent, name, SymbolType.Object, SymbolScope.Global)
{
ImportObject = importObject;
}
public SymbolNode(SymbolNode parent, string name, SymbolType type)
: this(parent, name, type, SymbolScope.Global)
{
}
public EnumLeaf(SymbolNode parent, string name, SymbolType type, SymbolScope scope, long value) : base(parent, name, type, scope)
{
Value = value;
}
public void EnterNew(string scopeName, SymbolType type, SymbolScope scope)
{
Current = Current.EnterNew(scopeName, type, scope);
}
public SymbolTable()
{
Current = new SymbolNode(null, "__0Root", SymbolType.Block);
}
public void RemoveSymbolFromDefinitionLookup(SymbolNode node)
{
_others.Remove(node);
}
public void AddSymbolToDefinitionLookup(SymbolNode node)
{
_others.Add(node);
}
public ImportLeaf(SymbolNode parent, string name, SymbolScope scope, ImportScriptNode node)
: base(parent, name, SymbolType.Script, scope)
{
Node = node;
}
public bool TryResolveNamespace(MemberAccessNode node, out ISyntaxElement resolved, out SymbolNode namespaceNode)
{
if (node.Left is ISyntaxToken token && _table.Defined(token.Name, out var symbol) && symbol.Type == SymbolType.Namespace)
{
namespaceNode = (SymbolNode)symbol;
resolved = node.Right;
return(true);
}
public VariableLeaf(SymbolNode parent, string name, SymbolScope scope)
: base(parent, name, SymbolType.Variable, scope)
{
}
