public void UnionWith(VarInfoContainer container)
{
foreach (SemanticTree.IConstantDefinitionNode node in container.Constants)
if (!Constants.Contains(node))
Constants.Add(node);
foreach (SemanticTree.IVAriableDefinitionNode node in container.SharedVariables)
if (!SharedVariables.Contains(node))
SharedVariables.Add(node);
foreach (SemanticTree.IVAriableDefinitionNode node in container.PrivateVariables)
if (!PrivateVariables.Contains(node))
PrivateVariables.Add(node);
for (int i = 0; i < container.ReductionVariables.Count; ++i )
if (!ReductionVariables.Contains(container.ReductionVariables[i]))
{
ReductionVariables.Add(container.ReductionVariables[i]);
ReductionActions.Add(container.ReductionActions[i]);
}
}
private static VarInfoContainer GetVarInfoContainer(VarFinderSyntaxVisitor VFVis, List<ReductionDirective> Reductions, List<string> PrivateVars, syntax_tree_visitor visitor, SyntaxTree.compiler_directive dir)
{
if (Reductions == null)
Reductions = new List<ReductionDirective>();
if (PrivateVars == null)
PrivateVars = new List<string>();
VarInfoContainer Result = new VarInfoContainer();
//константы копируются сразу
Result.Constants = VFVis.Constants;
//список переменных для редукции
//ищем переменные с такими именами, проверяем их наличие, тип и если все хорошо - добавляем в список
foreach (ReductionDirective rd in Reductions)
foreach (string rdVarName in rd.variables)
{
if (LoopVariables.Contains(rdVarName))
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_REDUCTION_WITH_LOOPVAR_{0}"), rdVarName), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
SymbolInfo si = visitor.context.find(rdVarName);
if (si == null)
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_UNKNOWN_VARNAME_{0}"), rdVarName), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
if (!(si.sym_info is SemanticTree.IVAriableDefinitionNode))
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_NAME_IS_NOT_VAR_{0}"), rdVarName), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
if (!IsValidVarForReduction(si.sym_info as SemanticTree.IVAriableDefinitionNode))
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_IS_NOT_POSSIBLE_REDUCTION_WITH_THIS_VAR_{0}"), rdVarName), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
Result.ReductionVariables.Add(si.sym_info as SemanticTree.IVAriableDefinitionNode);
Result.ReductionActions.Add(rd.Oper);
//for (int i = 0; i < VFVis.Variables.Count; ++i)
// if (VFVis.Variables[i].name.ToLower() == rdVarName.ToLower())
// {
// Result.ReductionVariables.Add(VFVis.Variables[i]);
// Result.ReductionActions.Add(rd.Oper);
// break;
// }
}
//приватные переменные - аналогично, но без проверки на тип
foreach (string privateVar in PrivateVars)
{
SymbolInfo si = visitor.context.find(privateVar);
if (si == null)
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_UNKNOWN_VARNAME_{0}"), privateVar), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
if (!(si.sym_info is SemanticTree.IVAriableDefinitionNode))
{
visitor.AddWarning(new PascalABCCompiler.Errors.CommonWarning(String.Format(PascalABCCompiler.StringResources.Get("OMPERROR_NAME_IS_NOT_VAR_{0}"), privateVar), visitor.CurrentDocument.file_name, dir.source_context.begin_position.line_num, dir.source_context.begin_position.column_num));
continue;
}
Result.PrivateVariables.Add(si.sym_info as SemanticTree.IVAriableDefinitionNode);
}
//по всем переменным:
//если она не приватная и по ней нет редукции - переписываем ее в список разделяемых
foreach (SemanticTree.IVAriableDefinitionNode var in VFVis.Variables)
{
bool NotShared = false;
foreach (SemanticTree.IVAriableDefinitionNode rdn in Result.ReductionVariables)
if (rdn.name.ToLower() == var.name.ToLower())
{
NotShared = true;
break;
}
if (!NotShared)
foreach (SemanticTree.IVAriableDefinitionNode prVar in Result.PrivateVariables)
if (prVar.name.ToLower() == var.name.ToLower())
{
NotShared = true;
break;
}
if (!NotShared)
Result.SharedVariables.Add(var);
}
return Result;
}
private static SyntaxTree.statement_list CreateFinalPart(string ObjName, VarInfoContainer Vars)
{
SyntaxTree.statement_list stl = new PascalABCCompiler.SyntaxTree.statement_list();
//создаем присваивания разделяемым переменным
for (int i = 0; i < Vars.SharedVariables.Count; ++i)
{
string VarName = Vars.SharedVariables[i].name;
if (LoopVariables.Contains(VarName.ToLower()))
continue;
SyntaxTree.dot_node DotNode = new PascalABCCompiler.SyntaxTree.dot_node();
DotNode.left = new SyntaxTree.ident(ObjName);
DotNode.right = new SyntaxTree.ident(VarName);
SyntaxTree.array_type arrType = ConvertToSyntaxType(Vars.SharedVariables[i].type as type_node) as SyntaxTree.array_type;
if (arrType != null && !is_dyn_arr(arrType))
{
stl.subnodes.Add(AssignArrs(arrType, DotNode, new SyntaxTree.ident(VarName)));
}
else
{
SyntaxTree.assign Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.to = new SyntaxTree.ident(VarName);
Assign.from = DotNode;
stl.subnodes.Add(Assign);
}
}
//создаем присваивания переменным редукции
for (int i = 0; i < Vars.ReductionVariables.Count; ++i)
{
string VarName = Vars.ReductionVariables[i].name;
SyntaxTree.dot_node DotNode = new PascalABCCompiler.SyntaxTree.dot_node();
DotNode.left = new SyntaxTree.ident(ObjName);
DotNode.right = new SyntaxTree.ident("$" + VarName);
SyntaxTree.array_type arrType = ConvertToSyntaxType(Vars.ReductionVariables[i].type as type_node) as SyntaxTree.array_type;
if (arrType != null && !is_dyn_arr(arrType))
{
stl.subnodes.Add(AssignArrs(arrType, DotNode, new SyntaxTree.ident(VarName)));
}
else
{
SyntaxTree.assign Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.to = new SyntaxTree.ident(VarName);
Assign.from = DotNode;
stl.subnodes.Add(Assign);
}
}
return stl;
}
private static SyntaxTree.statement_list CreateInitPart(string ClassName, string ObjName, VarInfoContainer Vars)
{
SyntaxTree.statement_list stl = new PascalABCCompiler.SyntaxTree.statement_list();
//Var Statement - объявление экземпляра обьекта-функции
SyntaxTree.var_statement ClassVar = new PascalABCCompiler.SyntaxTree.var_statement();
stl.subnodes.Add(ClassVar);
SyntaxTree.var_def_statement ClassVarDef = new PascalABCCompiler.SyntaxTree.var_def_statement();
ClassVar.var_def = ClassVarDef;
SyntaxTree.ident_list ClassIdl = new PascalABCCompiler.SyntaxTree.ident_list();
ClassVarDef.vars = ClassIdl;
ClassIdl.idents.Add(new PascalABCCompiler.SyntaxTree.ident(ObjName));
SyntaxTree.named_type_reference ClassTypeNTR = new PascalABCCompiler.SyntaxTree.named_type_reference();
ClassVarDef.vars_type = ClassTypeNTR;
ClassTypeNTR.names.Add(new PascalABCCompiler.SyntaxTree.ident(ClassName));
SyntaxTree.new_expr ClassInitNE = new PascalABCCompiler.SyntaxTree.new_expr();
ClassVarDef.inital_value = ClassInitNE;
SyntaxTree.named_type_reference ClassInitNTR = new PascalABCCompiler.SyntaxTree.named_type_reference();
ClassInitNE.type = ClassInitNTR;
ClassInitNTR.names.Add(new PascalABCCompiler.SyntaxTree.ident(ClassName));
//создаем присваивания разделяемым переменным
for (int i = 0; i < Vars.SharedVariables.Count; ++i)
{
string VarName = Vars.SharedVariables[i].name;
SyntaxTree.dot_node DotNode = new PascalABCCompiler.SyntaxTree.dot_node();
DotNode.left = new SyntaxTree.ident(ObjName);
DotNode.right = new SyntaxTree.ident(VarName);
SyntaxTree.array_type arrType = ConvertToSyntaxType(Vars.SharedVariables[i].type as type_node) as SyntaxTree.array_type;
if (arrType != null && !is_dyn_arr(arrType))
{
stl.subnodes.Add(AssignArrs(arrType, new SyntaxTree.ident(VarName), DotNode));
}
else
{
SyntaxTree.assign Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.from = new SyntaxTree.ident(VarName);
Assign.to = DotNode;
stl.subnodes.Add(Assign);
}
}
//создаем присваивания переменным редукции
for (int i = 0; i < Vars.ReductionVariables.Count; ++i)
{
string VarName = Vars.ReductionVariables[i].name;
SyntaxTree.dot_node DotNode = new PascalABCCompiler.SyntaxTree.dot_node();
DotNode.left = new SyntaxTree.ident(ObjName);
DotNode.right = new SyntaxTree.ident("$" + VarName);
SyntaxTree.array_type arrType = ConvertToSyntaxType(Vars.ReductionVariables[i].type as type_node) as SyntaxTree.array_type;
if (arrType != null && !is_dyn_arr(arrType))
{
stl.subnodes.Add(AssignArrs(arrType, new SyntaxTree.ident(VarName), DotNode));
}
else
{
SyntaxTree.assign Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.from = new SyntaxTree.ident(VarName);
Assign.to = DotNode;
stl.subnodes.Add(Assign);
}
}
return stl;
}
private static SyntaxTree.procedure_definition CreateMethod(string MethodName, SyntaxTree.statement Body, string LoopVariableName, SyntaxTree.class_members ClassMember, VarInfoContainer Vars)
{
// генерация метода
SyntaxTree.procedure_definition ProcDef = new PascalABCCompiler.SyntaxTree.procedure_definition();
//ClassMember.members.Add(ProcDef);
SyntaxTree.procedure_header ProcHead = new PascalABCCompiler.SyntaxTree.procedure_header();
ProcDef.proc_header = ProcHead;
ProcHead.name = new PascalABCCompiler.SyntaxTree.method_name(null, null, new PascalABCCompiler.SyntaxTree.ident(MethodName), null);
if (LoopVariableName != "")
{
// параметр, счетчик цикла
string ParamType = "integer";
SyntaxTree.formal_parameters FormalParams = new PascalABCCompiler.SyntaxTree.formal_parameters();
ProcHead.parameters = FormalParams;
SyntaxTree.typed_parameters TypedParams = new PascalABCCompiler.SyntaxTree.typed_parameters();
FormalParams.params_list.Add(TypedParams);
SyntaxTree.ident_list idl = new PascalABCCompiler.SyntaxTree.ident_list();
TypedParams.idents = idl;
idl.Add(new SyntaxTree.ident(LoopVariableName));
SyntaxTree.named_type_reference ntr = new PascalABCCompiler.SyntaxTree.named_type_reference();
TypedParams.vars_type = ntr;
ntr.Add(new SyntaxTree.ident(ParamType));
}
SyntaxTree.block ProcBlock = new PascalABCCompiler.SyntaxTree.block();
ProcDef.proc_body = ProcBlock;
ProcBlock.defs = new PascalABCCompiler.SyntaxTree.declarations();
if (Vars.Constants.Count > 0)
{
SyntaxTree.consts_definitions_list cdl = new PascalABCCompiler.SyntaxTree.consts_definitions_list();
ProcBlock.defs.defs.Add(cdl);
// константы - в методе
for (int i = 0; i < Vars.Constants.Count; ++i)
cdl.Add(CreateClassMember(Vars.Constants[i], "") as SyntaxTree.typed_const_definition);
}
if ((Vars.ReductionVariables.Count > 0) || (Vars.PrivateVariables.Count > 0))
{
// переменные редукции - в методе тоже, но без префикса
SyntaxTree.variable_definitions vds = new PascalABCCompiler.SyntaxTree.variable_definitions();
ProcBlock.defs.defs.Add(vds);
for (int i = 0; i < Vars.ReductionVariables.Count; ++i)
vds.Add(CreateClassMember(Vars.ReductionVariables[i], "") as SyntaxTree.var_def_statement);
// и приватные переменные
for (int i = 0; i < Vars.PrivateVariables.Count; ++i)
vds.Add(CreateClassMember(Vars.PrivateVariables[i], "") as SyntaxTree.var_def_statement);
}
if (Body is SyntaxTree.statement_list)
ProcBlock.program_code = Body as SyntaxTree.statement_list;
else
{
SyntaxTree.statement_list stl = new PascalABCCompiler.SyntaxTree.statement_list();
stl.subnodes.Add(Body);
ProcBlock.program_code = stl;
}
//присваивания для переменных редукции
if (Vars.ReductionVariables.Count > 0)
{
SyntaxTree.statement_list LoopBodyInit = new PascalABCCompiler.SyntaxTree.statement_list();
SyntaxTree.statement_list LoopBodyFinal = new PascalABCCompiler.SyntaxTree.statement_list();
for (int i = 0; i < Vars.ReductionVariables.Count; ++i)
{
//присваивание начального значения
SyntaxTree.assign Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.to = new SyntaxTree.ident(Vars.ReductionVariables[i].name);
bool isBool = Vars.ReductionVariables[i].type.name.ToLower() == "boolean";
switch (Vars.ReductionActions[i])
{
case ReductionOperations.and:
{
if (isBool)
Assign.from = new SyntaxTree.bool_const(true);
else
{
//отрицание нуля
Assign.from = new SyntaxTree.int32_const(0);
LoopBodyInit.subnodes.Add(Assign);
Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.to = new SyntaxTree.ident(Vars.ReductionVariables[i].name);
SyntaxTree.un_expr ue = new PascalABCCompiler.SyntaxTree.un_expr();
ue.operation_type = PascalABCCompiler.SyntaxTree.Operators.LogicalNOT;
ue.subnode = new SyntaxTree.ident(Vars.ReductionVariables[i].name);
Assign.from = ue;
}
break;
}
case ReductionOperations.or:
if (isBool)
Assign.from = new SyntaxTree.bool_const(false);
else
{
Assign.from = new SyntaxTree.int32_const(0);
}
break;
case ReductionOperations.xor: //
case ReductionOperations.plus: //см следующую ветку
case ReductionOperations.minus: Assign.from = new SyntaxTree.int32_const(0); break;
case ReductionOperations.mult: Assign.from = new SyntaxTree.int32_const(1); break;
}
LoopBodyInit.Add(Assign);
//присваивание после итерации
Assign = new PascalABCCompiler.SyntaxTree.assign();
Assign.operator_type = PascalABCCompiler.SyntaxTree.Operators.Assignment;
Assign.to = new SyntaxTree.ident("$" + Vars.ReductionVariables[i].name);
SyntaxTree.bin_expr From = new PascalABCCompiler.SyntaxTree.bin_expr();
From.left = new SyntaxTree.ident("$" + Vars.ReductionVariables[i].name);
From.right = new SyntaxTree.ident(Vars.ReductionVariables[i].name);
Assign.from = From;
switch (Vars.ReductionActions[i])
{
case ReductionOperations.and: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.LogicalAND; break;
case ReductionOperations.or: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.LogicalOR; break;
case ReductionOperations.xor: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.BitwiseXOR; break;
case ReductionOperations.plus: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.Plus; break;
case ReductionOperations.minus: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.Minus; break;
case ReductionOperations.mult: From.operation_type = PascalABCCompiler.SyntaxTree.Operators.Multiplication; break;
}
LoopBodyFinal.Add(Assign);
}
//создаем обьект для блокировки в классе
SyntaxTree.var_def_statement Lvds = new PascalABCCompiler.SyntaxTree.var_def_statement();
SyntaxTree.ident_list Lidl = new PascalABCCompiler.SyntaxTree.ident_list();
Lvds.vars = Lidl;
Lidl.Add(new SyntaxTree.ident("$ReductionLock"));
SyntaxTree.named_type_reference Lntr = new PascalABCCompiler.SyntaxTree.named_type_reference();
Lvds.vars_type = Lntr;
Lntr.Add(new SyntaxTree.ident("object"));
SyntaxTree.new_expr Lne = new PascalABCCompiler.SyntaxTree.new_expr();
Lvds.inital_value = Lne;
Lne.type = Lntr;
ClassMember.members.Add(Lvds);
//создаем lock Statement на обьекте с присваиваниями в конце итерации
SyntaxTree.lock_stmt reductionLock = new PascalABCCompiler.SyntaxTree.lock_stmt();
reductionLock.lock_object = new SyntaxTree.ident("$ReductionLock");
reductionLock.stmt = LoopBodyFinal;
//собираем все вместе и присваиваем это телу процедуры
LoopBodyInit.subnodes.AddRange(ProcBlock.program_code.subnodes);
LoopBodyInit.subnodes.Add(reductionLock);
ProcBlock.program_code = LoopBodyInit;
}
return ProcDef;
}
private static SyntaxTree.type_declarations CreateClass(string ClassName,out SyntaxTree.class_members ClassMember, VarInfoContainer Vars)
{
//генерация класса
SyntaxTree.type_declarations TypeDecls = new PascalABCCompiler.SyntaxTree.type_declarations();
SyntaxTree.type_declaration TypeDecl = new PascalABCCompiler.SyntaxTree.type_declaration();
TypeDecls.types_decl.Add(TypeDecl);
TypeDecl.type_name = new PascalABCCompiler.SyntaxTree.ident(ClassName);
SyntaxTree.class_definition ClassDef = new PascalABCCompiler.SyntaxTree.class_definition();
TypeDecl.type_def = ClassDef;
SyntaxTree.class_body ClassBody = new PascalABCCompiler.SyntaxTree.class_body();
ClassDef.body = ClassBody;
ClassMember = new PascalABCCompiler.SyntaxTree.class_members();
ClassBody.class_def_blocks.Add(ClassMember);
ClassMember.access_mod = new PascalABCCompiler.SyntaxTree.access_modifer_node(PascalABCCompiler.SyntaxTree.access_modifer.public_modifer);
// генерация полей класса
// shared переменные
for (int i = 0; i < Vars.SharedVariables.Count; ++i)
ClassMember.members.Add(CreateClassMember(Vars.SharedVariables[i], ""));
// переменные редукции - с долларовым префиксом
for (int i = 0; i < Vars.ReductionVariables.Count; ++i)
ClassMember.members.Add(CreateClassMember(Vars.ReductionVariables[i], "$"));
return TypeDecls;
}
private static bool GenerateOMPParallelSectionsCall(statements_list stmts, SyntaxTree.statement_list syntax_stmts, statements_list omp_stmts, syntax_tree_visitor syntax_tree_visitor)
{
SyntaxTree.expression_list delegates = new PascalABCCompiler.SyntaxTree.expression_list();
SyntaxTree.statement_list stlInit = new PascalABCCompiler.SyntaxTree.statement_list();
SyntaxTree.statement_list stlFinal = new PascalABCCompiler.SyntaxTree.statement_list();
VarInfoContainer Vars = new VarInfoContainer();
string ClassName = syntax_tree_visitor.context.get_free_name("$section_class{0}");
List<SyntaxTree.statement> Sections = new List<PascalABCCompiler.SyntaxTree.statement>();
foreach (SyntaxTree.statement syntax_statement in syntax_stmts.subnodes)
{
if (syntax_statement is SyntaxTree.empty_statement)
continue; //А зачем? ;-)
if (syntax_statement is SyntaxTree.var_statement)
{
//выдать предупреждение. Это не нормально для параллельных секций
syntax_tree_visitor.visit(syntax_statement as SyntaxTree.var_statement);
}
else
{
//ищем используемые переменные
VarFinderSyntaxVisitor VFvis = new VarFinderSyntaxVisitor(syntax_statement, syntax_tree_visitor.context, false);
SyntaxTree.compiler_directive dir = syntax_tree_visitor.DirectivesToNodesLinks[syntax_stmts];
//if (DirInfosTable[dir].ErrorName == "WARNING_IN_CLAUSE_PARAMETERS_REPEATED_VARS")
// syntax_tree_visitor.AddWarning(new Errors.CommonWarning(StringResources.Get(DirInfosTable[dir].ErrorName), syntax_stmts.source_context.FileName, DirInfosTable[dir].SC.begin_position.line_num, DirInfosTable[dir].SC.begin_position.column_num));
//else if (DirInfosTable[dir].ErrorName == "ERROR_IN_CLAUSE_PARAMETERS")
//{
// syntax_tree_visitor.AddWarning(new Errors.CommonWarning(StringResources.Get(DirInfosTable[dir].ErrorName), syntax_stmts.source_context.FileName, DirInfosTable[dir].SC.begin_position.line_num, DirInfosTable[dir].SC.begin_position.column_num));
//}
//else
if (DirInfosTable[dir].ErrorName != null)
{
syntax_tree_visitor.AddWarning(new Errors.CommonWarning(PascalABCCompiler.StringResources.Get(DirInfosTable[dir].ErrorName), syntax_stmts.source_context.FileName, DirInfosTable[dir].SC.begin_position.line_num, DirInfosTable[dir].SC.begin_position.column_num));
}
Vars.UnionWith(GetVarInfoContainer(VFvis, null, DirInfosTable[dir].Privates, syntax_tree_visitor, dir));
Sections.Add(syntax_statement);
}
}
//сохраняем контекст
ContextInfo contextInfo = new ContextInfo(syntax_tree_visitor);
try
{
//создание и конвертирование класса
SyntaxTree.class_members member;
SyntaxTree.type_declarations Decls = CreateClass(ClassName, out member, Vars);
for (int i = 0; i < Sections.Count; ++i)
member.members.Add(CreateMethod("method" + i.ToString(), Sections[i], "", member, Vars));
syntax_tree_visitor.visit(Decls);
}
finally
{
//восстанавливаем контекст
contextInfo.RestoreContext(syntax_tree_visitor);
}
//создаем инициализацию и финализацию
int NameNum = 0;
string ObjName = GetFreeName("$section_obj", ref NameNum, syntax_tree_visitor.context);
stlInit.subnodes.AddRange(CreateInitPart(ClassName, ObjName, Vars).subnodes);
stlFinal.subnodes.AddRange(CreateFinalPart(ObjName, Vars).subnodes);
SyntaxTree.procedure_call pc = new PascalABCCompiler.SyntaxTree.procedure_call();
SyntaxTree.method_call mc = new PascalABCCompiler.SyntaxTree.method_call();
mc.dereferencing_value = CreateTPLFunctionReference("Invoke");
pc.func_name = mc;
SyntaxTree.expression_list exl = new PascalABCCompiler.SyntaxTree.expression_list();
//foreach (string str in ObjNames)
for (int i=0; i<Sections.Count; ++i)
exl.Add(new SyntaxTree.dot_node(new SyntaxTree.ident(ObjName), new SyntaxTree.ident("Method"+i.ToString())));
mc.parameters = exl;
stlInit.subnodes.Add(CreateNestedRegionBorder(true));
stlInit.subnodes.Add(pc);
stlInit.subnodes.AddRange(stlFinal.subnodes);
stlInit.subnodes.Add(CreateNestedRegionBorder(false));
statement_node st = syntax_tree_visitor.ret.visit(stlInit);
omp_stmts.statements.AddElement(st);
return true;
}