public expression_node convert_delegate_to_return_value_type_with_convertion(location call_location, params expression_node[] parameters)
{
expression_node del = parameters[0];
expression_node par = convert_delegate_to_return_value_type(call_location, del);
return(type_table_function_call_maker(convert_function, call_location, par));
}
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="condition">Условие.</param>
/// <param name="then_body">Тело then.</param>
/// <param name="else_body">Тело else.</param>
/// <param name="loc">Расположение узла.</param>
public if_node(expression_node condition, statement_node then_body, statement_node else_body, location loc) :
base(loc)
{
_condition = condition;
_then_body = then_body;
_else_body = else_body;
}
/// <summary>
/// Конструктор клааса.
/// </summary>
/// <param name="initialization_statement">Выражение инициализации переменной цикла.</param>
/// <param name="while_expr">Условие цикла.</param>
/// <param name="increment_statement">Выражение измененияя счетчика цикла.</param>
/// <param name="body">Тело цикла.</param>
public for_node(statement_node initialization_statement, expression_node while_expr, expression_node init_while_expr,
statement_node increment_statement, statement_node body, location loc) : base(loc)
{
_initialization_statement = initialization_statement;
_while_expr = while_expr;
_init_while_expr = init_while_expr;
_increment_statement = increment_statement;
_body = body;
}
public common_parameter(string name, type_node tp, parameter_type pt,
common_function_node cont_function, concrete_parameter_type conc_par_type, expression_node default_value,
location loc) :
base(name, tp)
{
_par_type = pt;
_cont_function = cont_function;
_concrete_parameter_type = conc_par_type;
_default_value = default_value;
_loc = loc;
}
public question_colon_expression(expression_node condition, expression_node ret_if_true, expression_node ret_if_false,
location loc)
: base(ret_if_true is null_const_node ? ret_if_false.type : ret_if_true.type, loc)
{
this._condition = condition;
this._ret_if_true = ret_if_true;
this._ret_if_false = ret_if_false;
/*if (ret_if_true is null_const_node)
* this.conversion_type = ret_if_false.conversion_type;
* else
* this.conversion_type = ret_if_true.conversion_type;*/
}
public static expression_node convert_delegate_to_return_value_type(location call_location, params expression_node[] parameters)
{
expression_node par = parameters[0];
internal_interface ii = par.type.get_internal_interface(internal_interface_kind.delegate_interface);
delegate_internal_interface dii = (delegate_internal_interface)ii;
common_method_node cmn = dii.invoke_method as common_method_node;
if (cmn != null)
{
expression_node exp = new common_method_call(cmn, par, call_location);
return(exp);
}
compiled_function_node cfn = dii.invoke_method as compiled_function_node;
if (cfn != null)
{
expression_node exp = new compiled_function_call(cfn, par, call_location);
return(exp);
}
return(null);
}
/// <summary>
/// Конструктор узла.
/// </summary>
/// <param name="body">Тело цикла.</param>
/// <param name="condition">Условие.</param>
/// <param name="loc">Расположение узла.</param>
public repeat_node(statement_node body, expression_node condition, location loc) : base(loc)
{
_body = body;
_condition = condition;
}
public foreach_node(var_definition_node _ident, expression_node _in_what, statement_node _what_do, location loc) : base(loc)
{
this._ident = _ident;
this._in_what = _in_what;
this._what_do = _what_do;
}
public lock_statement(expression_node _lock_object, statement_node _body, location loc)
: base(loc)
{
this._lock_object = _lock_object;
this._body = _body;
}
public class_field_reference(class_field field, expression_node obj, location loc) :
base(field.type, loc)
{
_field = field;
_obj = obj;
}
public is_node(expression_node left, type_node right, location loc)
: base(compiled_type_node.get_type_node(typeof(bool)), loc)
{
_left = left;
_right = right;
}
public as_node(expression_node left, type_node right, location loc)
: base(right, loc)
{
_left = left;
_right = right;
}
public statements_expression_node(statement_node_list statements, expression_node expression, location loc)
: base(expression.type, loc)
{
this._statements_list = statements;
this._expression = expression;
}
public expression_node convert_delegates_to_delegates(location call_location, expression_node[] parameters)
{
if (parameters.Length != 1)
{
throw new PascalSharp.Internal.TreeConverter.CompilerInternalError("Invalid delegates convertion");
}
delegate_internal_interface dii_to =
(delegate_internal_interface)_to.get_internal_interface(internal_interface_kind.delegate_interface);
delegate_internal_interface dii =
(delegate_internal_interface)parameters[0].type.get_internal_interface(internal_interface_kind.delegate_interface);
expression_node pr = parameters[0];
base_function_call ifnotnull = null;
if (_to.semantic_node_type == semantic_node_type.compiled_type_node)
{
ifnotnull = new compiled_constructor_call((compiled_constructor_node)dii_to.constructor, call_location);
}
else
{
ifnotnull = new common_constructor_call((common_method_node)dii_to.constructor, call_location);
}
//ccc = new common_constructor_call(dii_to.constructor, call_location);
expression_node par = null;
if (parameters[0].type.semantic_node_type == semantic_node_type.compiled_type_node)
{
par = new compiled_function_call((compiled_function_node)dii.invoke_method, parameters[0], call_location);
}
else
{
par = new common_method_call((common_method_node)dii.invoke_method, parameters[0], call_location);
}
ifnotnull.parameters.AddElement(par);
null_const_node ncn = new null_const_node(_to, call_location);
null_const_node ncn2 = new null_const_node(_to, call_location);
SymbolInfo si = pr.type.find_first_in_type(compiler_string_consts.eq_name);
basic_function_node fn = si.sym_info as basic_function_node;
expression_node condition = null;
if (fn != null)
{
basic_function_call condition_bfc = new basic_function_call(fn, call_location);
condition_bfc.parameters.AddElement(pr);
condition_bfc.parameters.AddElement(ncn);
condition = condition_bfc;
}
else if (si.sym_info is compiled_function_node)
{
compiled_static_method_call condition_cfc = new compiled_static_method_call(si.sym_info as compiled_function_node, call_location);
condition_cfc.parameters.AddElement(pr);
condition_cfc.parameters.AddElement(ncn);
condition = condition_cfc;
}
question_colon_expression qce = new question_colon_expression(condition, ncn2, ifnotnull, call_location);
return(qce);
}
/// <summary>
/// Конструктор узла.
/// </summary>
/// <param name="deref_expr">Выражение-указатель.</param>
/// <param name="loc">Расположение выражения.</param>
public dereference_node(expression_node deref_expr, location loc) :
//base(SystemLibrary.get_pointed_type_by_type(deref_expr.type),loc)
base((deref_expr.type as ref_type_node).pointed_type, loc)
{
_deref_expr = deref_expr;
}
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="condition">Условие цикла.</param>
/// <param name="loc">Расположение узла.</param>
public while_node(expression_node condition, location loc)
: base(loc)
{
_condition = condition;
}
public compiled_function_call(compiled_function_node compiled_method, expression_node obj, location loc) :
base(compiled_method, loc)
{
_obj = obj;
}
public common_method_call(common_method_node method, expression_node obj, location loc)
: base(method, loc)
{
_obj = obj;
_virtual_call = true;
}
public throw_statement_node(expression_node exception, location loc) :
base(loc)
{
_excpetion = exception;
}
public compiled_variable_reference(compiled_variable_definition var, expression_node obj, location loc) :
base(var.type, loc)
{
_var = var;
_obj = obj;
}
/// <summary>
/// Конструктор класса.
/// </summary>
/// <param name="condition">Условие цикла.</param>
/// <param name="body">Тело цикла.</param>
/// <param name="loc">Расположение узла.</param>
public while_node(expression_node condition, statement_node body, location loc) : base(loc)
{
_condition = condition;
_body = body;
}
public nonstatic_event_reference(expression_node obj, event_node en, location loc)
: base(en, loc)
{
_obj = obj;
}
public non_static_property_reference(property_node pn, expression_node obj, location loc) :
base(pn, loc)
{
_en = obj;
}
/// <summary>
/// Конструктор узла.
/// </summary>
/// <param name="addr_of">Выражение, адрес которого мы получаем.</param>
/// <param name="loc">Расположение узла.</param>
public get_addr_node(expression_node addr_of, location loc) :
base(addr_of.type.ref_type, loc)
{
_addr_of = addr_of;
}
