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;
 }

		public UnitImplementationScope CreateUnitImplementationScope(Scope InterfaceScope,Scope[] UsedUnits)
		{
			return new UnitImplementationScope(this,InterfaceScope,UsedUnits);
		}

 private bool IsInOneOrDerivedClass(Scope IdentScope, Scope FromScope)
 {
     IdentScope = FindClassScope(IdentScope);
     FromScope = FindClassScope(FromScope);
     while (FromScope != null)
     {
         if (IdentScope.ScopeNum == FromScope.ScopeNum)
             return true;
         if (FromScope is ClassScope)
             FromScope = ((ClassScope)FromScope).BaseClassScope;
         else
             FromScope = ((PascalABCCompiler.NetHelper.NetTypeScope)FromScope).TopScope;
     }
     return false;
     
 }

		public ClassMethodScope CreateClassMethodScope(Scope TopScope,Scope MyClass)
		{
			return new ClassMethodScope(this,TopScope,MyClass);
		}

		//возвращает номер верхней области видимости относительно
		//области Scope
		public Scope GetTopScope(Scope scope)
		{
			//DEBUG
#if (DEBUG)
			if ((scope.TopScopeNum>=ScopeTable.Count)|(scope.TopScopeNum<0)) throw new Exception("Ошибка при взятии верхней области видимости: область с номером "+scope.ScopeNum+" не существует");
#endif
            return ScopeTable[scope.TopScopeNum];
		}

		//Возвращает количество уровней на которые надо поднятся начиная с Down чтобы очутиться в Up
		//Работает только для процедур. Модуль считает за одно Scope
		public int GetRelativeScopeDepth(Scope Up,Scope Down)
		{
			if (Up==Down) return 0;
			int depth=0;
			while(Down.TopScopeNum>=0)
			{
				if (Up==Down) return depth;
				if(!(Down is UnitImplementationScope))
					depth++;
				Down=Down.TopScope;
			}
			//throw new Exception("Can not execute st depth");
			return -1;
		}