public static procedure_definition BuildToStringFuncForAutoClass(List <ident> names)
{
var pal = new procedure_attributes_list(proc_attribute.attr_override);
var fp = new formal_parameters();
var ff = new function_header("ToString", "string", fp, pal);
var cleft = new char_const('(');
var cright = new char_const(')');
var ccomma = new char_const(',');
bin_expr ex = new bin_expr(cleft, cright, Operators.Plus);
for (var i = 0; i < names.Count; i++)
{
var dn = new dot_node(names[i], new ident("ToString"));
var asnode = new typecast_node(names[i], new named_type_reference("object"), op_typecast.as_op);
var eqnode = new bin_expr(asnode, new nil_const(), Operators.Equal);
var expr = new question_colon_expression(eqnode, new string_const("nil"), dn);
ex.left = new bin_expr(ex.left, expr, Operators.Plus);
if (i < names.Count - 1)
{
ex.left = new bin_expr(ex.left, ccomma, Operators.Plus);
}
}
var ass = new assign("Result", ex);
return(BuildShortProcFuncDefinitionNoSC(ff, ass));
}
public LambdaResultTypeInferrer(function_header lambdaHeader, proc_block lambdaBody, syntax_tree_visitor syntaxTreeVisitor)
{
this.lambdaBody = lambdaBody;
this.lambdaHeader = lambdaHeader;
this.syntaxTreeVisitor = syntaxTreeVisitor;
resultExpressionsTypes = new List <Tuple <type_node, expression, expression_node> >();
}
public static procedure_definition CreateFunctionDefinitionNode(method_name methName, formal_parameters formalPars, bool ofObject, bool classKeyword, statement procBody, type_definition returnType, SourceContext sc)
{
procedure_definition procDef = new procedure_definition();
function_header procHeader = new function_header();
procHeader.name = methName;
procHeader.source_context = sc;
if (procHeader.name.meth_name is template_type_name)
{
procHeader.template_args = (procHeader.name.meth_name as template_type_name).template_args;
ident id = new ident(procHeader.name.meth_name.name);
procHeader.name.meth_name = id;
}
procHeader.parameters = formalPars;
procHeader.of_object = ofObject;
procHeader.class_keyword = classKeyword;
procHeader.return_type = returnType;
statement_list stmtList = new statement_list();
stmtList.subnodes.Add(procBody);
block bl = new block(null, null);
bl.program_code = stmtList;
procDef.proc_header = procHeader;
procDef.proc_body = (proc_block)bl;
return(procDef);
}
public static procedure_definition BuildShortFuncDefinition(formal_parameters fp, procedure_attributes_list att, method_name name, type_definition result, expression ex, SourceContext headsc)
{
var ff = new function_header(fp, att, name, null, result, headsc);
procedure_definition pd = BuildShortProcFuncDefinition(ff, new assign("Result", ex, ex.source_context));
return(pd);
}
public procedure_definition lambda(function_lambda_definition _function_lambda_definition)
{
procedure_definition _func_def = new procedure_definition();
method_name _method_name1 = new method_name(null, null, new ident(_function_lambda_definition.lambda_name), null);
//parsertools.create_source_context(_method_name1, _method_name1.meth_name, _method_name1.meth_name);
function_header _function_header1 = new function_header();
object rt1 = new object();
_function_header1.name = _method_name1;
if (_function_header1.name.meth_name is template_type_name)
{
_function_header1.template_args = (_function_header1.name.meth_name as template_type_name).template_args;
ident id = new ident(_function_header1.name.meth_name.name);
//parsertools.create_source_context(id, _function_header1.name.meth_name, _function_header1.name.meth_name);
_function_header1.name.meth_name = id;
}
formal_parameters fps = new PascalABCCompiler.SyntaxTree.formal_parameters();
_function_header1.parameters = _function_lambda_definition.formal_parameters;//fps;
/*SyntaxTree.named_type_reference _named_type_reference = new SyntaxTree.named_type_reference();
* SyntaxTree.ident idtype = new SyntaxTree.ident("object");
* _named_type_reference.source_context = idtype.source_context;
* _named_type_reference.names.Add(idtype);
* rt1 = _named_type_reference;
* _function_header1.return_type = (SyntaxTree.type_definition)_named_type_reference;*/
_function_header1.return_type = _function_lambda_definition.return_type;
_function_header1.of_object = false;
_function_header1.class_keyword = false;
token_info _token_info = new token_info("function");
//_token_info.source_context = parsertools.GetTokenSourceContext();
//parsertools.create_source_context(_function_header1, _token_info, _token_info);
block _block1 = new block(null, null);
statement_list sl1 = new statement_list();
sl1.subnodes.Add(_function_lambda_definition.proc_body);
_block1.program_code = sl1;
_func_def.proc_header = _function_header1;
_func_def.proc_body = (proc_block)_block1;
if (_function_lambda_definition.defs != null)
{
if (((block)_func_def.proc_body).defs == null)
{
((block)_func_def.proc_body).defs = new declarations();
}
for (int l = 0; l < _function_lambda_definition.defs.Count; l++)
{
((block)_func_def.proc_body).defs.defs.Add(_function_lambda_definition.defs[l] as procedure_definition);
}
}
_function_lambda_definition.proc_definition = _func_def;
//parsertools.create_source_context(_func_def, _function_header1, _function_header1);
return(_func_def);
}
public override void visit(function_header _function_header)
{
prepare_node(_function_header.name, "name");
prepare_node(_function_header.parameters, "parameters");
prepare_node(_function_header.proc_attributes, "attributes");
prepare_node(_function_header.template_args, "template_params");
prepare_node(_function_header.where_defs, "where_defs");
prepare_node(_function_header.return_type, "return_type");
}
public override void visit(function_header fh)
{
if (first_time_visit_function_header)
{
DefaultVisit(fh);
first_time_visit_function_header = false;
}
// DO NOTHING
}
/// <summary>
/// Вывод типа возвращаемого значения лямбды
/// </summary>
public static void InferResultType(function_header funcHeader, proc_block procBody, syntax_tree_visitor visitor)
{
var retType = funcHeader.return_type as lambda_inferred_type;
if (retType != null && retType.real_type is lambda_any_type_node)
{
retType.real_type = new LambdaResultTypeInferrer(funcHeader, procBody, visitor).InferResultType();
}
}
public override void visit(function_header _function_header)
{
if (_function_header.of_object)
{
text += "of object";
}
if (_function_header.class_keyword)
{
text += "class proc";
}
}
private procedure_header get_method_header(ICSharpCode.NRefactory.Ast.MethodDeclaration method)
{
procedure_header proc_header;
if (is_void(method.TypeReference))
{
proc_header = new procedure_header();
}
else
{
proc_header = new function_header();
}
proc_header.name = new method_name();
proc_header.name.meth_name = new ident(method.Name);
proc_header.source_context = get_source_context(method);
if (proc_header is function_header)
{
(proc_header as function_header).return_type = get_type_reference(method.TypeReference);
}
proc_header.parameters = get_parameters(method.Parameters);
proc_header.proc_attributes = new procedure_attributes_list();
if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Abstract) == ICSharpCode.NRefactory.Ast.Modifiers.Abstract)
{
proc_header.proc_attributes.proc_attributes.Add(new procedure_attribute(proc_attribute.attr_abstract));
}
if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Virtual) == ICSharpCode.NRefactory.Ast.Modifiers.Virtual)
{
proc_header.proc_attributes.proc_attributes.Add(new procedure_attribute(proc_attribute.attr_virtual));
}
if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Override) == ICSharpCode.NRefactory.Ast.Modifiers.Override)
{
proc_header.proc_attributes.proc_attributes.Add(new procedure_attribute(proc_attribute.attr_override));
}
//if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Overloads) == ICSharpCode.NRefactory.Ast.Modifiers.Overloads)
// proc_header.proc_attributes.proc_attributes.Add(new procedure_attribute(proc_attribute.attr_overload));
if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.New) == ICSharpCode.NRefactory.Ast.Modifiers.New)
{
proc_header.proc_attributes.proc_attributes.Add(new procedure_attribute(proc_attribute.attr_reintroduce));
}
if ((method.Modifier & ICSharpCode.NRefactory.Ast.Modifiers.Static) == ICSharpCode.NRefactory.Ast.Modifiers.Static)
{
proc_header.class_keyword = true;
}
return(proc_header);
}
public override void visit(function_header _function_header)
{
AddPossibleComments(_function_header, true, false);
_function_header.name.visit(this);
if (_function_header.parameters != null)
{
_function_header.parameters.visit(this);
}
_function_header.return_type.visit(this);
if (_function_header.proc_attributes != null)
{
_function_header.proc_attributes.visit(this);
}
if (_function_header.where_defs != null)
{
_function_header.where_defs.visit(this);
}
}
public override void visit(function_header _function_header)
{
executer.visit(_function_header);
if (_function_header.return_type != null)
this.visit((dynamic)_function_header.return_type);
if (_function_header.parameters != null)
this.visit((dynamic)_function_header.parameters);
if (_function_header.proc_attributes != null)
this.visit((dynamic)_function_header.proc_attributes);
if (_function_header.name != null)
this.visit((dynamic)_function_header.name);
if (_function_header.template_args != null)
this.visit((dynamic)_function_header.template_args);
if (_function_header.where_defs != null)
this.visit((dynamic)_function_header.where_defs);
if (_function_header.attr_list != null)
this.visit((dynamic)_function_header.attr_list);
if (_function_header.attributes != null)
this.visit((dynamic)_function_header.attributes);
}
public override void visit(function_header h)
{
AddProcHeader(h);
}
public virtual void visit(function_header _function_header)
{
DefaultVisit(_function_header);
}
public virtual void post_do_visit(function_header _function_header)
{
}
public override void visit(function_header _function_header)
{
DefaultVisit(_function_header);
pre_do_visit(_function_header);
visit(function_header.return_type);
post_do_visit(_function_header);
}
public virtual void visit(function_header _function_header)
{
DefaultVisit(_function_header);
}
public virtual void visit(function_header _function_header)
{
}
public virtual void visit(function_header _function_header)
{
}
public override void visit(function_header _function_header)
{
connect(_function_header);
}
