public void for_assignment(object lr0, object lr2) { if (lr0 is ident && lr2 is ident && ((ident)lr2).name.Contains("__lambda__")) { string type_name = ""; var_def_statement vds = find_var_statements(((ident)lr0).name); if (vds != null) { type_name = ((named_type_reference)vds.vars_type).names[0].name; } if (type_name != "") { int ii = 0; while (ii < pascalABC_type_declarations.Count && ((type_declaration)pascalABC_type_declarations[ii]).type_name.name != type_name) { ii++; } if (ii < pascalABC_type_declarations.Count) { type_definition td = ((type_declaration)pascalABC_type_declarations[ii]).type_def; function_lambda_definition fld = find_pascalABC_lambda_name(((ident)lr2).name); fld.return_type = ((function_header)td).return_type; for (int k = 0; k < fld.formal_parameters.params_list.Count && k < ((function_header)td).parameters.params_list.Count; k++) { fld.formal_parameters.params_list[k].vars_type = ((function_header)td).parameters.params_list[k].vars_type; } } pascalABC_var_statements.Remove(vds); } } }
public for_node NewForStmt(bool opt_var, ident identifier, type_definition for_stmt_decl_or_assign, expression expr1, for_cycle_type fc_type, expression expr2, token_info opt_tk_do, statement stmt, LexLocation loc) { var nfs = new for_node(identifier, expr1, expr2, stmt, fc_type, null, for_stmt_decl_or_assign, opt_var != false, loc); if (opt_tk_do == null) { file_position fp = expr2.source_context.end_position; syntax_tree_node err_stn = stmt; if (err_stn == null) { err_stn = expr2; } parsertools.errors.Add(new PABCNETUnexpectedToken(parsertools.CurrentFileName, StringResources.Get("TKDO"), new SourceContext(fp.line_num, fp.column_num + 1, fp.line_num, fp.column_num + 1, 0, 0), err_stn)); } if (!opt_var && for_stmt_decl_or_assign == null) { parsertools.AddWarningFromResource("USING_UNLOCAL_FOR_VARIABLE", identifier.source_context); } return(nfs); }
public SymInfoSyntax(ident Id, SymKind SK, type_definition Td = null, Attributes Attr = 0) { this.Id = Id; this.Td = Td; this.SK = SK; this.Attr = Attr; }
public void AddSymbols(List <ident> names, SymKind kind, type_definition td = null, Attributes attr = 0) { foreach (var n in names) { AddSymbol(n, kind, td, attr); } }
private expression convert_cast_expression(ICSharpCode.NRefactory.Ast.CastExpression expr) { type_definition td = get_type_reference(expr.CastTo); expression exp = get_expression(expr.Expression); return(new typecast_node(exp as addressed_value, td, op_typecast.typecast)); }
public static var_statement CreateVarStatementNode(string idName, type_definition varType, expression initValue) { var id = new ident(idName); var idlist = new ident_list(id); var vdef = new var_def_statement(idlist, varType, initValue, definition_attribute.None, false, null); return(new var_statement(vdef, null)); }
private static where_definition GetWhereRestriction(type_definition restriction, ident templateName) { return // where (new where_definition( // ConstraintTC : new ident_list(templateName), new where_type_specificator_list(new List <type_definition> { // IConstraint<T, C>, restriction, // constructor new declaration_specificator(DeclarationSpecificator.WhereDefConstructor, "constructor") }))); }
public typecast_node NewAsIsExpr(syntax_tree_node term, op_typecast typecast_op, type_definition simple_or_template_type_reference, LexLocation loc) { var naie = new typecast_node((addressed_value)term, simple_or_template_type_reference, typecast_op, loc); if (!(term is addressed_value)) { parsertools.errors.Add(new bad_operand_type(parsertools.CurrentFileName, term.source_context, naie)); } return(naie); }
private void CheckIfCanBeMatched(expression matchedExpression, type_definition targetType) { var type = convert_strong(targetType); var expression = convert_strong(matchedExpression).type; if (type_table.is_derived(type, expression) || type_table.is_derived(expression, type) || AreTheSameType(type, expression) || type.IsInterface && expression.IsInterface) { return; } AddError(get_location(matchedExpression), "EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expression.name, type.name); }
private void CheckIfCanBeMatched(expression matchedExpression, type_definition targetType) { var type = convert_strong(targetType); var expression = convert_strong(matchedExpression); if (expression is typed_expression) { try_convert_typed_expression_to_function_call(ref expression); } var expressionType = expression.type; if (type_table.is_derived(type, expressionType) || type_table.is_derived(expressionType, type) || AreTheSameType(type, expressionType) || type.IsInterface || expressionType.IsInterface || type.is_generic_parameter || expressionType.is_generic_parameter) { return; } AddError(get_location(matchedExpression), "EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expressionType.name, type.name); }
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 virtual void visit(type_definition _type_definition) { DefaultVisit(_type_definition); }
public virtual void post_do_visit(type_definition _type_definition) { }
public override void visit(type_definition _type_definition) { DefaultVisit(_type_definition); pre_do_visit(_type_definition); visit(type_definition.attr_list); post_do_visit(_type_definition); }
void semantic_check_for_new_range(SyntaxTree.diapason_expr_new diap, type_definition td, ident id) { var from = diap.left; var to = diap.right; var semfrom = convert_strong(from); var b = convertion_data_and_alghoritms.can_convert_type(semfrom, SystemLibrary.SystemLibrary.integer_type); var b1 = false; if (!b) { b1 = convertion_data_and_alghoritms.can_convert_type(semfrom, SystemLibrary.SystemLibrary.char_type); } if (!b && !b1) { AddError(get_location(from), "INTEGER_OR_CHAR_VALUE_EXPECTED"); } var semto = convert_strong(to); var c = convertion_data_and_alghoritms.can_convert_type(semto, SystemLibrary.SystemLibrary.integer_type); var c1 = false; if (!c) { c1 = convertion_data_and_alghoritms.can_convert_type(semto, SystemLibrary.SystemLibrary.char_type); } if (!c && !c1) { AddError(get_location(to), "INTEGER_OR_CHAR_VALUE_EXPECTED"); } if (b != c || c1 != b1) { AddError(get_location(to), "INCOMPATIBLE_DIAPASON_BOUNDS_TYPES"); } if (td != null && !(td is no_type_foreach)) { // то мы определили тип явно в заголовке var semtype = convert_strong(td); var d = convertion_data_and_alghoritms.can_convert_type(semtype, SystemLibrary.SystemLibrary.integer_type); var d1 = false; if (!d) { d1 = convertion_data_and_alghoritms.can_convert_type(semtype, SystemLibrary.SystemLibrary.char_type); } if (!d && !d1) { AddError(get_location(td), "INTEGER_OR_CHAR_VALUE_EXPECTED"); } if (b != d || b1 != d1) { AddError(get_location(id), "INCOMPATIBLE_TYPES_OF_ELEMENT_AND_DIAPASON"); } } else if (td == null) { var semid = convert_strong(id); var e = convertion_data_and_alghoritms.can_convert_type(semid, SystemLibrary.SystemLibrary.integer_type); var e1 = false; if (!e) { e1 = convertion_data_and_alghoritms.can_convert_type(semid, SystemLibrary.SystemLibrary.char_type); } if (!e && !e1) { AddError(get_location(id), "INTEGER_OR_CHAR_VALUE_EXPECTED"); } if (b != e || b1 != e1) { AddError(get_location(id), "INCOMPATIBLE_TYPES_OF_ELEMENT_AND_DIAPASON"); } } }
public static procedure_definition CreateFunctionDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, type_definition returnType) { return(InternalCreateFunctionDefinitionNode(methName, formalPars, classKeyword, procBody, returnType, null)); }
public virtual void AddSymbol(ident name, SymKind kind, type_definition td = null, Attributes attr = 0) { Current.Symbols.Add(new SymInfoSyntax(name, kind, td, attr)); }
public type_node visit(type_definition type_def) { type_def.visit(syntax_tree_visitor); return(ret_semantic as type_node); }
public ident func_decl_lambda(object lr0, object lr2) { statement_list _statement_list = (statement_list)lr2; expression_list _expression_list = new expression_list(); ident_list _i_l = new ident_list(); formal_parameters _formal_parameters = new formal_parameters(); if (lr0 != null) { List <object> ar = (List <object>)lr0; for (int i = 0; i < ar.Count; i++) { if (ar[i] is ident) { _i_l.idents.Add((ident)ar[i]); } else { _i_l.idents.Add(((var_def_statement)ar[i]).vars.idents[0]); } } for (int i = 0; i < _i_l.idents.Count; i++) { _expression_list.expressions.Add(_i_l.idents[i]); } for (int i = 0; i < ar.Count; i++) { ident_list _ident_list = new ident_list(); ident id = _i_l.idents[i]; _ident_list.idents.Add(id); string name_param = id.name; typed_parameters _typed_parameters = null; int k = 0; { named_type_reference _named_type_reference = new named_type_reference(); type_definition t_d = new type_definition(); if (ar[i] is ident) { ident idtype = new ident("object"); _named_type_reference.names.Add(idtype); t_d = (type_definition)_named_type_reference; } else { t_d = ((var_def_statement)ar[i]).vars_type; } _typed_parameters = new typed_parameters(_ident_list, t_d, parametr_kind.none, null); //parsertools.create_source_context(_typed_parameters, _ident_list, t_d); } _formal_parameters.params_list.Add(_typed_parameters); } } ////////////////////////// named_type_reference _named_type_reference1 = new named_type_reference(); ident idtype1 = new ident("object"); _named_type_reference1.source_context = idtype1.source_context; _named_type_reference1.names.Add(idtype1); ///////////////////////////// lambda_num++; function_lambda_definition _procedure_definition = new function_lambda_definition(); _procedure_definition.formal_parameters = _formal_parameters; _procedure_definition.return_type = (type_definition)_named_type_reference1; _procedure_definition.ident_list = _i_l; _procedure_definition.proc_body = null; _procedure_definition.parameters = _expression_list; _procedure_definition.lambda_name = "__lambda__" + lambda_num; //new function_lambda_definition(_formal_parameters, (type_definition)_named_type_reference1, _i_l, null, _expression_list, "lambda" + lambda_num); object rt = _i_l; _procedure_definition.proc_body = _statement_list; //////////////////////////////vnutrennie lambda if (_procedure_definition.defs == null) { _procedure_definition.defs = new List <declaration>(); } while (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] != null) { _procedure_definition.defs.Add(lambda((function_lambda_definition)pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1])); pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1); } if (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] == null) { pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1); } pascalABC_lambda_definitions.Add(_procedure_definition); /////////////////////////////////////////////// //parsertools.create_source_context(_procedure_definition, _expression_list, rt); ident _name = new ident(_procedure_definition.lambda_name); if (lr0 != null) { _name.source_context = _i_l.idents[0].source_context; } return(_name); }
public override void visit(type_definition _type_definition) { executer.visit(_type_definition); if (_type_definition.attr_list != null) this.visit((dynamic)_type_definition.attr_list); if (_type_definition.attributes != null) this.visit((dynamic)_type_definition.attributes); }
public virtual void visit(type_definition _type_definition) { }
public override void visit(type_definition _type_definition) { throw new NotImplementedException(); }
public override void visit(type_definition _type_definition) { }
private static procedure_definition InternalCreateFunctionDefinitionNode(string methName, formal_parameters formalPars, bool classKeyword, statement procBody, type_definition returnType, SourceContext sc) { return(PascalABCCompiler.TreeConverter.LambdaHelper.SyntaxTreeNodesConstructor.CreateFunctionDefinitionNode(new method_name(methName), formalPars, false, classKeyword, procBody, returnType, sc)); }
public typecast_node NewAsIsConstexpr(expression constterm, op_typecast typecastop, type_definition tdef, LexLocation loc) { var naic = new typecast_node(constterm as addressed_value, tdef, typecastop, loc); if (!(constterm is addressed_value)) { parsertools.errors.Add(new bad_operand_type(parsertools.CurrentFileName, constterm.source_context, naic)); } return(naic); }
public static simple_property BuildSimpleReadWriteProperty(ident name, ident field, type_definition type) { return(new simple_property(name, type, new property_accessors(new read_accessor_name(field, null, null), new write_accessor_name(field, null, null)))); }
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); }