Experiments/Attic/Rook/Castle.Rook.Compiler/AST/SymbolTable.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Rook.Compiler.AST
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20
  21
  22         public sealed class SymbolTable : ISymbolTable
  23         {
  24                 private readonly ISymbolTable parent;
  25
  26                 private ScopeType scopeType;
  27
  28                 private IDictionary identifierMap = new HybridDictionary();
  29                 private IDictionary methodMap = new HybridDictionary();
  30
  31
  32                 public SymbolTable()
  33                 {
  34                 }
  35
  36                 public SymbolTable(ISymbolTable parent, ScopeType scopeType)
  37                 {
  38                         this.parent = parent;
  39                         this.scopeType = scopeType;
  40                 }
  41
  42                 public bool IsDefined(String name)
  43                 {
  44                         if (name == null) throw new ArgumentNullException("name");
  45
  46                         return IsIdentifierDefined(name) || IsMethodDefined(name);
  47                 }
  48
  49                 public bool IsDefinedRecursive(String name)
  50                 {
  51                         if (name == null) throw new ArgumentNullException("name");
  52
  53                         return (!IsDefined(name) && parent != null) ?
  54                                 parent.IsDefinedRecursive(name) : false;
  55                 }
  56
  57                 public void AddMethod(MethodDefinitionStatement methodDef)
  58                 {
  59                         if (methodDef == null) throw new ArgumentNullException("methodDef");
  60
  61                         String name = methodDef.Name;
  62
  63                         IList list = null;
  64
  65                         if (!methodMap.Contains(name))
  66                         {
  67                                 list = new ArrayList();
  68                                 methodMap[name] = list;
  69                         }
  70                         else
  71                         {
  72                                 list = (IList) methodMap[name];
  73                         }
  74
  75                         list.Add(methodDef);
  76                 }
  77
  78                 public void AddIdentifier(Identifier identifier)
  79                 {
  80                         if (identifier == null) throw new ArgumentNullException("identifier");
  81
  82                         String name = identifier.Name;
  83
  84                         if (name == null) throw new ArgumentNullException("identifier.name");
  85
  86                         if (identifierMap.Contains(name))
  87                         {
  88                                 throw new Exception(name + " is already defined within this scope");
  89                         }
  90
  91                         identifierMap[name] = identifier;
  92                 }
  93
  94                 public Identifier GetIdentifier(String name)
  95                 {
  96                         if (IsIdentifierDefined(name))
  97                         {
  98                                 return (Identifier) identifierMap[name];
  99                         }
 100
 101                         throw new Exception(name + " is not defined on this scope");
 102                 }
 103
 104                 public MethodDefinitionStatement GetMethod(String name)
 105                 {
 106                         if (name == null) throw new ArgumentNullException("name");
 107
 108                         if (IsMethodDefined(name))
 109                         {
 110                                 IList list = (IList) methodMap[name];
 111                                 return list[0] as MethodDefinitionStatement;
 112                         }
 113
 114                         throw new Exception(name + " is not defined on this scope");
 115                 }
 116
 117                 public MethodDefinitionStatement[] GetMethods(String name)
 118                 {
 119                         if (name == null) throw new ArgumentNullException("name");
 120
 121                         if (IsMethodDefined(name))
 122                         {
 123                                 IList list = (IList) methodMap[name];
 124                                 Array array = Array.CreateInstance( typeof(MethodDefinitionStatement), list.Count );
 125                                 list.CopyTo( array, 0 );
 126                                 return (MethodDefinitionStatement[]) array;
 127                         }
 128
 129                         throw new Exception(name + " is not defined on this scope");
 130                 }
 131
 132                 public ISymbolTable Parent
 133                 {
 134                         get { return parent; }
 135                 }
 136
 137                 public ScopeType ScopeType
 138                 {
 139                         get { return scopeType; }
 140                 }
 141
 142                 private bool IsIdentifierDefined(String name)
 143                 {
 144                         return identifierMap.Contains(name);
 145                 }
 146
 147                 private bool IsMethodDefined(String name)
 148                 {
 149                         return methodMap.Contains(name);
 150                 }
 151         }
 152 }