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; }
public double_question_colon_expression(expression_node condition, expression_node ret_if_null, location loc) : base(condition is null_const_node ? ret_if_null.type : condition.type, loc) { this._condition = condition; this._ret_if_null = ret_if_null; }
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; }
/// <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, SemanticTree.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 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); }
private addressed_expression create_class_field_reference(expression_node en, definition_node dn, SyntaxTree.ident id_right) { try_convert_typed_expression_to_function_call(ref en); if (dn.semantic_node_type == semantic_node_type.class_field) { class_field cf = (class_field)dn; if (cf.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferanceToStaticFieldWithExpression(cf, get_location(id_right), en)); } class_field_reference cfr = new class_field_reference(cf, en, get_location(id_right)); //return_value(cfr); return cfr; } if (dn.semantic_node_type == semantic_node_type.compiled_variable_definition) { compiled_variable_definition cfd = (compiled_variable_definition)dn; if (cfd.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferanceToStaticFieldWithExpression(cfd, get_location(id_right), en)); } compiled_variable_reference cfr2 = new compiled_variable_reference(cfd, en, get_location(id_right)); //return_value(cfr2); return cfr2; } #if (DEBUG) throw new CompilerInternalError("Invalid variable kind"); #endif return null; }
private expression_node convert_if_typed_expression_to_function_call(expression_node expr) { if (expr is typed_expression) return convert_typed_expression_to_function_call(expr as typed_expression); return expr; }
private void check_on_loop_variable(expression_node en) { if (context.is_in_cycle() && !SemanticRules.AllowChangeLoopVariable) if (en.semantic_node_type == semantic_node_type.namespace_variable_reference) { if (context.is_loop_variable((en as namespace_variable_reference).var)) AddError(en.location, "CANNOT_ASSIGN_TO_LOOP_VARIABLE"); } else if (en.semantic_node_type == semantic_node_type.local_variable_reference) { if (context.is_loop_variable((en as local_variable_reference).var)) AddError(en.location, "CANNOT_ASSIGN_TO_LOOP_VARIABLE"); } else if (en.semantic_node_type == semantic_node_type.local_block_variable_reference) { if (context.is_loop_variable((en as local_block_variable_reference).var)) AddError(en.location, "CANNOT_ASSIGN_TO_LOOP_VARIABLE"); } }
private expressions_list get_set_initializer(expression_node cnfc) { return set_intls[cnfc]; }
public nonstatic_event_reference(expression_node obj, event_node en, location loc) : base(en, loc) { _obj = obj; }
private void CheckAssign(expression_node p) { switch (p.semantic_node_type) { case semantic_node_type.local_variable_reference: IncreaseNumAssVar((local_variable_reference)p); break; case semantic_node_type.namespace_variable_reference: IncreaseNumAssVar((namespace_variable_reference)p); break; case semantic_node_type.class_field_reference: VisitExpression((p as class_field_reference).obj); IncreaseNumAssField((class_field_reference)p); break; case semantic_node_type.static_class_field_reference: IncreaseNumAssField((static_class_field_reference)p); break; case semantic_node_type.common_parameter_reference: IncreaseNumAssParam((common_parameter_reference)p); break; case semantic_node_type.deref_node: CheckAssign(((dereference_node)p).deref_expr); break; } }
private string_const_node convert_string_const_to_switch(expression_node switch_expr, location loc) { if (switch_expr is string_const_node) return switch_expr as string_const_node; string_const_node scn = null; if (switch_expr is static_compiled_variable_reference && (switch_expr as static_compiled_variable_reference).var.compiled_field.IsLiteral) scn = new string_const_node((string)(switch_expr as static_compiled_variable_reference).var.compiled_field.GetRawConstantValue(), loc); if (scn == null) { AddError(loc, "CONSTANT_EXPRESSION_EXPECTED"); } return scn; }
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 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 compiled_variable_reference(compiled_variable_definition var, expression_node obj, location loc) : base(var.type, loc) { _var = var; _obj = obj; }
public class_field_reference(class_field field, expression_node obj, location loc) : base(field.type, loc) { _field = field; _obj = obj; }
private void return_value(expression_node expr) { ret.return_value(expr); }
public expression_node convert_delegates_to_delegates(location call_location, expression_node[] parameters) { if (parameters.Length != 1) { throw new PascalABCCompiler.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); PascalABCCompiler.TreeConverter.SymbolInfo si = pr.type.find_first_in_type(PascalABCCompiler.TreeConverter.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); }
private addressed_expression address_expression_reciving(SyntaxTree.ident id_right, SymbolInfo si, expression_node en) { if (si != null && si.sym_info != null && si.sym_info.semantic_node_type == semantic_node_type.indefinite_definition_node) { return new indefinite_reference(si.sym_info as indefinite_definition_node, get_location(id_right)); } definition_node dn = null; if (!internal_is_assign) dn = context.check_name_node_type(id_right.name, si, get_location(id_right), general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node); else dn = context.check_name_node_type(id_right.name, si, get_location(id_right), general_node_type.variable_node, general_node_type.property_node, general_node_type.event_node, general_node_type.constant_definition); if (dn.general_node_type == general_node_type.constant_definition) { AddError(get_location(id_right), "CAN_NOT_ASSIGN_TO_CONSTANT_OBJECT"); } switch (dn.general_node_type) { case general_node_type.variable_node: { return create_class_field_reference(en, dn, id_right); } case general_node_type.property_node: { property_node pn = (property_node)dn; if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferenceToStaticPropertyWithExpression(pn, get_location(id_right), pn.comprehensive_type)); } try_convert_typed_expression_to_function_call(ref en); non_static_property_reference pr = new non_static_property_reference(pn, en, get_location(id_right)); return pr; } case general_node_type.event_node: { if (dn.semantic_node_type == semantic_node_type.compiled_event) { compiled_event ce = (compiled_event)dn; if (ce.is_static) { //throw new NonStaticAndStaticEvevnt(); } nonstatic_event_reference ser = new nonstatic_event_reference(en, ce, get_location(id_right)); return ser; } else if (dn.semantic_node_type == semantic_node_type.common_event) { common_event ce = (common_event)dn; if (ce.is_static) { //throw new NonStaticAndStaticEvevnt(); } nonstatic_event_reference ser = new nonstatic_event_reference(en, ce, get_location(id_right)); return ser; } break; } default : return null; } throw new CompilerInternalError("Undefined expression to address reciving"); }
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 throw_statement_node(expression_node exception, location loc) : base(loc) { _excpetion = exception; }
public lock_statement(expression_node _lock_object, statement_node _body, location loc) : base(loc) { this._lock_object = _lock_object; this._body = _body; }
private RetVal GetConstantValue(expression_node en) { if (en is bool_const_node) { if ((en as bool_const_node).constant_value) return RetVal.True; else return RetVal.False; } else return RetVal.Undef; }
public as_node(expression_node left, type_node right, location loc) : base(right, loc) { _left = left; _right = right; }
internal expression_node make_assign_operator(addressed_expression left, expression_node right, location loc) { return find_operator(compiler_string_consts.assign_name, left, right, loc); }
/// <summary> /// Конструктор класса. /// </summary> /// <param name="condition">Условие цикла.</param> /// <param name="loc">Расположение узла.</param> public while_node(expression_node condition, location loc) : base(loc) { _condition = condition; }
private void add_set_initializer(expression_node cnfc, expressions_list exprs) { set_intls[cnfc] = exprs; }
/// <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; }
private expression_node create_with_expression(expression_node expr) { location sl = expr.location; switch (expr.semantic_node_type) { case semantic_node_type.common_namespace_function_call: case semantic_node_type.common_in_function_function_call: case semantic_node_type.common_method_call: case semantic_node_type.common_static_method_call: case semantic_node_type.compiled_function_call: case semantic_node_type.compiled_constructor_call: case semantic_node_type.common_constructor_call: case semantic_node_type.compiled_static_method_call: return convertion_data_and_alghoritms.CreateVariableReference(context.add_var_definition(compiler_string_consts.GetTempVariableName(), sl, expr.type, expr), sl); case semantic_node_type.class_field_reference: (expr as class_field_reference).obj = create_with_expression((expr as class_field_reference).obj); return expr; case semantic_node_type.compiled_variable_reference: (expr as compiled_variable_reference).obj = create_with_expression((expr as compiled_variable_reference).obj); return expr; case semantic_node_type.simple_array_indexing: simple_array_indexing sar = expr as simple_array_indexing; sar.simple_arr_expr = create_with_expression(sar.simple_arr_expr); sar.ind_expr = create_with_expression(sar.ind_expr); return sar; case semantic_node_type.deref_node: (expr as dereference_node).deref_expr = create_with_expression((expr as dereference_node).deref_expr); return expr; case semantic_node_type.basic_function_call: return convertion_data_and_alghoritms.CreateVariableReference(context.add_var_definition(compiler_string_consts.GetTempVariableName(), sl, expr.type, expr), sl); case semantic_node_type.as_node: return convertion_data_and_alghoritms.CreateVariableReference(context.add_var_definition(compiler_string_consts.GetTempVariableName(), sl, expr.type, expr), sl); } return expr; }
/// <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; }
private void try_convert_typed_expression_to_function_call(ref expression_node en) { if (en.semantic_node_type == semantic_node_type.typed_expression) { en = convert_typed_expression_to_function_call((typed_expression)en); } }
private expression_node find_operator(SyntaxTree.Operators ot, expression_node expr, location loc) { string name = name_reflector.get_name(ot); //#if (DEBUG) if (name == null) { if (ot == PascalABCCompiler.SyntaxTree.Operators.AddressOf) { if (expr.is_addressed == false) { AddError(expr.location, "CAN_NOT_GET_ADDRESS_FROM_EXPRESSION"); } expression_node res = new get_addr_node(expr, loc); return res; } if (ot == PascalABCCompiler.SyntaxTree.Operators.Dereference) { } throw new CompilerInternalError("Invalid operator name"); } //#endif SymbolInfo si = expr.type.find(name, context.CurrentScope); if (si == null || si.sym_info is wrapped_definition_node) { AddError(new OperatorCanNotBeAppliedToThisType(name, expr)); } expressions_list pars = new expressions_list(); pars.AddElement(expr); function_node fn = convertion_data_and_alghoritms.select_function(pars, si, loc); expr = pars[0]; if (fn == null) { AddError(new OperatorCanNotBeAppliedToThisType(name, expr)); } #if (DEBUG) convertion_data_and_alghoritms.check_operator(fn); #endif expression_node exp_node = convertion_data_and_alghoritms.create_simple_function_call(fn, loc, expr); return exp_node; }
private base_function_call create_not_static_method_call(function_node fn, expression_node en, location loc, bool procedure_allowed) { try_convert_typed_expression_to_function_call(ref en); if ((!procedure_allowed) && (fn.return_value_type == null)) { AddError(loc, "FUNCTION_EXPECTED_PROCEDURE_{0}_MEET", fn); } if (fn.semantic_node_type == semantic_node_type.common_method_node) { common_method_node cmn = (common_method_node)fn; if (cmn.is_constructor) { AddError(loc, "CAN_NOT_CALL_CONSTRUCTOR_AS_PROCEDURE"); } if (cmn.original_function != null && cmn.original_function is compiled_function_node && (cmn.original_function as compiled_function_node).ConnectedToType != null) { common_static_method_call csmc = new common_static_method_call(cmn, loc); return csmc; } if (cmn.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotCallStaticMethodWithExpression(en, fn)); } common_method_call cmc = new common_method_call(cmn, en, loc); cmc.virtual_call = !inherited_ident_processing; return cmc; } if (fn.semantic_node_type == semantic_node_type.compiled_function_node) { compiled_function_node cfn = (compiled_function_node)fn; if (cfn.ConnectedToType != null) { compiled_static_method_call csmc = new compiled_static_method_call(cfn, loc); return csmc; } else { if (cfn.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { if (!cfn.is_extension_method) AddError(new CanNotCallStaticMethodWithExpression(en, fn)); else return new compiled_static_method_call(cfn, loc); } compiled_function_call cfc = new compiled_function_call(cfn, en, loc); cfc.virtual_call = !inherited_ident_processing; return cfc; } } if (fn.semantic_node_type == semantic_node_type.compiled_constructor_node) { AddError(loc, "CAN_NOT_CALL_CONSTRUCTOR_AS_PROCEDURE"); } if (fn.semantic_node_type == semantic_node_type.common_namespace_function_node && (fn as common_namespace_function_node).ConnectedToType != null) { common_namespace_function_call cnfc = new common_namespace_function_call(fn as common_namespace_function_node,loc); //cnfc.parameters.AddElement(en); return cnfc; } if (fn.semantic_node_type == semantic_node_type.indefinite_definition_node) { indefinite_function_call ifc = new indefinite_function_call(fn, loc); return ifc; } throw new CompilerInternalError("Invalid method kind"); }
private static expression_node inc_value_compile_time_executor(location call_location, expression_node[] expr) { return null; /* if (expr.Length != 1) { return null; } expression_node value_to_inc = expr[0]; internal_interface ii=value_to_inc.type.get_internal_interface(internal_interface_kind.ordinal_interface); if (ii == null) { throw new CompilerInternalError("This method must be called only with ordinal types."); } ordinal_type_interface oti = (ordinal_type_interface)ii; constant_node cn = value_to_inc as constant_node; if (cn != null) { if (compare_ordinal_type(cn, oti.upper_value, oti.greater_eq_method.compile_time_executor,call_location)) { throw new CanNotIncrementOrdinalTypeValue(cn); } return (oti.internal_inc_value.compile_time_executor(call_location,cn)); } else { } */ }
private expression_node expression_value_reciving(SyntaxTree.ident id_right, SymbolInfo si, expression_node en, bool expected_delegate) { definition_node dn = context.check_name_node_type(id_right.name, si, get_location(id_right), general_node_type.variable_node, general_node_type.function_node, general_node_type.property_node, general_node_type.constant_definition); switch (dn.general_node_type) { /*case general_node_type.constant_defenition: { constant_definition_node cdn=(constant_definition_node)dn; return cdn.const_value; }*/ case general_node_type.variable_node: { return create_class_field_reference(en, dn, id_right); } case general_node_type.function_node: { if (dn.semantic_node_type == semantic_node_type.indefinite_definition_node) { return new indefinite_reference(dn as indefinite_definition_node, get_location(id_right)); } if (expected_delegate) return make_delegate_wrapper(en, si, get_location(id_right), false); else { function_node fn = convertion_data_and_alghoritms.select_function(new expressions_list(), si, get_location(id_right)); return create_not_static_method_call(fn, en, get_location(id_right), false); } } case general_node_type.property_node: { property_node pn = (property_node)dn; if (pn.polymorphic_state == SemanticTree.polymorphic_state.ps_static) { AddError(new CanNotReferenceToStaticPropertyWithExpression(pn, get_location(id_right), pn.comprehensive_type)); } function_node fn = pn.get_function; if (fn == null) { AddError(new ThisPropertyCanNotBeReaded(pn, get_location(id_right))); } location lloc = get_location(id_right); check_property_no_params(pn, lloc); return create_not_static_method_call(fn, en, lloc, false); } case general_node_type.constant_definition: { //throw new ConstMemberCannotBeAccessedWithAnInstanceReference((class_constant_definition)dn, get_location(id_right)); return ((constant_definition_node)dn).const_value; } } throw new CompilerInternalError("Invalid class member"); }
internal static expression_node delegated_empty_method(location call_loc,expression_node[] expr) { if (expr.Length != 1) { return null; } return expr[0]; }
private void dot_node_as_expression_dot_ident(expression_node en, SyntaxTree.ident id_right, motivation mot, addressed_value syntax_node) { if (en is typed_expression) try_convert_typed_expression_to_function_call(ref en); SymbolInfo si = en.type.find_in_type(id_right.name, context.CurrentScope); if (si == null) { AddError(new MemberIsNotDeclaredInType(id_right, get_location(id_right), en.type)); } try_convert_typed_expression_to_function_call(ref en); /* if (en.semantic_node_type == semantic_node_type.typed_expression) { type_node tn11=en.type; delegated_methods dm11=tn11 as delegated_methods; if (dm11!=null) { en = dm11.empty_param_method; } } */ switch (mot) { case motivation.address_reciving: { return_addressed_value(address_expression_reciving(id_right, si, en)); return; } case motivation.expression_evaluation: { //en = expression_value_reciving(id_right, si, en, true); //try_convert_typed_expression_to_function_call(ref en); //return_value(en); if (si.sym_info is function_node && (si.sym_info as function_node).is_extension_method) { dot_node dnode = new dot_node(syntax_node, id_right); method_call mc = new method_call(dnode, new expression_list()); mc.visit(this); return; } return_value(expression_value_reciving(id_right, si, en, true)); return; } case motivation.semantic_node_reciving: { return_semantic_value(expression_value_reciving(id_right, si, en, true)); return; } } throw new CompilerInternalError("Invalid motivation."); }
private void FixupExpressionPosition(expression_node expr) { List<int> poses = exprs_cache[expr]; //System.Diagnostics.Debug.WriteLine(pos); foreach (int pos in poses) { int tmp = (int)bw.BaseStream.Position; bw.Seek(pos,SeekOrigin.Begin); bw.Write(tmp); bw.Seek(tmp,SeekOrigin.Begin); } }
private int_const_node convert_const_to_switch(expression_node switch_expr, ordinal_type_interface oti, type_node case_expr_type, location loc) { convertion_data_and_alghoritms.convert_type(switch_expr, case_expr_type, loc); if (switch_expr is int_const_node) return switch_expr as int_const_node; //switch_expr = convertion_data_and_alghoritms.create_simple_function_call(oti.value_to_int, // loc, switch_expr); int_const_node icn = null;//switch_expr as constant_node; if (switch_expr is byte_const_node) icn = new int_const_node((switch_expr as byte_const_node).constant_value, loc); else if (switch_expr is sbyte_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as sbyte_const_node).constant_value), loc); else if (switch_expr is short_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as short_const_node).constant_value), loc); else if (switch_expr is ushort_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as ushort_const_node).constant_value), loc); /*else if (switch_expr is uint_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as uint_const_node).constant_value),loc); else if (switch_expr is long_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as long_const_node).constant_value),loc); else if (switch_expr is ulong_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as ulong_const_node).constant_value),loc);*/ else if (switch_expr is bool_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as bool_const_node).constant_value), loc); else if (switch_expr is char_const_node) icn = new int_const_node(Convert.ToInt32((switch_expr as char_const_node).constant_value), loc); else if (switch_expr is enum_const_node) icn = new int_const_node((switch_expr as enum_const_node).constant_value, loc); else if (switch_expr is static_compiled_variable_reference && (switch_expr as static_compiled_variable_reference).var.compiled_field.IsLiteral) icn = new int_const_node((int)(switch_expr as static_compiled_variable_reference).var.compiled_field.GetRawConstantValue(), loc); //учти здесь модет быть и long! //-DarkStar Add if (icn == null) { AddError(loc, "CONSTANT_EXPRESSION_EXPECTED"); } return icn; }
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 return_node(expression_node return_expr,location loc) : base(loc) { _return_expr=return_expr; }
/// <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; }
private static expression_node dec_compile_time_executor(location call_location, expression_node[] expr) { return null; }
/// <summary> /// Конструктор узла. /// </summary> /// <param name="deref_expr">Выражение-указатель.</param> /// <param name="loc">Расположение выражения.</param> public dereference_node(expression_node deref_expr, location loc) : //base(PascalABCCompiler.SystemLibrary.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; }
private void SaveExpressionAndOffset(expression_node expr) { List<int> lst = null; if (!exprs_cache.ContainsKey(expr)) { lst = new List<int>(); exprs_cache[expr] = lst; } else lst = exprs_cache[expr]; lst.Add((int)bw.BaseStream.Position); //System.Diagnostics.Debug.WriteLine((int)bw.BaseStream.Position); }
private void check_expression_for_assign(expression_node expr, location loc) { if (expr is namespace_constant_reference || expr is function_constant_reference) AddError(loc, "LEFT_SIDE_CANNOT_BE_ASSIGNED_TO"); else if (expr is class_field_reference) check_field_reference_for_assign(expr as class_field_reference,loc); else if (expr is simple_array_indexing) check_expression_for_assign((expr as simple_array_indexing).simple_arr_expr,loc); }
public non_static_property_reference(property_node pn, expression_node obj, location loc) : base(pn, loc) { _en = obj; }
private expression_node clip_expression_if_need(expression_node expr, type_node tn) { if (!(tn is short_string_type_node) && tn.type_special_kind != SemanticTree.type_special_kind.set_type) return expr; if (tn is short_string_type_node) { return convertion_data_and_alghoritms.create_simple_function_call(SystemLibrary.SystemLibInitializer.ClipShortStringProcedure.sym_info as function_node,null,convertion_data_and_alghoritms.convert_type(expr,SystemLibrary.SystemLibrary.string_type),new int_const_node((tn as short_string_type_node).Length,null)); } else if (tn.type_special_kind == SemanticTree.type_special_kind.set_type && tn.element_type != null) { ordinal_type_interface oti = tn.element_type.get_internal_interface(internal_interface_kind.ordinal_interface) as ordinal_type_interface; if (oti != null) { base_function_call cmc = null; if (SystemLibrary.SystemLibInitializer.ClipFunction.sym_info is common_namespace_function_node) cmc = new common_namespace_function_call(SystemLibrary.SystemLibInitializer.ClipFunction.sym_info as common_namespace_function_node, null); else cmc = new compiled_static_method_call(SystemLibrary.SystemLibInitializer.ClipFunction.sym_info as compiled_function_node, null); cmc.parameters.AddElement(expr); cmc.parameters.AddElement(oti.lower_value.get_constant_copy(null)); cmc.parameters.AddElement(oti.upper_value.get_constant_copy(null)); cmc.ret_type = tn; return cmc; } else if (tn.element_type.type_special_kind == SemanticTree.type_special_kind.short_string) { base_function_call cmc = null; if (SystemLibrary.SystemLibInitializer.ClipShortStringInSetFunction.sym_info is common_namespace_function_node) cmc = new common_namespace_function_call(SystemLibrary.SystemLibInitializer.ClipShortStringInSetFunction.sym_info as common_namespace_function_node, null); else cmc = new compiled_static_method_call(SystemLibrary.SystemLibInitializer.ClipShortStringInSetFunction.sym_info as compiled_function_node, null); cmc.parameters.AddElement(expr); cmc.parameters.AddElement(new int_const_node((tn.element_type as short_string_type_node).Length, null)); cmc.ret_type = tn; return cmc; } } return expr; }
private void CheckType(type_node type, expression_node initial_value, location loc) { if (type.type_special_kind == SemanticTree.type_special_kind.array_wrapper) { AddHint("DO_NOT_USE_STATIC_ARRAYS", loc); } else if (type.IsPointer && type.element_type.is_value_type && type.element_type is common_type_node) { AddHint("DO_NOT_USE_POINTERS_TO_RECORDS", loc); } else if (type.type_special_kind == SemanticTree.type_special_kind.short_string) { AddHint("DO_NOT_USE_SHORT_STRINGS", loc); } }
public override void visit(SyntaxTree.try_stmt _try_stmt) { context.enter_code_block_without_bind(); context.enter_exception_handlers(); statement_node try_statements = convert_strong(_try_stmt.stmt_list); context.leave_code_block(); location loc = get_location(_try_stmt); exception_filters_list efl = new exception_filters_list(); SyntaxTree.try_handler_except try_hand_except = _try_stmt.handler as SyntaxTree.try_handler_except; if (try_hand_except != null) { if (try_hand_except.except_block.handlers != null) { int hand_count = try_hand_except.except_block.handlers.handlers.Count; for (int i = 0; i < hand_count; i++) { SyntaxTree.exception_handler eh = try_hand_except.except_block.handlers.handlers[i]; type_node filter_type = convert_strong(eh.type_name); if (!SemanticRules.GenerateNativeCode && !(filter_type.is_generic_parameter || filter_type == SystemLibrary.SystemLibrary.exception_base_type || type_table.is_derived(SystemLibrary.SystemLibrary.exception_base_type, filter_type))) { AddError(get_location(eh.type_name), "EXCEPTION_TYPE_MUST_BE_SYSTEM_EXCEPTION_OR_DERIVED_FROM_EXCEPTION"); } current_catch_excep = new int_const_node(2,null);//create_constructor_call(filter_type, new expressions_list(), null); local_block_variable_reference lvr = null; context.enter_code_block_without_bind(); if (eh.variable != null) { context.check_name_redefinition = false; local_block_variable lbv = context.add_var_definition(eh.variable.name, get_location(eh.variable), filter_type, SemanticTree.polymorphic_state.ps_common) as local_block_variable; context.check_name_redefinition = true; lvr = new local_block_variable_reference(lbv, lbv.loc); } statement_node stm = convert_strong(eh.statements); context.leave_code_block(); /*if (eh.variable != null) { context.leave_scope(); }*/ exception_filter ef = new exception_filter(filter_type, lvr, stm, get_location(eh)); efl.AddElement(ef); current_catch_excep = null; } } else { context.enter_code_block_without_bind(); exception_filter ef = new exception_filter(null, null, convert_strong(try_hand_except.except_block.stmt_list), get_location(try_hand_except.except_block.stmt_list)); context.leave_code_block(); efl.AddElement(ef); } if (try_hand_except.except_block.else_stmt_list != null) { context.enter_code_block_without_bind(); statement_node else_stm = convert_strong(try_hand_except.except_block.else_stmt_list); context.leave_code_block(); type_node ftype = SystemLibrary.SystemLibrary.object_type; exception_filter else_ef = new exception_filter(ftype, null, else_stm, else_stm.location); efl.AddElement(else_ef); } } else { type_node filter_type = compiled_type_node.get_type_node(NetHelper.NetHelper.FindType(compiler_string_consts.ExceptionName)); expression_node current_catch_excep = create_constructor_call(filter_type, new expressions_list(), null); local_block_variable_reference lvr = null; local_block_variable tmp_var = context.add_var_definition(context.BuildName("$try_temp" + UniqueNumStr()), null, SystemLibrary.SystemLibrary.bool_type, null) as local_block_variable; statements_list stm = new statements_list(null); SyntaxTree.try_handler_finally try_hndlr_finally = _try_stmt.handler as SyntaxTree.try_handler_finally; context.enter_code_block_without_bind(); statement_node finally_stmt = convert_strong(try_hndlr_finally.stmt_list); context.leave_code_block(); stm.statements.AddElement(finally_stmt); basic_function_call bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_not as basic_function_node,null); bfc.parameters.AddElement(new local_block_variable_reference(tmp_var,null)); stm.statements.AddElement(new if_node(bfc,new rethrow_statement_node(null),null,null)); exception_filter ef = new exception_filter(filter_type, lvr, stm, null); efl.AddElement(ef); bfc = new basic_function_call(SystemLibrary.SystemLibrary.bool_assign as basic_function_node,null); bfc.parameters.AddElement(new local_block_variable_reference(tmp_var,null)); bfc.parameters.AddElement(new bool_const_node(true,null)); (try_statements as statements_list).statements.AddElement(bfc); (try_statements as statements_list).statements.AddElement(new throw_statement_node(current_catch_excep,null)); return_value(new try_block(try_statements, null, efl, loc)); context.leave_exception_handlers(); return; } statement_node finally_st = null; SyntaxTree.try_handler_finally try_handler_finally = _try_stmt.handler as SyntaxTree.try_handler_finally; if (try_handler_finally != null) { context.enter_code_block_without_bind(); finally_st = convert_strong(try_handler_finally.stmt_list); context.leave_code_block(); } try_block tb = new try_block(try_statements, finally_st, efl, loc); context.leave_exception_handlers(); return_value(tb); }
private void VisitExpression(expression_node en) { if (en == null) return; //WriteDebugInfo(en.location); switch (en.semantic_node_type) { case semantic_node_type.exit_procedure: /*ничего писать не надо*/ break; case semantic_node_type.typeof_operator: //VisitTypeOfOperator((typeof_operator)en); break; case semantic_node_type.statement_expression_node: VisitStatementsExpressionNode((statements_expression_node)en); break; case semantic_node_type.question_colon_expression: VisitQuestionColonExpression((question_colon_expression)en); break; case semantic_node_type.sizeof_operator: VisitSizeOfOperator((sizeof_operator)en); break; case semantic_node_type.is_node: VisitIsNode((is_node)en); break; case semantic_node_type.as_node: VisitAsNode((as_node)en); break; case semantic_node_type.compiled_static_method_call_node_as_constant: //VisitCompiledStaticMethodCallNodeAsConstant((compiled_static_method_call_as_constant)en); break; case semantic_node_type.array_initializer: VisitArrayInitializer((array_initializer)en); break; case semantic_node_type.record_initializer: VisitRecordInitializer((record_initializer)en); break; case semantic_node_type.array_const: //VisitArrayConst((array_const)en); break; case semantic_node_type.record_const: //VisitRecordConst((record_constant)en); break; case semantic_node_type.float_const_node: //VisitFloatConst((float_const_node)en); break; case semantic_node_type.byte_const_node: //VisitByteConstNode((byte_const_node)en); break; case semantic_node_type.int_const_node: //VisitIntConstNode((int_const_node)en); break; case semantic_node_type.sbyte_const_node: //VisitSByteConstNode((sbyte_const_node)en); break; case semantic_node_type.short_const_node: //VisitShortConstNode((short_const_node)en); break; case semantic_node_type.ushort_const_node: //VisitUShortConstNode((ushort_const_node)en); break; case semantic_node_type.uint_const_node: //VisitUIntConstNode((uint_const_node)en); break; case semantic_node_type.ulong_const_node: //VisitULongConstNode((ulong_const_node)en); break; case semantic_node_type.long_const_node: //VisitLongConstNode((long_const_node)en); break; case semantic_node_type.double_const_node: //VisitDoubleConstNode((double_const_node)en); break; case semantic_node_type.char_const_node: //VisitCharConstNode((char_const_node)en); break; case semantic_node_type.bool_const_node: //VisitBoolConstNode((bool_const_node)en); break; case semantic_node_type.string_const_node: //VisitStringConstNode((string_const_node)en); break; case semantic_node_type.local_variable_reference: VisitLocalVariableReference((local_variable_reference)en); break; case semantic_node_type.namespace_variable_reference: VisitNamespaceVariableReference((namespace_variable_reference)en); break; case semantic_node_type.basic_function_call: VisitBasicFunctionCall((basic_function_call)en); break; case semantic_node_type.common_parameter_reference: VisitCommonParameterReference((common_parameter_reference)en); break; case semantic_node_type.common_namespace_function_call: VisitCommonNamespaceFunctionCall((common_namespace_function_call)en); break; case semantic_node_type.basic_function_call_node_as_constant: VisitBasicFunctionCall((en as basic_function_call_as_constant).method_call); break; case semantic_node_type.common_namespace_function_call_node_as_constant: VisitCommonNamespaceFunctionCallAsConstant((common_namespace_function_call_as_constant)en); break; case semantic_node_type.common_in_function_function_call: VisitCommonInFuncFuncCall((common_in_function_function_call)en); break; case semantic_node_type.while_break_node: //VisitWhileBreakNode((while_break_node)en); is_break_stmt = true; break; case semantic_node_type.while_continue_node: //VisitWhileContinueNode((while_continue_node)en); is_break_stmt = true; break; case semantic_node_type.for_break_node: //VisitForBreakNode((for_break_node)en); is_break_stmt = true; break; case semantic_node_type.for_continue_node: //VisitForContinueNode((for_continue_node)en); is_break_stmt = true; break; case semantic_node_type.repeat_break_node: //VisitRepeatBreakNode((repeat_break_node)en); is_break_stmt = true; break; case semantic_node_type.repeat_continue_node: //VisitRepeatContinueNode((repeat_continue_node)en); is_break_stmt = true; break; case semantic_node_type.foreach_break_node: is_break_stmt = true; break; case semantic_node_type.foreach_continue_node: is_break_stmt = true; break; case semantic_node_type.common_static_method_call: VisitCommonStaticMethodCall((common_static_method_call)en); break; case semantic_node_type.compiled_static_method_call: VisitCompiledStaticMethodCall((compiled_static_method_call)en); break; case semantic_node_type.class_field_reference: VisitClassFieldReference((class_field_reference)en); break; case semantic_node_type.deref_node: VisitDerefNode((dereference_node)en); break; case semantic_node_type.common_method_call: VisitCommonMethodCall((common_method_call)en); break; case semantic_node_type.compiled_function_call: VisitCompiledFunctionCall((compiled_function_call)en); break; case semantic_node_type.get_addr_node: VisitGetAddrNode((get_addr_node)en); break; case semantic_node_type.common_constructor_call: VisitCommonConstructorCall((common_constructor_call)en); break; case semantic_node_type.compiled_constructor_call: VisitCompiledConstructorCall((compiled_constructor_call)en); break; case semantic_node_type.compiled_variable_reference: VisitCompiledVariableReference((compiled_variable_reference)en); break; case semantic_node_type.local_block_variable_reference: VisitLocalBlockVariableReference((local_block_variable_reference)en); break; case semantic_node_type.static_compiled_variable_reference: //VisitStaticCompiledVariableReference((static_compiled_variable_reference)en); break; case semantic_node_type.static_class_field_reference: VisitStaticClassFieldReference((static_class_field_reference)en); break; case semantic_node_type.non_static_property_reference: VisitNonStaticPropertyReference((non_static_property_reference)en); break; case semantic_node_type.simple_array_indexing: VisitSimpleArrayIndexing((simple_array_indexing)en); break; case semantic_node_type.this_node: //VisitThisNode((this_node)en); break; case semantic_node_type.null_const_node: //VisitNullConstNode((null_const_node)en); break; //default: ;//Console.WriteLine(en.semantic_node_type); throw new Exception("Unknown expression"); } }
internal expression_node get_init_call_for_set_as_constr(var_definition_node vdn, expression_node init_value) { location loc = (vdn.type as common_type_node).loc; if (!SystemUnitAssigned) AddError(new NotSupportedError(loc)); //Когда заработает наследование конструкторов надо вставить это /* expression_node var_ref = create_variable_reference(vdn, loc); expressions_list exl = new expressions_list(); exl.AddElement(new typeof_operator(element_type, loc)); base_function_call bfc = create_constructor_call(vdn.type, exl, loc); expression_node expr = find_operator(compiler_string_consts.assign_name, var_ref, bfc, loc); */ type_node tn = vdn.type; vdn.type = SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as type_node; expression_node var_ref = create_variable_reference(vdn, loc); expressions_list exl = new expressions_list(); //exl.AddElement(var_ref); //exl.AddElement(new typeof_operator(element_type, loc)); if (tn.element_type == SystemLibrary.SystemLibrary.byte_type) { exl.AddElement(new byte_const_node(byte.MinValue,null)); exl.AddElement(new byte_const_node(byte.MaxValue,null)); } else if (tn.element_type == SystemLibrary.SystemLibrary.sbyte_type) { exl.AddElement(new sbyte_const_node(sbyte.MinValue,null)); exl.AddElement(new sbyte_const_node(sbyte.MaxValue,null)); } else if (tn.element_type == SystemLibrary.SystemLibrary.short_type) { exl.AddElement(new short_const_node(short.MinValue,null)); exl.AddElement(new short_const_node(short.MaxValue,null)); } else if (tn.element_type == SystemLibrary.SystemLibrary.ushort_type) { exl.AddElement(new ushort_const_node(ushort.MinValue,null)); exl.AddElement(new ushort_const_node(ushort.MaxValue,null)); } else if (tn.element_type.type_special_kind == SemanticTree.type_special_kind.diap_type || tn.element_type.type_special_kind == SemanticTree.type_special_kind.enum_kind) { ordinal_type_interface ii = tn.element_type.get_internal_interface(internal_interface_kind.ordinal_interface) as ordinal_type_interface; exl.AddElement(ii.lower_value); exl.AddElement(ii.upper_value); } exl.AddElement(init_value); function_node fn = null; if (exl.Count > 1) { fn = convertion_data_and_alghoritms.select_function(exl, (SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as type_node).find_in_type(compiler_string_consts.default_constructor_name), loc); } else { fn = convertion_data_and_alghoritms.select_function(exl, (SystemLibrary.SystemLibInitializer.TypedSetType.sym_info as type_node).find_in_type(compiler_string_consts.default_constructor_name), loc); } //expression_node expr = convertion_data_and_alghoritms.create_simple_function_call(fn, null, exl.ToArray()); expression_node expr = create_static_method_call_with_params(fn, loc, tn, false, exl); vdn.type = tn; return expr; }