1192 lines
45 KiB
C#
1192 lines
45 KiB
C#
// Copyright (c) Ivan Bondarev, Stanislav Mihalkovich (for details please see \doc\copyright.txt)
|
||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
||
using System;
|
||
using System.Collections;
|
||
using PascalABCCompiler.TreeConverter;
|
||
using System.Collections.Generic;
|
||
using SymbolTable;
|
||
using System.Reflection;
|
||
|
||
namespace PascalABCCompiler.TreeRealization
|
||
{
|
||
public abstract class BasePCUReader
|
||
{
|
||
public abstract definition_node CreateInterfaceMember(int offset, string name);
|
||
public static void RestoreSymbolsInterfaceMember(SymbolInfo si, string name)
|
||
{
|
||
while (si != null)
|
||
{
|
||
if (si.sym_info!=null)
|
||
if (si.sym_info.semantic_node_type == PascalABCCompiler.TreeRealization.semantic_node_type.wrap_def)
|
||
{
|
||
PascalABCCompiler.TreeRealization.wrapped_definition_node wdn = (PascalABCCompiler.TreeRealization.wrapped_definition_node)si.sym_info;
|
||
si.sym_info = wdn.PCUReader.CreateInterfaceMember(wdn.offset, name);
|
||
}
|
||
si = si.Next;
|
||
}
|
||
}
|
||
|
||
|
||
public abstract definition_node CreateInterfaceInClassMember(int offset, string name);
|
||
public abstract definition_node CreateImplementationMember(int offset, bool restore_code=true);
|
||
public abstract definition_node CreateTypeSynonim(int offset, string name);
|
||
public static void RestoreSymbols(SymbolInfo si, string name)
|
||
{
|
||
while (si != null)
|
||
{
|
||
if (si.sym_info != null)
|
||
if (si.sym_info.semantic_node_type == PascalABCCompiler.TreeRealization.semantic_node_type.wrap_def)
|
||
{
|
||
PascalABCCompiler.TreeRealization.wrapped_definition_node wdn = (PascalABCCompiler.TreeRealization.wrapped_definition_node)si.sym_info;
|
||
RestoreSymbols(si, wdn, name);
|
||
}
|
||
si = si.Next;
|
||
}
|
||
}
|
||
|
||
|
||
static void RestoreSymbols(SymbolInfo si, PascalABCCompiler.TreeRealization.wrapped_definition_node wdn, string name)
|
||
{
|
||
if (wdn.is_synonim)
|
||
si.sym_info = wdn.PCUReader.CreateTypeSynonim(wdn.offset, name);
|
||
else
|
||
if (si.scope is ClassScope)
|
||
si.sym_info = wdn.PCUReader.CreateInterfaceInClassMember(wdn.offset, name);
|
||
else
|
||
si.sym_info = wdn.PCUReader.CreateImplementationMember(wdn.offset, false);
|
||
}
|
||
|
||
}
|
||
|
||
/*public class PCUReturner
|
||
{
|
||
private static Hashtable ht = new Hashtable();
|
||
|
||
public static void Clear()
|
||
{
|
||
ht.Clear();
|
||
}
|
||
|
||
public static BasePCUReader GetPCUReader(PascalABCCompiler.TreeRealization.wrapped_definition_node wdn)
|
||
{
|
||
return (BasePCUReader)ht[wdn];
|
||
}
|
||
|
||
public static void AddPCUReader(PascalABCCompiler.TreeRealization.wrapped_definition_node wdn, BasePCUReader pr)
|
||
{
|
||
ht[wdn] = pr;
|
||
}
|
||
|
||
}*/
|
||
|
||
public class wrapped_definition_node : definition_node
|
||
{
|
||
public int offset;
|
||
public bool is_synonim;
|
||
public BasePCUReader PCUReader;
|
||
|
||
public wrapped_definition_node(int offset, BasePCUReader PCUReader)
|
||
{
|
||
this.offset = offset;
|
||
this.PCUReader = PCUReader;
|
||
}
|
||
|
||
public override general_node_type general_node_type
|
||
{
|
||
get
|
||
{
|
||
return general_node_type.unit_node;
|
||
}
|
||
}
|
||
|
||
public override semantic_node_type semantic_node_type
|
||
{
|
||
get
|
||
{
|
||
return semantic_node_type.wrap_def;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
namespace SymbolTable
|
||
{
|
||
|
||
#region SymbolTableConstants набор констант определяющих поведение таблицы символов
|
||
public class SymbolTableConstants
|
||
{
|
||
//стартовый размер списка областей видимости
|
||
public const int AreaList_StartSize=8;
|
||
//во сколько раз расширять список областей видимости
|
||
public const int AreaList_ResizeParam=2;
|
||
|
||
//стартовый размер списка информаций о символах
|
||
public const int InfoList_StartSize=1;
|
||
|
||
//рекомендуемый стартовый размер хештаблицы
|
||
public const int HashTable_StartSize=8192;
|
||
|
||
//параметры поведения хеш таблицы
|
||
public const int HashTable_StartResise=85; //Расширить хеш на ProcResize процентов,
|
||
public const int HashTable_ProcResize =100;//если он заполнен на StartResize процентов
|
||
|
||
public const int SymbolNotFound=-1;
|
||
}
|
||
#endregion
|
||
|
||
#region Scope,DotNETScope,UnitPartScope,UnitInterfaceScope,UnitImplementationScope,ClassScope элемены таблицы областей видимости
|
||
//элемент таблицы областей видимости
|
||
//при создании добавляет себя в vSymbolTable
|
||
public class Scope:BaseScope
|
||
{
|
||
public DSSymbolTable SymbolTable;
|
||
public bool CaseSensitive;
|
||
public int TopScopeNum;
|
||
public bool AddStatementsToFront = false; // SSM - введено для необходимости добавлять statements не только в конец statement_list, но и в начало. Нужно для синтаксически сахарных конструкций: например, для создания объекта класса при замыканиях
|
||
public Scope TopScope
|
||
{
|
||
get
|
||
{
|
||
if(TopScopeNum>=0)
|
||
return SymbolTable.ScopeTable[TopScopeNum];
|
||
else
|
||
return null;
|
||
}
|
||
}
|
||
//public Scope()
|
||
//{
|
||
//}
|
||
public int ScopeNum;
|
||
public Scope(DSSymbolTable vSymbolTable, Scope TopScope)
|
||
{
|
||
SymbolTable=vSymbolTable;
|
||
TopScopeNum=-1;
|
||
if (TopScope!=null)
|
||
TopScopeNum=TopScope.ScopeNum;
|
||
ScopeNum = SymbolTable.ScopeTable.Count;
|
||
SymbolTable.ScopeTable.Add(this);
|
||
this.CaseSensitive = SemanticRules.SymbolTableCaseSensitive;
|
||
}
|
||
public Scope(DSSymbolTable vSymbolTable, Scope TopScope, bool CaseSensetive)
|
||
{
|
||
SymbolTable = vSymbolTable;
|
||
TopScopeNum = -1;
|
||
if (TopScope != null)
|
||
TopScopeNum = TopScope.ScopeNum;
|
||
ScopeNum = SymbolTable.ScopeTable.Count;
|
||
SymbolTable.ScopeTable.Add(this);
|
||
this.CaseSensitive = CaseSensetive;
|
||
}
|
||
public virtual SymbolInfo Find(string name)
|
||
{
|
||
return Find(name, null);
|
||
}
|
||
public virtual SymbolInfo Find(string name, Scope CurrentScope)
|
||
{
|
||
SymbolInfo si = SymbolTable.Find(this, name, CurrentScope);
|
||
if (si == null) return si;
|
||
PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbols(si, name);
|
||
return si;
|
||
}
|
||
public virtual SymbolInfo FindOnlyInScopeAndBlocks(string name)
|
||
{
|
||
return SymbolTable.FindOnlyInScope(this, name, true);
|
||
}
|
||
public virtual SymbolInfo FindOnlyInScope(string name)
|
||
{
|
||
return SymbolTable.FindOnlyInScope(this, name, false);
|
||
}
|
||
public virtual SymbolInfo FindOnlyInType(string name, Scope CurrentScope)
|
||
{
|
||
SymbolInfo si = SymbolTable.FindOnlyInType(this, name, CurrentScope);
|
||
if (si == null) return si;
|
||
PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbols(si, name);
|
||
return si;
|
||
}
|
||
public void AddSymbol(string Name,SymbolInfo Inf)
|
||
{
|
||
SymbolTable.Add(this,Name,Inf);
|
||
}
|
||
}
|
||
|
||
public class BlockScope : Scope
|
||
{
|
||
public BlockScope(DSSymbolTable vSymbolTable, Scope TopScope)
|
||
: base(vSymbolTable, TopScope)
|
||
{
|
||
}
|
||
}
|
||
|
||
public class LambdaScope : Scope //lroman//
|
||
{
|
||
public LambdaScope(DSSymbolTable vSymbolTable, Scope TopScope)
|
||
: base(vSymbolTable, TopScope)
|
||
{
|
||
}
|
||
}
|
||
|
||
public class WithScope : BlockScope
|
||
{
|
||
public Scope[] WithScopes;
|
||
public WithScope(DSSymbolTable vSymbolTable, Scope TopScope, Scope[] WithScopes)
|
||
: base(vSymbolTable, TopScope)
|
||
{
|
||
this.WithScopes = WithScopes;
|
||
}
|
||
}
|
||
|
||
public class DotNETScope:Scope
|
||
{
|
||
public DotNETScope(DSSymbolTable vSymbolTable):base(vSymbolTable,null,false)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
public class UnitPartScope:Scope
|
||
{
|
||
public Scope[] TopScopeArray;
|
||
public UnitPartScope(DSSymbolTable vSymbolTable,Scope TopScope,Scope[] vTopScopeArray):
|
||
base(vSymbolTable,TopScope)
|
||
{
|
||
TopScopeArray=vTopScopeArray;
|
||
}
|
||
}
|
||
public class UnitInterfaceScope:UnitPartScope
|
||
{
|
||
public UnitInterfaceScope(DSSymbolTable vSymbolTable,Scope TopScope,Scope[] vTopScopeArray):
|
||
base(vSymbolTable,TopScope,vTopScopeArray)
|
||
{
|
||
}
|
||
}
|
||
public class UnitImplementationScope:UnitPartScope
|
||
{
|
||
public UnitImplementationScope(DSSymbolTable vSymbolTable, Scope TopScope, Scope[] vTopScopeArray)
|
||
:
|
||
base(vSymbolTable,TopScope,vTopScopeArray)
|
||
{}
|
||
}
|
||
public class ClassScope:Scope
|
||
{
|
||
public int BaseClassScopeNum;
|
||
public ClassScope PartialScope;
|
||
|
||
public Scope BaseClassScope
|
||
{
|
||
get
|
||
{
|
||
if (BaseClassScopeNum>=0)
|
||
return SymbolTable.ScopeTable[BaseClassScopeNum];
|
||
else
|
||
return null;
|
||
|
||
}
|
||
//TODO: Kolya add this set accessor
|
||
//Ask for Alexander
|
||
set
|
||
{
|
||
if (value == null)
|
||
{
|
||
BaseClassScopeNum = -2;
|
||
return;
|
||
}
|
||
BaseClassScopeNum=value.ScopeNum;
|
||
}
|
||
}
|
||
public ClassScope(DSSymbolTable vSymbolTable,Scope TopScope,Scope BaseClassScope):
|
||
base(vSymbolTable,TopScope)
|
||
{
|
||
BaseClassScopeNum=-2;
|
||
if (BaseClassScope!=null)
|
||
BaseClassScopeNum=BaseClassScope.ScopeNum;
|
||
}
|
||
|
||
public override SymbolInfo Find(string name, Scope CurrentScope)
|
||
{
|
||
SymbolInfo si = SymbolTable.Find(this, name, CurrentScope);
|
||
if (PartialScope != null)
|
||
{
|
||
if (si == null)
|
||
si = SymbolTable.Find(PartialScope, name, CurrentScope);
|
||
else
|
||
{
|
||
SymbolInfo tmp_si = si;
|
||
while (tmp_si.Next != null)
|
||
tmp_si = tmp_si.Next;
|
||
tmp_si.Next = SymbolTable.Find(PartialScope, name, CurrentScope);
|
||
}
|
||
}
|
||
if (si == null) return si;
|
||
PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbols(si, name);
|
||
return si;
|
||
}
|
||
|
||
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 class GenericTypeInstanceScope : ClassScope
|
||
{
|
||
private PascalABCCompiler.TreeRealization.generic_instance_type_node _instance_type;
|
||
private Scope _orig_scope;
|
||
|
||
public GenericTypeInstanceScope(PascalABCCompiler.TreeRealization.generic_instance_type_node instance_type,
|
||
Scope orig_scope, Scope BaseClassScope)
|
||
: base(orig_scope.SymbolTable, orig_scope.TopScope, BaseClassScope)
|
||
{
|
||
_orig_scope = orig_scope;
|
||
_instance_type = instance_type;
|
||
}
|
||
|
||
public override SymbolInfo Find(string name)
|
||
{
|
||
return _instance_type.ConvertSymbolInfo(_orig_scope.Find(name));
|
||
}
|
||
|
||
public override SymbolInfo Find(string name, Scope CurrentScope)
|
||
{
|
||
return _instance_type.ConvertSymbolInfo(_orig_scope.Find(name, CurrentScope));
|
||
}
|
||
|
||
public override SymbolInfo FindOnlyInScope(string name)
|
||
{
|
||
return _instance_type.ConvertSymbolInfo(_orig_scope.FindOnlyInScope(name));
|
||
}
|
||
|
||
public override SymbolInfo FindOnlyInScopeAndBlocks(string name)
|
||
{
|
||
return _instance_type.ConvertSymbolInfo(_orig_scope.FindOnlyInScopeAndBlocks(name));
|
||
}
|
||
}*/
|
||
|
||
//(ssyy) Интерфейс для интерфейсов
|
||
public interface IInterfaceScope
|
||
{
|
||
Scope[] TopInterfaceScopeArray
|
||
{
|
||
get;
|
||
set;
|
||
}
|
||
}
|
||
|
||
//ssyy owns
|
||
//Область видимости для интерфейсов
|
||
//Наследование от ClassScope сделано для простоты, так как в кодах
|
||
//местами есть проверки (scope is ClassScope)
|
||
public class InterfaceScope : ClassScope, IInterfaceScope
|
||
{
|
||
private Scope[] _TopInterfaceScopeArray;
|
||
public virtual Scope[] TopInterfaceScopeArray
|
||
{
|
||
get
|
||
{
|
||
return _TopInterfaceScopeArray;
|
||
}
|
||
set
|
||
{
|
||
_TopInterfaceScopeArray = value;
|
||
}
|
||
}
|
||
|
||
public InterfaceScope(DSSymbolTable vSymbolTable, Scope TopScope, Scope[] vTopInterfaceScopeArray)
|
||
:
|
||
base(vSymbolTable, TopScope, null)
|
||
{
|
||
_TopInterfaceScopeArray = vTopInterfaceScopeArray;
|
||
}
|
||
|
||
public InterfaceScope(DSSymbolTable vSymbolTable, Scope TopScope, Scope BaseClassScope, Scope[] vTopInterfaceScopeArray)
|
||
:
|
||
base(vSymbolTable, TopScope, BaseClassScope)
|
||
{
|
||
_TopInterfaceScopeArray = vTopInterfaceScopeArray;
|
||
}
|
||
}
|
||
//\ssyy owns
|
||
|
||
public class ClassMethodScope:Scope
|
||
{
|
||
public int MyClassNum;
|
||
public Scope MyClass
|
||
{
|
||
get
|
||
{
|
||
if (MyClassNum>=0)
|
||
return SymbolTable.ScopeTable[MyClassNum];
|
||
else
|
||
return null;
|
||
}
|
||
}
|
||
public ClassMethodScope(DSSymbolTable vSymbolTable,Scope TopScope,Scope MyClass):
|
||
base(vSymbolTable,TopScope)
|
||
{
|
||
MyClassNum=-2;
|
||
if (MyClass!=null)
|
||
MyClassNum=MyClass.ScopeNum;
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region AreaListNode элемент списка областей видимости
|
||
public class AreaListNode
|
||
{
|
||
public int Area;
|
||
public List<SymbolInfo> InfoList;//для перегузки
|
||
public AreaListNode()
|
||
{
|
||
InfoList = new List<SymbolInfo>(SymbolTableConstants.InfoList_StartSize);
|
||
}
|
||
public AreaListNode(int ar,SymbolInfo inf)
|
||
{
|
||
InfoList = new List<SymbolInfo>(SymbolTableConstants.InfoList_StartSize);
|
||
Area=ar;
|
||
InfoList.Add(inf);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region HashTableNode элемент хеш-таблицы
|
||
public class HashTableNode
|
||
{
|
||
public string Name;
|
||
public AreaNodesList NumAreaList;
|
||
public HashTableNode(string name)
|
||
{
|
||
Name=name;
|
||
NumAreaList=new AreaNodesList(SymbolTableConstants.AreaList_StartSize);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
|
||
// Определения
|
||
// ОВ - область видимости
|
||
// ООВ - особая область видимости в стиле delphi.это:
|
||
// - ОВ поцедуры
|
||
// - OВ класса + ОВ предков
|
||
// - ОВ модуля + ОВ интерфейсных частей всех модулей подклюценных к нему
|
||
public class DSSymbolTable
|
||
{
|
||
public List<Scope> ScopeTable;
|
||
private DSHashTable HashTable;
|
||
internal bool CaseSensitive;
|
||
private Scope LastScope;
|
||
//private SymbolInfo FirstInfo;
|
||
private Scope CurrentScope;
|
||
|
||
#region DSSymbolTable(int hash_size,bool case_sensitive)
|
||
public DSSymbolTable(int hash_size,bool case_sensitive)
|
||
{
|
||
CaseSensitive=case_sensitive;
|
||
HashTable=new DSHashTable(hash_size);
|
||
Clear();
|
||
}
|
||
#endregion
|
||
|
||
#region Clear() очистка таблицы
|
||
public void Clear()
|
||
{
|
||
ScopeTable=new List<Scope>();
|
||
HashTable.ClearTable();
|
||
}
|
||
#endregion
|
||
|
||
#region CreateScope для различных Scope
|
||
public LambdaScope CreateLambdaScope(Scope TopScope) //lroman//
|
||
{
|
||
return new LambdaScope(this, TopScope);
|
||
}
|
||
public Scope CreateScope(Scope TopScope)
|
||
{
|
||
return new Scope(this,TopScope);
|
||
}
|
||
public ClassScope CreateClassScope(Scope TopScope,Scope BaseClass)
|
||
{
|
||
return new ClassScope(this, TopScope, BaseClass);
|
||
}
|
||
//ssyy
|
||
public InterfaceScope CreateInterfaceScope(Scope TopScope, Scope[] TopInterfaces)
|
||
{
|
||
return new InterfaceScope(this, TopScope, TopInterfaces);
|
||
}
|
||
public InterfaceScope CreateInterfaceScope(Scope TopScope, Scope BaseClass, Scope[] TopInterfaces)
|
||
{
|
||
return new InterfaceScope(this, TopScope, BaseClass, TopInterfaces);
|
||
}
|
||
public ClassScope CreateInterfaceOrClassScope(bool is_interface)
|
||
{
|
||
if (is_interface)
|
||
{
|
||
return CreateInterfaceScope(null, null);
|
||
}
|
||
else
|
||
{
|
||
return CreateClassScope(null, null);
|
||
}
|
||
}
|
||
//\ssyy
|
||
public UnitInterfaceScope CreateUnitInterfaceScope(Scope[] UsedUnits)
|
||
{
|
||
return new UnitInterfaceScope(this,null,UsedUnits);
|
||
}
|
||
public UnitImplementationScope CreateUnitImplementationScope(Scope InterfaceScope,Scope[] UsedUnits)
|
||
{
|
||
return new UnitImplementationScope(this,InterfaceScope,UsedUnits);
|
||
}
|
||
public ClassMethodScope CreateClassMethodScope(Scope TopScope,Scope MyClass)
|
||
{
|
||
return new ClassMethodScope(this,TopScope,MyClass);
|
||
}
|
||
#endregion
|
||
|
||
//возвращает номер верхней области видимости относительно
|
||
//области 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];
|
||
}
|
||
public int GetTopScopeNum(int scope)
|
||
{
|
||
//DEBUG
|
||
#if (DEBUG)
|
||
if ((scope>=ScopeTable.Count)|(scope<0)) throw new Exception("Ошибка при взятии верхней области видимости: область с номером "+scope+" не существует");
|
||
#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;
|
||
}
|
||
|
||
//Добавление символа
|
||
//если такой символ в пр-ве имен уже существует то symbol_info добавляется к AreaListNode[].InfoList[]
|
||
public void Add(Scope InScope,string Name,SymbolInfo Inf)
|
||
{
|
||
//int.try
|
||
//{
|
||
Inf.scope = InScope;
|
||
if (!InScope.CaseSensitive) Name = Name.ToLower();
|
||
int hn = HashTable.Add(new HashTableNode(Name));//ЗДЕСь ВОЗНИКАЕТ НЕДЕТЕРМЕНИРОВАНЯ ОШИБКА
|
||
HashTable.hash_arr[hn].NumAreaList.Add(new AreaListNode(InScope.ScopeNum, Inf));
|
||
//}
|
||
// catch (Exception e)
|
||
//{
|
||
// throw e;
|
||
// }
|
||
}
|
||
|
||
|
||
|
||
|
||
//Этот метод ищет ТОЛЬКО В УКАЗАННОЙ ОВ, и не смотрит есть ли имя выше.
|
||
//Если это ОВ типа UnitImplementationScope то имя ищется также и
|
||
//в верней ОВ, которая типа UnitInterfaceScope
|
||
public SymbolInfo FindOnlyInScope(Scope scope,string Name, bool FindInUpperBlocks)
|
||
{
|
||
if (!scope.CaseSensitive) Name = Name.ToLower();
|
||
CurrentScope = null;
|
||
LastScope=null;
|
||
SymbolInfo FirstInfo = new SymbolInfo();
|
||
SymbolInfo info=FirstInfo;
|
||
int Area=scope.ScopeNum;
|
||
int tn=HashTable.Find(Name); //найдем имя в хеше
|
||
if (tn < 0 || scope is DotNETScope)//если нет такого ищем в областях .NET
|
||
{
|
||
Scope an;
|
||
an = ScopeTable[Area];
|
||
if (an is DotNETScope)
|
||
info = AddToSymbolInfo(info, (DotNETScope)an, Name);
|
||
return FirstInfo.Next;
|
||
}
|
||
|
||
AreaNodesList AreaList=HashTable.hash_arr[tn].NumAreaList;
|
||
int CurrentArea=Area,ai,bs;
|
||
do
|
||
{
|
||
if (ScopeTable[CurrentArea] is UnitPartScope) //мы очутились в модуле
|
||
{
|
||
|
||
//мы в ImplementationPart?
|
||
if (ScopeTable[CurrentArea] is UnitImplementationScope)
|
||
{
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
CurrentArea = GetTopScopeNum(CurrentArea);
|
||
}
|
||
//сейча мы в InterfacePart
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
if(FirstInfo.Next!=null)
|
||
return FirstInfo.Next;
|
||
}
|
||
if (ScopeTable[CurrentArea] is WithScope)//мы очутились в Width
|
||
{
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
info = FindAllInAreaList(info, Name, (ScopeTable[CurrentArea] as WithScope).WithScopes, AreaList, true,FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
else
|
||
{
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
{
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
return FirstInfo.Next;
|
||
}
|
||
}
|
||
bs = CurrentArea;
|
||
CurrentArea = GetTopScopeNum(CurrentArea);
|
||
} while (CurrentArea >= 0 && (FindInUpperBlocks && ScopeTable[bs] is BlockScope));
|
||
// } while (CurrentArea >= 0 && ScopeTable[bs] is BlockScope);
|
||
/*if (!CaseSensitive) Name=Name.ToLower();
|
||
int Area=scope.ScopeNum;
|
||
int tn=HashTable.Find(Name);
|
||
if (tn<0) return null;
|
||
int ai=HashTable.hash_arr[tn].NumAreaList.IndexOf(Area);
|
||
CurrentScope = null;
|
||
|
||
if (ScopeTable[Area] is UnitImplementationScope)
|
||
{
|
||
int ai2=HashTable.hash_arr[tn].NumAreaList.IndexOf(ScopeTable[Area].TopScopeNum);
|
||
if ((ai < 0) && (ai2 >= 0))
|
||
//Kolay modified if.
|
||
//return HashTable.hash_arr[tn].NumAreaList[ai2].InfoList[0];
|
||
{
|
||
SymbolInfo si_init = HashTable.hash_arr[tn].NumAreaList[ai2].InfoList[0];
|
||
SymbolInfo si_next = si_init;
|
||
for (int iter = 1; iter < HashTable.hash_arr[tn].NumAreaList[ai2].InfoList.Count; iter++)
|
||
{
|
||
si_next.Next = HashTable.hash_arr[tn].NumAreaList[ai2].InfoList[iter];
|
||
si_next = si_next.Next;
|
||
}
|
||
return si_init;
|
||
}
|
||
if ((ai>=0)&&(ai2>=0))
|
||
{
|
||
SymbolInfo si_int=HashTable.hash_arr[tn].NumAreaList[ai2].InfoList[0];
|
||
SymbolInfo si_impl=HashTable.hash_arr[tn].NumAreaList[ai].InfoList[0];
|
||
|
||
//Kolay modified. All methods searched.
|
||
|
||
//SymbolInfo si_init_interface = HashTable.hash_arr[tn].NumAreaList[ai].InfoList[0];
|
||
SymbolInfo si_next = si_int;
|
||
for (int iter = 1; iter < HashTable.hash_arr[tn].NumAreaList[ai].InfoList.Count; iter++)
|
||
{
|
||
si_next.Next = HashTable.hash_arr[tn].NumAreaList[ai].InfoList[iter];
|
||
si_next = si_next.Next;
|
||
}
|
||
|
||
si_next.Next=si_impl;
|
||
si_next = si_next.Next;
|
||
for (int iter = 1; iter < HashTable.hash_arr[tn].NumAreaList[ai2].InfoList.Count; iter++)
|
||
{
|
||
si_next.Next = HashTable.hash_arr[tn].NumAreaList[ai2].InfoList[iter];
|
||
si_next = si_next.Next;
|
||
}
|
||
|
||
return si_int;
|
||
|
||
|
||
//return it;
|
||
}
|
||
}
|
||
|
||
if (ai >= 0)
|
||
//Kolay modifeds this if.
|
||
//return HashTable.hash_arr[tn].NumAreaList[ai].InfoList[0];
|
||
{
|
||
SymbolInfo si_init = HashTable.hash_arr[tn].NumAreaList[ai].InfoList[0];
|
||
SymbolInfo si_next = si_init;
|
||
for (int iter = 1; iter < HashTable.hash_arr[tn].NumAreaList[ai].InfoList.Count;iter++ )
|
||
{
|
||
si_next.Next = HashTable.hash_arr[tn].NumAreaList[ai].InfoList[iter];
|
||
si_next = si_next.Next;
|
||
}
|
||
//Проверить не чиго ли это не портит!
|
||
PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbolsImplementationMember(si_init, Name);
|
||
return si_init;
|
||
}
|
||
|
||
|
||
* */
|
||
return null;
|
||
|
||
}
|
||
|
||
|
||
|
||
private SymbolInfo FindAllInClass(SymbolInfo si, string name, int ClassArea, AreaNodesList AreaList, bool OnlyInThisClass, SymbolInfo FirstInfo)
|
||
{
|
||
int ai;
|
||
|
||
Scope ar = ScopeTable[ClassArea];
|
||
|
||
if ((ai = AreaList.IndexOf(ClassArea)) >= 0)
|
||
si = AddToSymbolInfo(si, AreaList[ai].InfoList, ar, FirstInfo);
|
||
|
||
if (ar is DotNETScope)
|
||
{
|
||
PascalABCCompiler.TreeRealization.BasePCUReader.RestoreSymbols(si, name);
|
||
return AddToSymbolInfo(si, (DotNETScope)ar, name);
|
||
}
|
||
|
||
ClassScope cl = (ClassScope)ScopeTable[ClassArea];
|
||
|
||
if(!OnlyInThisClass)
|
||
while (cl.BaseClassScopeNum >= 0)
|
||
{
|
||
ai = AreaList.IndexOf(cl.BaseClassScopeNum);
|
||
if (ai >= 0) si = AddToSymbolInfo(si, AreaList[ai].InfoList, cl.BaseClassScope, FirstInfo);
|
||
|
||
//cl=(ClassScope)ScopeTable[cl.BaseClassScopeNum];
|
||
|
||
ar = ScopeTable[cl.BaseClassScopeNum];
|
||
if (ar is DotNETScope)
|
||
return AddToSymbolInfo(si, (DotNETScope)ar, name);
|
||
cl = (ClassScope)ScopeTable[cl.BaseClassScopeNum];
|
||
}
|
||
return si;
|
||
}
|
||
private Scope FindUnitInterfaceScope(Scope scope)
|
||
{
|
||
while (scope!=null && !(scope is UnitInterfaceScope))
|
||
scope = scope.TopScope;
|
||
return scope;
|
||
}
|
||
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;
|
||
}
|
||
|
||
private bool IsInOneModule(Scope Scope1, Scope Scope2)
|
||
{
|
||
Scope1 = FindUnitInterfaceScope(Scope1);
|
||
Scope2 = FindUnitInterfaceScope(Scope2);
|
||
return (Scope1 != null) && (Scope2 != null) && (Scope1.ScopeNum == Scope2.ScopeNum);
|
||
}
|
||
|
||
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;
|
||
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
private bool IsNormal(SymbolInfo to,SymbolInfo add)
|
||
{
|
||
return //true;
|
||
(to.scope == null) || ((to.scope != null) &&
|
||
(((to.symbol_kind==symbol_kind.sk_none)&&(add.symbol_kind==symbol_kind.sk_none))&&(to.scope==add.scope))
|
||
||
|
||
((to.symbol_kind==symbol_kind.sk_overload_function)&&(add.symbol_kind==symbol_kind.sk_overload_function))
|
||
||
|
||
((to.symbol_kind == symbol_kind.sk_overload_procedure) && (add.symbol_kind == symbol_kind.sk_overload_procedure))
|
||
);
|
||
}
|
||
|
||
private bool AlreadyAdded(SymbolInfo si, SymbolInfo FirstInfo)
|
||
{
|
||
if (FirstInfo == null)
|
||
return false;
|
||
while (FirstInfo.Next != null)
|
||
{
|
||
if (FirstInfo.Next == si)
|
||
return true;
|
||
FirstInfo = FirstInfo.Next;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private SymbolInfo AddToSymbolInfo(SymbolInfo to, List<SymbolInfo> from, Scope scope, SymbolInfo FirstInfo)
|
||
{
|
||
bool CheckVisible = CurrentScope != null, NeedAdd = false;
|
||
foreach (SymbolInfo si in from)
|
||
{
|
||
if (CheckVisible)
|
||
NeedAdd = IsVisible(si, CurrentScope) && IsNormal(to, si);
|
||
else
|
||
NeedAdd = IsNormal(to, si);
|
||
if (NeedAdd && !AlreadyAdded(si,FirstInfo))
|
||
{
|
||
to.Next = si;
|
||
si.Next = null;
|
||
to = si;
|
||
}
|
||
}
|
||
LastScope=scope;
|
||
return to;
|
||
}
|
||
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 AddToSymbolInfo(SymbolInfo sito,DotNETScope ar,string name)
|
||
{
|
||
SymbolInfo si=ar.Find(name);
|
||
if(si!=null)
|
||
if (IsNormal(sito, si))
|
||
{
|
||
sito.Next = si;
|
||
return si;
|
||
}
|
||
|
||
return sito;
|
||
}
|
||
private SymbolInfo FindAllInAreaList(SymbolInfo si, string name, Scope[] arr, AreaNodesList AreaNodes,SymbolInfo FirstInfo)
|
||
{
|
||
return FindAllInAreaList(si, name, arr, AreaNodes, false, FirstInfo);
|
||
}
|
||
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;
|
||
}
|
||
//поиск всех имен в ООВ.
|
||
// ищет наборы имен в ООВ, если находит то возвращает их список.
|
||
// иначе ищет в обьемлющем ООВ.
|
||
//SymbolInfo возвращаются в поряде в котором они встретились при проходе областей
|
||
public SymbolInfo Find(Scope scope,string Name)
|
||
{
|
||
return FindAll(scope, Name, false, false, null);
|
||
}
|
||
public SymbolInfo Find(Scope scope, string Name, Scope FromScope)
|
||
{
|
||
return FindAll(scope, Name, false, false, FromScope);
|
||
}
|
||
public SymbolInfo FindOnlyInType(Scope scope, string Name)
|
||
{
|
||
//TODO: Почему ищет везде??? Только в типе и надтипах. А в юните он найдет?
|
||
return FindAll(scope, Name, true, false, null);
|
||
}
|
||
public SymbolInfo FindOnlyInType(Scope scope, string Name, Scope FromScope)
|
||
{
|
||
return FindAll(scope, Name, true, false,FromScope);
|
||
}
|
||
public SymbolInfo FindOnlyInThisClass(ClassScope scope, string Name)
|
||
{
|
||
return FindAll(scope, Name, true, true, null);
|
||
}
|
||
|
||
private SymbolInfo FindAll(Scope scope,string Name,bool OnlyInType,bool OnlyInThisClass, Scope FromScope)
|
||
{
|
||
if(OnlyInType && !(scope is ClassScope) && !(scope is SymbolTable.DotNETScope)) return null;
|
||
//if (!CaseSensitive) Name=Name.ToLower();
|
||
if(!scope.CaseSensitive)
|
||
Name = Name.ToLower();
|
||
CurrentScope = FromScope; //глобальные переменные могут привести к ошибкам при поиске и поторном вызове!
|
||
LastScope = null; //глобальные переменные могут привести к ошибкам при поиске и поторном вызове!
|
||
SymbolInfo FirstInfo = new SymbolInfo();
|
||
SymbolInfo info=FirstInfo;
|
||
int Area=scope.ScopeNum;
|
||
Scope[] used_units=null;
|
||
int tn=HashTable.Find(Name); //найдем имя в хеше
|
||
|
||
// SSM 21.01.16
|
||
if (Name.StartsWith("?")) // это значит, надо искать в областях .NET
|
||
Name = Name.Substring(1); // съели ? и ищем т.к. tn<0
|
||
// end SSM
|
||
|
||
if (tn<0 || scope is DotNETScope)//если нет такого ищем в областях .NET
|
||
{
|
||
//ssyy
|
||
int NextUnitArea = -2;
|
||
//\ssyy
|
||
Scope an;
|
||
while(Area>=0)
|
||
{
|
||
an=ScopeTable[Area];
|
||
if (an is DotNETScope)
|
||
{
|
||
if (tn < 0)
|
||
info = AddToSymbolInfo(info, (DotNETScope)an, Name);
|
||
else
|
||
info = FindAllInClass(info, Name, Area, HashTable.hash_arr[tn].NumAreaList, false, FirstInfo);
|
||
}
|
||
if (FirstInfo.Next != null)
|
||
return FirstInfo.Next;
|
||
if (an is UnitPartScope)
|
||
{
|
||
if (an is UnitImplementationScope)
|
||
{
|
||
info=FindAllInAreaList(info,Name,(an as UnitImplementationScope).TopScopeArray,null,FirstInfo);
|
||
an=ScopeTable[an.TopScopeNum];
|
||
}
|
||
info=FindAllInAreaList(info,Name,(an as UnitInterfaceScope).TopScopeArray,null,FirstInfo);
|
||
if (FirstInfo.Next!=null)
|
||
return FirstInfo.Next;
|
||
}
|
||
if (an is WithScope)//мы очутились в Width
|
||
{
|
||
info = FindAllInAreaList(info, Name, (an as WithScope).WithScopes, null, true,FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
if (an is ClassScope)
|
||
{
|
||
int unit_area=an.TopScopeNum;
|
||
InterfaceScope IntScope = an as InterfaceScope;
|
||
while (((ClassScope)an).BaseClassScopeNum >= 0)
|
||
{
|
||
an=ScopeTable[((ClassScope)an).BaseClassScopeNum];
|
||
if(an is DotNETScope)
|
||
{
|
||
info=AddToSymbolInfo(info,(DotNETScope)an,Name);
|
||
if (FirstInfo.Next != null) // || OnlyInType)
|
||
return FirstInfo.Next;
|
||
break;
|
||
}
|
||
}
|
||
//В предках ничего не нашли, ищем по интерфейсам...
|
||
if (IntScope != null)
|
||
{
|
||
info = FindAllInAreaList(info, Name, IntScope.TopInterfaceScopeArray, null,FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
if (OnlyInType)
|
||
return FirstInfo.Next;
|
||
//ssyy
|
||
if (NextUnitArea > -1)
|
||
{
|
||
Area = NextUnitArea;
|
||
//NextUnitArea = -2;
|
||
continue;
|
||
}
|
||
else
|
||
//\ssyy
|
||
an=ScopeTable[unit_area];
|
||
}
|
||
if (info.Next!=null) return FirstInfo.Next;
|
||
|
||
if (an is ClassMethodScope)
|
||
{
|
||
//ssyy
|
||
NextUnitArea = an.TopScopeNum;
|
||
//\ssyy
|
||
Area=(an as ClassMethodScope).MyClassNum;
|
||
}
|
||
else
|
||
{
|
||
Area=GetTopScopeNum(Area);
|
||
}
|
||
|
||
//Area=GetTopScopeNum(Area);
|
||
}
|
||
return null; //если такого нет то поиск окончен
|
||
}
|
||
|
||
AreaNodesList AreaList=HashTable.hash_arr[tn].NumAreaList;
|
||
int CurrentArea=Area,ai;
|
||
while (CurrentArea>=0)
|
||
{
|
||
if (ScopeTable[CurrentArea] is UnitPartScope) //мы очутились в модуле
|
||
{
|
||
|
||
//мы в ImplementationPart?
|
||
if (ScopeTable[CurrentArea] is UnitImplementationScope)
|
||
{
|
||
used_units=(ScopeTable[CurrentArea] as UnitImplementationScope).TopScopeArray;
|
||
ai=AreaList.IndexOf(CurrentArea);
|
||
if (ai>=0) //что-то нашли!
|
||
info=AddToSymbolInfo(info,AreaList[ai].InfoList,ScopeTable[CurrentArea],FirstInfo);
|
||
CurrentArea=GetTopScopeNum(CurrentArea);
|
||
}
|
||
//сейча мы в InterfacePart
|
||
ai=AreaList.IndexOf(CurrentArea);
|
||
if (ai>=0) //что-то нашли!
|
||
info=AddToSymbolInfo(info,AreaList[ai].InfoList,ScopeTable[CurrentArea],FirstInfo);
|
||
//смотрим в модулях
|
||
info=FindAllInAreaList(info,Name,used_units,AreaList,FirstInfo);
|
||
info=FindAllInAreaList(info,Name,(ScopeTable[CurrentArea] as UnitInterfaceScope).TopScopeArray,AreaList,FirstInfo);
|
||
return FirstInfo.Next;
|
||
}
|
||
else
|
||
if (ScopeTable[CurrentArea] is IInterfaceScope)
|
||
{
|
||
info = FindAllInClass(info, Name, CurrentArea, AreaList,OnlyInThisClass,FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
//Зачем искать в интерфейсах?
|
||
//(ssyy) Не понимаю вопрос. Спросившему подумать, зачем в компиляторе нужен поиск.
|
||
info = FindAllInAreaList(info, Name, (ScopeTable[CurrentArea] as IInterfaceScope).TopInterfaceScopeArray, AreaList, FirstInfo);
|
||
if (FirstInfo.Next != null || OnlyInType) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
else
|
||
if(ScopeTable[CurrentArea] is ClassScope)//мы очутились в классе
|
||
{
|
||
info=FindAllInClass(info,Name,CurrentArea,AreaList,OnlyInThisClass,FirstInfo);//надо сделать поиск по его предкам
|
||
if (FirstInfo.Next != null || OnlyInType) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
//иначе ищем дальше
|
||
}
|
||
else
|
||
if (ScopeTable[CurrentArea] is WithScope)//мы очутились в With
|
||
{
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
Scope[] wscopes = (ScopeTable[CurrentArea] as WithScope).WithScopes;
|
||
if(wscopes!=null)
|
||
foreach (Scope wsc in wscopes)
|
||
{
|
||
info = FindAllInClass(info, Name, wsc.ScopeNum, AreaList, OnlyInThisClass,FirstInfo);//надо сделать поиск по его предкам
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
//info = FindAllInAreaList(info, Name, (ScopeTable[CurrentArea] as WithScope).WithScopes, AreaList, true);
|
||
}
|
||
else
|
||
{
|
||
ai = AreaList.IndexOf(CurrentArea);
|
||
if (ai >= 0) //что-то нашли!
|
||
{
|
||
info = AddToSymbolInfo(info, AreaList[ai].InfoList, ScopeTable[CurrentArea],FirstInfo);
|
||
return FirstInfo.Next;
|
||
}
|
||
if (ScopeTable[CurrentArea] is ClassMethodScope)//мы очутились в методе класса
|
||
{
|
||
info = FindAllInClass(info, Name, (ScopeTable[CurrentArea] as ClassMethodScope).MyClassNum, AreaList, OnlyInThisClass,FirstInfo);//надо сделать поиск по его классу
|
||
if (FirstInfo.Next != null) //если что-то нашли то заканчиваем
|
||
return FirstInfo.Next;
|
||
}
|
||
}
|
||
CurrentArea=GetTopScopeNum(CurrentArea);//Пошли вверх
|
||
|
||
}
|
||
return null;
|
||
}
|
||
|
||
|
||
}
|
||
public class TreeConverterSymbolTable:DSSymbolTable
|
||
{
|
||
public TreeConverterSymbolTable(bool case_sensitive):base(SymbolTableConstants.HashTable_StartSize,case_sensitive){}
|
||
public TreeConverterSymbolTable():base(SymbolTableConstants.HashTable_StartSize,false){}
|
||
}
|
||
public class SymbolTableController
|
||
{
|
||
public static TreeConverterSymbolTable CurrentSymbolTable = new TreeConverterSymbolTable();
|
||
}
|
||
|
||
}
|