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) { }