C# SymbolTable.Scope類代碼示例

 public override SymbolInfo FindOnlyInType(string name, Scope CurrentScope)
 {
     SymbolInfo si = SymbolTable.FindOnlyInType(this, name, CurrentScope);
     if (PartialScope != null)
     {
         if (si == null)
             si = SymbolTable.FindOnlyInType(PartialScope, name, CurrentScope);
         else
         {
             SymbolInfo tmp_si = si;
             while (tmp_si.Next != null)
                 tmp_si = tmp_si.Next;
             tmp_si.Next = SymbolTable.FindOnlyInType(PartialScope, name, CurrentScope);
         }
     }
     if (si == null) return si;
     PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbols(si, name);
     return si;
 }

 public SymbolInfo Find(Scope scope, string Name, Scope FromScope)
 {
     return FindAll(scope, Name, false, false, FromScope);
 }

		private SymbolInfo AddToSymbolInfo(SymbolInfo to,SymbolInfo si,Scope scope)
		{
			if(si!=null)
				if(IsNormal(to,si))	
				{
					to.Next=si;si.Next=null;
					LastScope=scope;
					return si;
				}
			LastScope=scope;
			return to;	
		}

		private SymbolInfo FindAllInAreaList(SymbolInfo si,string name,Scope[] arr,AreaNodesList AreaNodes, bool StopIfFind, SymbolInfo FirstInfo)
		{
			if (arr==null) return si;
			int p;
            SymbolInfo sib=si;
            HashSet<Assembly> assm_cache = new HashSet<Assembly>();
			foreach(Scope sc in arr)
			{
                if (sc is DotNETScope)
                {
                    if (sc is PascalABCCompiler.NetHelper.NetScope)
                    {
                        PascalABCCompiler.NetHelper.NetScope netScope = sc as PascalABCCompiler.NetHelper.NetScope;
                        if (PascalABCCompiler.NetHelper.NetHelper.PABCSystemType == null || netScope.Assembly != PascalABCCompiler.NetHelper.NetHelper.PABCSystemType.Assembly)
                        {
                            if (!assm_cache.Contains(netScope.Assembly))
                                assm_cache.Add(netScope.Assembly);
                            else if (netScope.used_namespaces.Count == 0)
                                continue;
                        }
                    }
                    si = AddToSymbolInfo(si, (DotNETScope)sc, name);
                    if (sib.Next != null && StopIfFind)
                        return si;
                }
                else
                if (AreaNodes != null && sc != null)
                {
                    p = AreaNodes.IndexOf(sc.ScopeNum);
                    if (p >= 0)
                    {
                        si = AddToSymbolInfo(si, AreaNodes[p].InfoList, sc, FirstInfo);
                        if (sib.Next != null && StopIfFind)
                            return si;
                    }
                }
			}
			return si;
		}

 private bool IsInOneModule(Scope Scope1, Scope Scope2)
 {
     Scope1 = FindUnitInterfaceScope(Scope1);
     Scope2 = FindUnitInterfaceScope(Scope2);
     return (Scope1 != null) && (Scope2 != null) && (Scope1.ScopeNum == Scope2.ScopeNum);
 }

 private bool IsVisible(SymbolInfo ident, Scope fromScope)
 {
     if (fromScope == null) 
         return true;
     if (FindClassScope(ident.scope) == null)
         return true;
     switch (ident.access_level)
     {
         case access_level.al_public:
         case access_level.al_internal:
             return true;
         case access_level.al_protected:
             return IsInOneModule(ident.scope, fromScope) || IsInOneOrDerivedClass(ident.scope, fromScope);
         case access_level.al_private:
             return IsInOneModule(ident.scope, fromScope);
     }
     return true;
 }

		public ClassScope CreateClassScope(Scope TopScope,Scope BaseClass)
		{
            return new ClassScope(this, TopScope, BaseClass);	
		}

 public InterfaceScope CreateInterfaceScope(Scope TopScope, Scope BaseClass, Scope[] TopInterfaces)
 {
     return new InterfaceScope(this, TopScope, BaseClass, TopInterfaces);
 }

		public LambdaScope CreateLambdaScope(Scope TopScope) //lroman//
        {
            return new LambdaScope(this, TopScope);
        }

		public Scope CreateScope(Scope TopScope)
		{
			return new Scope(this,TopScope);
		}

		public ClassMethodScope(DSSymbolTable vSymbolTable,Scope TopScope,Scope MyClass):
			base(vSymbolTable,TopScope)
		{
			MyClassNum=-2;
			if (MyClass!=null) 
				MyClassNum=MyClass.ScopeNum;
		}

 public InterfaceScope(DSSymbolTable vSymbolTable, Scope TopScope, Scope BaseClassScope, Scope[] vTopInterfaceScopeArray)
     :
     base(vSymbolTable, TopScope, BaseClassScope)
 {
     _TopInterfaceScopeArray = vTopInterfaceScopeArray;
 }

 private Scope FindUnitInterfaceScope(Scope scope)
 {
     while (scope!=null && !(scope is UnitInterfaceScope))
         scope = scope.TopScope;
     return scope;
 }

        //\ssyy
        public UnitInterfaceScope CreateUnitInterfaceScope(Scope[] UsedUnits)
		{
			return new UnitInterfaceScope(this,null,UsedUnits);
		}

 private Scope FindClassScope(Scope scope)
 {
     while (scope != null && !(scope is ClassScope))
         if(scope is ClassMethodScope)
             scope = ((ClassMethodScope)scope).MyClass;
         else
             scope = scope.TopScope;
     return scope;
 }