/// <summary>
/// Поиск символа в пространстве имен.
/// </summary>
/// <param name="name">Имя для поиска.</param>
/// <returns>Первый элемент списка найденных имен. null если ни чего не найдено.</returns>
public override SymbolInfoList find(string name)
{
bool is_ns = NetHelper.NetHelper.IsNetNamespace(_name + "." + name);
SymbolInfoList sil = null;
if (is_ns)
{
compiled_namespace_node cnn = compiled_namespace_node.get_compiled_namespace(_name + "." + name, _tcst);
sil = new SymbolInfoList(new SymbolInfo(cnn));
}
else
{
//Kolay changed next string. throwOnError=false ignoreCase=true, .
//Type t = Type.GetType(_name+"."+name,false,true);
if (common_namespace != null)
{
sil = common_namespace.scope.FindOnlyInScope(name);
if (sil != null)
{
return(sil);
}
}
Type t = NetHelper.NetHelper.FindType(_name + "." + name);
if (t != null)
{
sil = new SymbolInfoList(new SymbolInfo(compiled_type_node.get_type_node(t, _tcst)));
}
else
{
t = NetHelper.NetHelper.FindType(_name + "." + _name);
if (t != null && NetHelper.NetHelper.IsEntryType(t))
{
sil = NetHelper.NetHelper.FindName(t, name);
if (sil == null)
{
type_node tn = NetHelper.NetHelper.FindCompiledPascalType(_name + "." + name);
if (tn != null)
{
sil = new SymbolInfoList(new SymbolInfo(tn));
}
else
{
template_class tc = NetHelper.NetHelper.FindCompiledTemplateType(_name + "." + name);
if (tc != null)
{
sil = new SymbolInfoList(new SymbolInfo(tc));
}
}
}
}
}
}
return(sil);
}
private void VisitTemplateClassDefinition(template_class tclass)
{
int offset = 0;
offset = SavePositionAndConstPool(tclass);//SavePosition(tclass);
bw.Write((byte)tclass.semantic_node_type);
//Пишем название шаблонного класса
bw.Write(tclass.name);
if (tclass.is_synonym)
bw.Write((byte)1);
else
bw.Write((byte)0);
//bw.Write(GetUnitReference(tclass.cnn)); //(ssyy) Нужно ли это?
//Пишем имена подключаемых сборок
bw.Write(tclass.using_list.Count);
foreach (using_namespace un in tclass.using_list)
{
bw.Write(un.namespace_name);
}
if (tclass.using_list2 == null)
{
bw.Write((byte)0);
}
else
{
bw.Write((byte)1);
bw.Write(tclass.using_list2.Count);
foreach (using_namespace un in tclass.using_list2)
{
bw.Write(un.namespace_name);
}
}
//Пишем имя файла, где описан шаблон
if (tclass.cur_document == null)
bw.Write((byte)0);
else
{
bw.Write((byte)1);
bw.Write(Path.GetFileName(tclass.cur_document.file_name));
}
SyntaxTree.SyntaxTreeStreamWriter stw = new SyntaxTree.SyntaxTreeStreamWriter();
stw.bw = bw;
if (tclass.type_dec == null)
{
bw.Write((byte)0);
}
else
{
bw.Write((byte)1);
//Пишем синтаксическое дерево шаблона
tclass.type_dec.visit(stw);
}
bw.Write(tclass.external_methods.Count);
foreach (procedure_definition_info pdi in tclass.external_methods)
{
if (pdi.nspace.scope is SymbolTable.UnitImplementationScope)
{
bw.Write((byte)1);
}
else
{
bw.Write((byte)0);
}
if (pdi.proc == null)
{
bw.Write((byte)0);
}
else
{
bw.Write((byte)1);
pdi.proc.visit(stw);
}
}
}
private void WriteTemplateClassReference(template_class tc)
{
byte is_def = 0;
int t_offset = GetTemplateTypeReference(tc, ref is_def);
bw.Write(is_def); //пишем флаг импортируемый ли это тип или нет
bw.Write(t_offset); // сохраняем его смещение (это либо смещение в самом модуле, либо в списке импорт. сущностей)
}
//ssyy
private int GetTemplateTypeReference(template_class tc, ref byte is_def)
{
int off = 0;
if (members.TryGetValue(tc, out off)) //если этот тип описан в этом модуле
{
is_def = 1;
return off;//возвращаем его смещение
}
//иначе он описан в другом модуле
is_def = 0;
ImportedEntity ie = null;
if (ext_members.TryGetValue(tc, out ie))
{
return ie.index * ie.GetSize();
}
ie = new ImportedEntity();
ie.flag = ImportKind.Common;
ie.num_unit = GetUnitToken(tc.cnn);//получаем модуль
ie.offset = GetExternalOffset(tc);//получаем смещение в другом модуле
int offset = imp_entitles.Count * ie.GetSize();
ie.index = imp_entitles.Count;
imp_entitles.Add(ie);
ext_members[tc] = ie;
return offset;
}
public common_type_node instance(template_class tc, List<type_node> template_params, location loc)
{
//Проверяем, что попытка инстанцирования корректна
SyntaxTree.class_definition cl_def = tc.type_dec.type_def as SyntaxTree.class_definition;
SyntaxTree.template_type_name ttn = tc.type_dec.type_name as SyntaxTree.template_type_name;
#if (DEBUG)
if (!tc.is_synonym)
{
if (cl_def == null)
{
throw new PascalABCCompiler.TreeConverter.CompilerInternalError("No body definition in template class.");
}
if (cl_def.template_args == null || cl_def.template_args.idents == null)
{
throw new PascalABCCompiler.TreeConverter.CompilerInternalError("No template arguments in syntax tree.");
}
}
else
{
if (ttn == null)
{
throw new PascalABCCompiler.TreeConverter.CompilerInternalError("No template name.");
}
}
#endif
List<SyntaxTree.ident> template_formals = (tc.is_synonym) ?
ttn.template_args.idents : cl_def.template_args.idents;
if (template_formals.Count != ttn.template_args.idents.Count)
{
AddError(loc, "TEMPLATE_ARGUMENTS_COUNT_MISMATCH");
}
if (!tc.is_synonym)
{
foreach (type_node tnode in template_params)
{
if (depended_from_generic_parameter(tnode))
{
AddError(loc, "TEMPLATES_AND_GENERICS_ARE_INCOMPATIBLE");
}
}
}
//А вдруг такая инстанция уже есть - вернём её
string inst_name = tc.CreateTemplateInstance(template_params, loc);
SymbolInfo si = tc.cnn.scope.FindOnlyInScope(inst_name);
if (si != null)
{
return (common_type_node)si.sym_info;
}
//Переходим в место описания шаблона
common_namespace_node current_namespace = context.converted_namespace;
context.converted_namespace = tc.cnn;
common_type_node current_type = context.converted_type;
context.converted_type = null;
template_class current_template = context.converted_template_type;
context.converted_template_type = null;
compiled_type_node current_compiled_type = context.converted_compiled_type;
context.converted_compiled_type = null;
common_function_node_stack current_funk_stack = context.converted_func_stack;
context.converted_func_stack = new common_function_node_stack(); //Думаю, это будет работать
//DarkStar
statement_list_stack statement_list_stack = convertion_data_and_alghoritms.statement_list_stack;
convertion_data_and_alghoritms.statement_list_stack = new statement_list_stack();
bool current_cur_meth_not_in_class = current_converted_method_not_in_class_defined;
current_converted_method_not_in_class_defined = false;
SymbolInfo current_last_created_function = context.last_created_function;
context.last_created_function = null;
bool current_record_created = _record_created;
_record_created = false;
SemanticTree.field_access_level current_fal = context.get_field_access_level();
document current_doc = current_document;
current_document = tc.cur_document;
bool current_body_exists = body_exists;
body_exists = false;
bool current_allow_inherited_ctor_call = context.allow_inherited_ctor_call;
bool current_is_direct_type_decl = is_direct_type_decl;
is_direct_type_decl = false;
context.allow_inherited_ctor_call = false;
bool current_type_section_converting = type_section_converting;
type_section_converting = true;
SemanticTree.field_access_level curr_fal = context.get_field_access_level();
List<var_definition_node> current_var_defs = context.var_defs;
context.var_defs = new List<var_definition_node>();
Hashtable current_member_decls = context.member_decls;
context.member_decls = new Hashtable();
//подменяем using-список
using_namespace_list current_using_list = new using_namespace_list();
foreach (using_namespace un in using_list)
{
current_using_list.AddElement(un);
}
using_list.clear();
foreach (using_namespace un in tc.using_list)
{
using_list.AddElement(un);
}
context.converted_type = null;
context.enter_code_block_without_bind();
common_type_node ctn;
bool interface_creating = false;
//Создаём инстанцию шаблона
if (tc.is_synonym)
{
ctn = context.create_type(inst_name, get_location(ttn));
}
else
{
if (cl_def.keyword == SyntaxTree.class_keyword.Record)
{
ctn = context.create_record_type(get_location(tc.type_dec.type_name), inst_name);
}
else
{
interface_creating = (cl_def.keyword == PascalABCCompiler.SyntaxTree.class_keyword.Interface);
ctn = context.advanced_create_type(inst_name, get_location(tc.type_dec.type_name), interface_creating);
}
}
ctn.original_template = tc;
bool indefinite = false;
foreach (type_node tn in template_params)
{
indefinite = indefinite || tn.depended_from_indefinite;
}
ctn.SetDependedFromIndefinite(indefinite);
tc.instance_params.Add(ctn, template_params);
//Ставим в соответствие формальным параметрам шаблона фактические
for (int i = 0; i < template_params.Count; i++)
{
ctn.Scope.AddSymbol(template_formals[i].name, new SymbolInfo(template_params[i]));
}
//Разбор тела класса
if (tc.is_synonym)
{
type_node synonym_value = convert_strong(tc.type_dec.type_def);
ctn.fields.AddElement(new class_field(compiler_string_consts.synonym_value_name,
synonym_value, ctn, PascalABCCompiler.SemanticTree.polymorphic_state.ps_static,
PascalABCCompiler.SemanticTree.field_access_level.fal_public, null));
}
else
{
if (cl_def.keyword == SyntaxTree.class_keyword.Record)
{
_record_created = true;
}
bool tmp_direct = is_direct_type_decl;
is_direct_type_decl = true;
hard_node_test_and_visit(cl_def);
is_direct_type_decl = tmp_direct;
//Разбор методов, описанных вне класса
if (!interface_creating)
{
type_section_converting = false;
foreach (procedure_definition_info pdi in tc.external_methods)
{
if (context.converted_namespace != pdi.nspace)
{
context.converted_namespace = pdi.nspace;
using_namespace_list ulist =
(pdi.nspace == tc.cnn) ? tc.using_list : tc.using_list2;
using_list.clear();
foreach (using_namespace un in ulist)
{
using_list.AddElement(un);
}
template_class.AddUsingListToScope(context.converted_namespace.scope, ulist);
}
//Заменяем в дереве метода имя шаблонного класса на имя инстанции
string tmp_name = pdi.proc.proc_header.name.class_name.name;
pdi.proc.proc_header.name.class_name.name = inst_name;
hard_node_test_and_visit(pdi.proc);
//Обратная замена
pdi.proc.proc_header.name.class_name.name = tmp_name;
}
foreach (common_method_node cmn in ctn.methods)
{
if (cmn.function_code == null)
{
AddError(cmn.loc, "FUNCTION_PREDEFINITION_WITHOUT_DEFINITION");
}
}
}
}
//Прыжок обратно
context.leave_code_block();
context.converted_namespace = current_namespace;
context.converted_type = current_type;
context.converted_template_type = current_template;
context.set_field_access_level(current_fal);
context.converted_func_stack = current_funk_stack;
context.converted_compiled_type = current_compiled_type;
convertion_data_and_alghoritms.statement_list_stack = statement_list_stack;
current_document = current_doc;
body_exists = current_body_exists;
_record_created = current_record_created;
context.last_created_function = current_last_created_function;
is_direct_type_decl = current_is_direct_type_decl;
context.allow_inherited_ctor_call = current_allow_inherited_ctor_call;
current_converted_method_not_in_class_defined = current_cur_meth_not_in_class;
context.set_field_access_level(curr_fal);
type_section_converting = current_type_section_converting;
context.member_decls = current_member_decls;
context.var_defs = current_var_defs;
using_list.clear();
foreach (using_namespace un in current_using_list)
{
using_list.AddElement(un);
}
return ctn;
}
public type_node instance_any(template_class tc, List<type_node> template_params, location loc)
{
common_type_node t = instance(tc, template_params, loc);
if (tc.is_synonym)
{
return t.fields[0].type;
}
return t;
}
public override void visit(SyntaxTree.type_declaration _type_declaration)
{
//bool is_template_synonym = false;
//SyntaxTree.array_type at=_type_declaration.type_def as SyntaxTree.array_type;
template_class tc = null;
SyntaxTree.template_type_name ttn = _type_declaration.type_name as SyntaxTree.template_type_name;
SyntaxTree.class_definition cl_def = _type_declaration.type_def as SyntaxTree.class_definition;
SyntaxTree.function_header function_header = _type_declaration.type_def as SyntaxTree.function_header;
SyntaxTree.procedure_header procedure_header = _type_declaration.type_def as SyntaxTree.procedure_header;
if (cl_def != null && (cl_def.attribute & SyntaxTree.class_attribute.Partial) == SyntaxTree.class_attribute.Partial && cl_def.keyword != SyntaxTree.class_keyword.Class)
{
AddError(get_location(_type_declaration), "ONLY_CLASS_CAN_BE_PARTIAL");
}
if (ttn != null && cl_def == null && function_header == null && procedure_header == null)
{
location t_loc = get_location(ttn);
context.check_name_free(ttn.name, t_loc);
tc = new template_class(_type_declaration, ttn.name,
context.converted_namespace,
current_document, using_list);
tc.is_synonym = true;
//Проверяем параметры шаблона на совпадение друг с другом
check_param_redeclared(ttn.template_args.idents);
context.AddTemplate(ttn.name, tc, t_loc);
return;
//is_template_synonym = true;
//AddError(new TemplateCanBeClassOnly(get_location(ttn)));
}
if ((function_header != null) || (procedure_header != null))
{
location loc;
if (function_header != null)
loc = get_location(function_header);
else
loc = get_location(procedure_header);
string del_name = _type_declaration.type_name.name;
if (ttn != null)
{
if (context.top_function != null)
{
AddError(loc, "GENERIC_DELEGATE_INNER_FUNCTION");
}
del_name += compiler_string_consts.generic_params_infix + ttn.template_args.idents.Count;
}
context.check_name_free(del_name, loc);
common_type_node del_type = convertion_data_and_alghoritms.type_constructor.create_delegate_without_init(
del_name, context.converted_namespace, loc);
//(ssyy) Обработка дженериков
common_type_node tmp_converted_type = null;
if (ttn != null)
{
tmp_converted_type = context.converted_type;
context.converted_type = del_type;
visit_generic_params(del_type, ttn.template_args.idents);
}
if (function_header != null)
{
del_type = convert_function_type(function_header, loc, del_name, del_type);
}
else
{
del_type = convert_function_type(procedure_header, loc, del_name, del_type);
}
if (ttn != null)
{
context.converted_type = tmp_converted_type;
}
//blocks.converted_namespace.types.AddElement(del_type);
CheckWaitedRefTypes(del_type);
if (_type_declaration.attributes != null)
{
make_attributes_for_declaration(_type_declaration,del_type);
}
context.converted_namespace.scope.AddSymbol(del_name, new SymbolInfo(del_type));
return;
}
if (cl_def == null && ttn == null)
{
string name = _type_declaration.type_name.name;
location loc = get_location(_type_declaration.type_name);
context.check_name_free(name, loc);
is_direct_type_decl = true;
type_node tn = convert_strong(_type_declaration.type_def);
assign_doc_info(tn,_type_declaration);
is_direct_type_decl = false;
if (_type_declaration.type_def is SyntaxTree.named_type_reference||
_type_declaration.type_def is SyntaxTree.ref_type || _type_declaration.type_def is SyntaxTree.string_num_definition ||
tn.type_special_kind == PascalABCCompiler.SemanticTree.type_special_kind.array_kind)// ||
/*tn.type_special_kind == PascalABCCompiler.SemanticTree.type_special_kind.set_type*/
{
if (context.converted_func_stack.Empty)
{
type_synonym ts = new type_synonym(name, tn, loc);
assign_doc_info(ts,_type_declaration);
context.converted_namespace.type_synonyms.Add(ts);
}
}
else
{
tn.SetName(context.BuildName(name));
}
if (_type_declaration.attributes != null)
if (_type_declaration.type_def is SyntaxTree.enum_type_definition)
{
make_attributes_for_declaration(_type_declaration,tn);
(tn as common_type_node).add_additional_enum_operations();
}
else
AddError(get_location(_type_declaration.attributes), "ATTRIBUTES_APPLICABLE_ONLY_TO_THESE_TYPES");
context.add_type(name, tn, loc);
return;
}
//Проверим, что список template-ов не пуст
bool is_generic = false;
if (ttn != null && cl_def != null && cl_def.template_args == null)
{
cl_def.template_args = ttn.template_args;
}
if (cl_def != null && cl_def.template_args != null && cl_def.template_args.idents != null &&
cl_def.template_args.idents.Count > 0)
{
switch (cl_def.keyword)
{
case PascalABCCompiler.SyntaxTree.class_keyword.TemplateClass:
cl_def.keyword = PascalABCCompiler.SyntaxTree.class_keyword.Class;
is_generic = false;
check_where_section(cl_def);
break;
case PascalABCCompiler.SyntaxTree.class_keyword.TemplateRecord:
cl_def.keyword = PascalABCCompiler.SyntaxTree.class_keyword.Record;
is_generic = false;
check_where_section(cl_def);
break;
case PascalABCCompiler.SyntaxTree.class_keyword.TemplateInterface:
cl_def.keyword = PascalABCCompiler.SyntaxTree.class_keyword.Interface;
is_generic = false;
check_where_section(cl_def);
break;
default:
is_generic = true;
break;
}
//if (is_generic)
//{
// throw new NotSupportedError(get_location(_type_declaration.type_name));
//}
if (!is_generic)
{
string t_name = _type_declaration.type_name.name;
location t_loc = get_location(_type_declaration.type_name);
SymbolInfo si = context.find_only_in_namespace(t_name);
tc = null;
//Ищем предописание
if (si != null)
{
tc = si.sym_info as template_class;
if (tc == null || !tc.ForwardDeclarationOnly)
{
AddError(new NameRedefinition(t_name, convertion_data_and_alghoritms.get_location(si.sym_info), t_loc));
}
SyntaxTree.class_definition prev_cl_def = tc.type_dec.type_def as SyntaxTree.class_definition;
if (prev_cl_def.keyword != cl_def.keyword || prev_cl_def.template_args.idents.Count != cl_def.template_args.idents.Count)
{
AddError(t_loc, "FORWARD_TEMPLATE_{0}_DECLARATION_MISMATCH_DECLARATION", t_name);
}
for (int k = 0; k < cl_def.template_args.idents.Count; k++)
{
if (string.Compare(cl_def.template_args.idents[k].name, prev_cl_def.template_args.idents[k].name, true) != 0)
{
AddError(t_loc, "FORWARD_TEMPLATE_{0}_DECLARATION_MISMATCH_DECLARATION", t_name);
}
}
if (cl_def.body == null)
{
AddError(new NameRedefinition(t_name, convertion_data_and_alghoritms.get_location(si.sym_info), t_loc));
}
tc.type_dec = _type_declaration;
tc.ForwardDeclarationOnly = false;
return;
}
tc = new template_class(_type_declaration, t_name,
context.converted_namespace,
current_document, using_list);
//Проверяем параметры шаблона на совпадение друг с другом
check_param_redeclared(cl_def.template_args.idents);
tc.ForwardDeclarationOnly = cl_def.body == null;
context.AddTemplate(t_name, tc, t_loc);
if (!tc.ForwardDeclarationOnly && template_class.check_template_definitions)
{
int count = cl_def.template_args.idents.Count;
List<type_node> test_types = new List<type_node>(count);
for (int i = 0; i < count; i++)
{
test_types.Add(new indefinite_type_node(cl_def.template_args.idents[i].name));
}
instance(tc, test_types, t_loc);
}
return;
}
}
//(ssyy) Теперь проверим на модификатор template
if (cl_def.keyword == PascalABCCompiler.SyntaxTree.class_keyword.TemplateClass ||
cl_def.keyword == PascalABCCompiler.SyntaxTree.class_keyword.TemplateRecord ||
cl_def.keyword == PascalABCCompiler.SyntaxTree.class_keyword.TemplateInterface)
{
//Ошибка, т.к. нет списка шаблонных параметров.
AddError(get_location(_type_declaration.type_name), "TEMPLATE_PARAMS_EXPECTED");
}
if (is_generic)
{
context.check_name_free(_type_declaration.type_name.name, get_location(_type_declaration.type_name));
_type_declaration.type_name.name += compiler_string_consts.generic_params_infix +
cl_def.template_args.idents.Count.ToString();
}
if (cl_def.keyword == SyntaxTree.class_keyword.Record)
{
string name = record_type_name = _type_declaration.type_name.name;
record_is_generic = is_generic;
location loc = get_location(_type_declaration.type_name);
context.check_name_free(name, loc);
//context.create_record_type(loc, record_type_name);
is_direct_type_decl = true;
type_node tn = convert_strong(_type_declaration.type_def);
assign_doc_info(tn,_type_declaration);
if (_type_declaration.attributes != null)
{
make_attributes_for_declaration(_type_declaration, tn);
}
is_direct_type_decl = false;
record_type_name = null;
record_is_generic = false;
tn.SetName(context.BuildName(name));
return;
}
//(ssyy) Флаг показывает, создаём ли мы интерфейс
bool interface_creating = (/*cl_def != null &&*/ cl_def.keyword == PascalABCCompiler.SyntaxTree.class_keyword.Interface);
common_type_node ctn = context.advanced_create_type(_type_declaration.type_name.name, get_location(_type_declaration.type_name), interface_creating, (cl_def.attribute & SyntaxTree.class_attribute.Partial) == SyntaxTree.class_attribute.Partial);
assign_doc_info(ctn,_type_declaration);
if (is_generic)
{
context.create_generic_indicator(ctn);
visit_generic_params(ctn, cl_def.template_args.idents);
}
visit_where_list(cl_def.where_section);
CheckWaitedRefTypes(ctn);
is_direct_type_decl = true;
hard_node_test_and_visit(_type_declaration.type_def);
// frninja 28/04/16 - режем мусорные методы хелперы yield
{
var toRemove = ctn.methods.Where(m => m.name.StartsWith(YieldHelpers.YieldConsts.YieldHelperMethodPrefix)).ToArray();
foreach (var m in toRemove)
{
ctn.methods.remove(m);
}
}
// end frninja
is_direct_type_decl = false;
if (_type_declaration.attributes != null)
{
make_attributes_for_declaration(_type_declaration, ctn);
}
}
public void AddTemplate(string name, template_class tc, location loc)
{
check_name_free(name, loc);
_cmn.scope.AddSymbol(name, new SymbolInfo(tc));
}
private template_class CreateTemplateClass(int offset)
{
definition_node dn = null;
if (members.TryGetValue(offset, out dn))
return dn as template_class;
template_class tc = null;
string name = br.ReadString();
bool is_syn = br.ReadByte() == 1;
using_namespace_list unl = new using_namespace_list();
int using_count = br.ReadInt32();
for (int i = 0; i < using_count; i++)
{
unl.AddElement(new using_namespace(br.ReadString()));
}
using_namespace_list unl2 = null;
if (CanReadObject())
{
unl2 = new using_namespace_list();
int using_count2 = br.ReadInt32();
for (int i = 0; i < using_count2; i++)
{
unl2.AddElement(new using_namespace(br.ReadString()));
}
}
document doc = null;
if (br.ReadByte() == 1)
{
doc = new document(Path.Combine(Path.GetDirectoryName(cur_doc.file_name),br.ReadString()));
}
SyntaxTree.SyntaxTreeStreamReader str = new SyntaxTree.SyntaxTreeStreamReader();
str.br = br;
SyntaxTree.type_declaration t_d = str._read_node() as SyntaxTree.type_declaration;
int ext_count = br.ReadInt32();
List<procedure_definition_info> pdi_list = new List<procedure_definition_info>(ext_count);
for (int i = 0; i < ext_count; i++)
{
byte num = br.ReadByte();
common_namespace_node c_m_n = cun.namespaces[num];
SyntaxTree.syntax_tree_node stn = str._read_node();
SyntaxTree.procedure_definition p_d = stn as SyntaxTree.procedure_definition;
pdi_list.Add(new procedure_definition_info(c_m_n, p_d));
}
//(ssyy) Далее формируем список областей видимости, которые
//подключаются к модулю. Вообще-то шаблоны классов этим
//заниматься не должны, но кроме них этот список
//никому не нужен (по состоянию на 01.06.2007).
if (cun.scope.TopScopeArray.Length == 0)
{
cun.scope.TopScopeArray = MakeTopScopeArray(unl, pcu_file.interface_uses_count);
}
if (cun.implementation_scope.TopScopeArray.Length == 0 && unl2 != null)
{
//формируем implementation - область
cun.implementation_scope.TopScopeArray = MakeTopScopeArray(unl2, pcu_file.incl_modules.Length);
}
tc = new template_class(t_d, name, cun.namespaces[0], doc, unl);
tc.external_methods = pdi_list;
tc.using_list2 = unl2;
tc.is_synonym = is_syn;
//members[offset] = tc;
AddMember(tc, offset);
cun.namespaces[0].scope.AddSymbol(name, new SymbolInfo(tc));
return tc;
}
public SymbolInfo(template_class tc)
{
_sym_info = tc;
_access_level = access_level.al_public;
_symbol_kind = symbol_kind.sk_none;
}
//\ssyy
//(ssyy) возвращаемое значение заменено на definition_node из-за шаблонов
public definition_node enter_in_type_method(SyntaxTree.method_name meth_name, string type_name, location loc, int num_template_args)
{
// num_template_args - это количество обобщенных аргументов в классе (не в методе!)
SymbolInfo si = null;
if (meth_name.ln!=null && meth_name.ln.Count > 1)
{
// обработать эту ситуацию особо тщательно: в ln - список возможных пространств имен с классом (возможно, обобщенным) на конце
// если в ln какое-то имя кроме последнего, содержит обобщенные параметры - это ошибка
for (var i = 0; i < meth_name.ln.Count - 1; i++)
if (meth_name.ln[i] is SyntaxTree.template_type_name)
AddError(new NameCannotHaveGenericParameters(meth_name.ln[i].name, syntax_tree_visitor.get_location(meth_name.ln[i])));
var ntr = new SyntaxTree.named_type_reference();
for (var i = 0; i < meth_name.ln.Count; i++)
ntr.Add(meth_name.ln[i]);
if (num_template_args>0 && ! ntr.names[meth_name.ln.Count-1].name.Contains(compiler_string_consts.generic_params_infix))
{
ntr.names[meth_name.ln.Count-1].name += compiler_string_consts.generic_params_infix + num_template_args;
}
si = find_definition_node(ntr, loc);
// если не нашли, то ошибка будет неправильной с неправильным именем - надо исправить
}
else
{
if (num_template_args != 0)
{
string template_type_name = type_name + compiler_string_consts.generic_params_infix + num_template_args.ToString();
si = find(template_type_name);
/*if (si == null || si.sym_info.general_node_type != general_node_type.template_type)
{
type_name = type_name + compiler_string_consts.generic_params_infix + num_template_args.ToString();
si = null;
}*/
}
if (si == null)
{
si = find(type_name);
}
}
if (si == null)
{
AddError(new UndefinedNameReference(type_name, loc));
}
definition_node dn = si.sym_info;
if (dn.general_node_type == general_node_type.template_type)
{
_ctt = dn as template_class;
if (_cmn != _ctt.cnn && _ctt.using_list2 == null)
{
//Заполняем список using для внешних методов
_ctt.using_list2 = new using_namespace_list();
foreach(using_namespace un in syntax_tree_visitor.using_list)
{
_ctt.using_list2.AddElement(un);
}
}
return dn;
}
if (dn.general_node_type == general_node_type.generic_indicator)
{
dn = (dn as generic_indicator).generic;
}
if (dn is compiled_type_node)
{
_compiled_tn = dn as compiled_type_node;
return dn;
}
if (dn.general_node_type != general_node_type.type_node)
{
AddError(loc, "TYPE_NAME_EXPECTED");
}
#if DEBUG
if (si.Next != null)
{
throw new CompilerInternalError("Must find only type, found some other.");
}
#endif
if (dn.semantic_node_type != semantic_node_type.common_type_node)
{
AddError(loc, "ONLY_COMMON_TYPE_METHOD_DEFINITION_ALLOWED");
}
//TODO: В случае создания вложенных классов этот код надо поправить.
common_type_node ctn = dn as common_type_node;
_ctn = ctn;
return ctn;
}
public void reset()
{
_cmn = null;
_ctn = null;
_func_stack.clear();
var_defs.Clear();
_main_procedure = null;
_last_created_function = null;
_cycles_stack.clear();
_num_of_for_cycles = 0;
_fal = SemanticTree.field_access_level.fal_private;
rec_num = 1;
var_defs_stack.Clear();
type_stack.Clear();
clear_special_local_vars();
_scope_stack.Clear();
TypedFiles.Clear();
ShortStringTypes.Clear();
TypedSets.Clear();
_compiled_tn = null;
_explicit_interface_type = null;
_ctt = null;
allow_inherited_ctor_call = false;
_types_predefined.Clear();
_block_stack.Clear();
member_decls.Clear();
possible_incorrect_instances.Clear();
skip_check_where_sections = false;
LambdaHelper.Reset(); //lroman//
SavedContext = null;
SavedContextStack.Clear();
compiled_tc_cache.Clear();
extension_method = false;
_last_created_function = null;
in_parameters_block = false;
is_order_independed_method_description = false;
}
public template_class create_template_class(string name, byte[] tree)
{
Dictionary<string, template_class> tc_dict = null;
template_class tc = null;
if (compiled_tc_cache.TryGetValue(converted_namespace, out tc_dict) && tc_dict.TryGetValue(name, out tc))
return tc;
SyntaxTree.SyntaxTreeStreamReader str = new SyntaxTree.SyntaxTreeStreamReader();
str.br = new System.IO.BinaryReader(new System.IO.MemoryStream(tree));
SyntaxTree.type_declaration t_d = str._read_node() as SyntaxTree.type_declaration;
tc = new template_class(t_d, name, converted_namespace, null, new using_namespace_list());
tc.is_synonym = true;
if (tc_dict == null)
{
tc_dict = new Dictionary<string, template_class>();
compiled_tc_cache[converted_namespace] = tc_dict;
}
tc_dict[name] = tc;
return tc;
}
