public expression NewVariable(addressed_value variable, expression var_specifiers, LexLocation loc) { if (var_specifiers is dot_node) { var dn = (dot_node)var_specifiers; dn.left = variable; } else if (var_specifiers is template_param_list) { var tpl = (template_param_list)var_specifiers; ((dot_node)tpl.dereferencing_value).left = variable; parsertools.create_source_context(tpl.dereferencing_value, variable, tpl.dereferencing_value); } else if (var_specifiers is dereference) { ((dereference)var_specifiers).dereferencing_value = variable; } else if (var_specifiers is ident_with_templateparams) { ((ident_with_templateparams)var_specifiers).name = (addressed_value_funcname)variable; } var_specifiers.source_context = loc; return(var_specifiers); }
private List <statement> ProcessDesugaringForConstPattern(is_pattern_expr isExpression) { var patternExpressionNode = isExpression.right as const_pattern; var statementsToAdd = new List <statement>(); var equalCalls = new List <bin_expr>(); foreach (var patternExpression in patternExpressionNode.pattern_expressions.expressions) { statementsToAdd.Add(GetTypeCompatibilityCheck(isExpression.left, patternExpression)); equalCalls.Add( new bin_expr(isExpression.left, patternExpression, Operators.Equal, isExpression.source_context ) ); } typeChecks.AddRange(statementsToAdd); expression orPatternCases = equalCalls[0]; for (int i = 1; i < equalCalls.Count; ++i) { orPatternCases = bin_expr.LogicalOr(orPatternCases, equalCalls[i]); } ReplaceUsingParent(isExpression, orPatternCases); return(statementsToAdd); }
public statement MyStmt(expression ex, statement st) { // Проверить, что в ex - целый тип // Сделать специальный узел для проверки new semantic_check("Тип проверки",params syntax_node[] ob) // Включать этот узел первым для "сахарных" узлов синтаксического дерева var sc = new semantic_check("ExprIsInteger", ex); var id = new ident("#my"); var idlist = new ident_list(id); var typ = new named_type_reference("integer"); var one = new int32_const(1); var vdef = new var_def_statement(idlist, typ, one, definition_attribute.None, false, null); var vstat = new var_statement(vdef, null); var ass = new assign(new ident("#my"), one, Operators.AssignmentAddition); var stlistwhile = new statement_list(st); stlistwhile.Add(ass); var bin = new bin_expr(id, ex, Operators.LessEqual); var wh = new while_node(bin, stlistwhile, WhileCycleType.While); var stlist = new statement_list(sc); stlist.Add(vstat); stlist.Add(wh); return(stlist); }
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); }
private void DesugarConstPatternCase(expression matchingExpression, pattern_case patternCase) { Debug.Assert(patternCase.pattern is const_pattern); var patternExpressionNode = patternCase.pattern as const_pattern; var statementsToAdd = new List <statement>(); var equalCalls = new List <bin_expr>(); foreach (var patternExpression in patternExpressionNode.pattern_expressions.expressions) { statementsToAdd.Add(GetTypeCompatibilityCheck(matchingExpression, patternExpression)); equalCalls.Add( new bin_expr(matchingExpression, patternExpression, Operators.Equal, patternCase.source_context ) ); } typeChecks.AddRange(statementsToAdd); expression orPatternCases = equalCalls[0]; for (int i = 1; i < equalCalls.Count; ++i) { orPatternCases = bin_expr.LogicalOr(orPatternCases, equalCalls[i]); } var ifCondition = patternCase.condition == null ? orPatternCases : bin_expr.LogicalAnd(orPatternCases, patternCase.condition); var ifCheck = SubtreeCreator.CreateIf(ifCondition, patternCase.case_action); // Добавляем полученные statements в результат AddDesugaredCaseToResult(ifCheck, ifCheck); }
public void semantic_check_assign_var_tuple(ident_list vars, expression ex) { // Проверить, что справа - Tuple var expr = convert_strong(ex); expr = convert_if_typed_expression_to_function_call(expr); var t = ConvertSemanticTypeNodeToNETType(expr.type); if (t == null) { AddError(expr.location, "TUPLE_EXPECTED"); } if (!t.FullName.StartsWith("System.Tuple")) { AddError(expr.location, "TUPLE_EXPECTED"); } var n = vars.idents.Count(); if (n > t.GetGenericArguments().Count()) { AddError(get_location(vars), "TOO_MANY_ELEMENTS_ON_LEFT_SIDE_OF_TUPLE_ASSIGNMRNT"); } }
public override void visit(double_question_node dqn) { var st = dqn.Parent; while (!(st is statement)) { st = st.Parent; } var tname = "#temp" + UniqueNumStr(); var tt = new var_statement(new ident(tname), dqn.left); tt.var_def.Parent = tt; var l = new List <statement>(); l.Add(tt); l.Add(st as statement); expression right = dqn.right; var eq = new bin_expr(new ident(tname), new nil_const(), Operators.NotEqual, dqn.left.source_context); var qce = new question_colon_expression(eq, new ident(tname), right, dqn.source_context); ReplaceUsingParent(dqn, qce); visit(qce); ReplaceStatementUsingParent(st as statement, l); visit(tt); }
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 statement_list NewLambdaBody(expression expr_l1, LexLocation loc) { var sl = new statement_list(); sl.expr_lambda_body = true; var id = new ident("result"); var op = new op_type_node(Operators.Assignment); //_op_type_node.source_context = parsertools.GetTokenSourceContext(); var ass = new assign(id, expr_l1, op.type); parsertools.create_source_context(ass, id, expr_l1); // дурацкая функция - если хотя бы у одного sc=null, то возвращает null if (ass.source_context == null) { if (expr_l1.source_context != null) { ass.source_context = expr_l1.source_context; } else if (id.source_context != null) { ass.source_context = id.source_context; } } sl.subnodes.Add(ass); sl.source_context = loc; return(sl); }
private void CheckIfCanBeMatched(expression matchedExpression, expression patternExpression) { var patternNode = convert_strong(patternExpression); var patternType = patternNode.type; var expressionNode = convert_strong(matchedExpression); var expressionType = expressionNode.type; if (!(patternNode is constant_node)) { AddError(get_location(patternExpression), "MATCHING_WITH_NON_CONST"); } var possible_convertion = type_table.get_convertions(patternType, expressionType); var expressionTypeName = expressionType.BaseFullName; var patternTypeName = patternType.BaseFullName; var tupleName = "System.Tuple"; if (type_table.is_derived(patternType, expressionType) || type_table.is_derived(expressionType, patternType) || possible_convertion.first != null || AreTheSameType(patternType, expressionType) || (expressionTypeName.StartsWith(tupleName) && patternTypeName.StartsWith(tupleName) && int.Parse(expressionTypeName.Substring(tupleName.Length + 1, 1)) == int.Parse(patternTypeName.Substring(tupleName.Length + 1, 1))) || (expressionType.IsPointer && patternNode is null_const_node) || (patternType.IsPointer && expressionNode is null_const_node)) { return; } AddError(get_location(matchedExpression), "EXPRESSION_OF_TYPE_{0}_CANNOT_BE_MATCHED_AGAINST_PATTERN_WITH_TYPE_{1}", expressionType.name, patternType.name); }
static expression[] parseBinary(ParameterExpression eRecord, ParameterExpression eArgument, Expression eLeft, eOperation op, Expression eRight) { HasParam hp = new HasParam(eRecord); bool leftParam = hp.hasParameter(eLeft); bool rightParam = hp.hasParameter(eRight); if (!(leftParam ^ rightParam)) { throw new NotSupportedException("Binary expression is not supported: must contain a ESENT column on exactly one side of the comparison"); } MemberInfo mi; Func <object, object> val; if (leftParam) { // The column is on the left of the expression mi = parseColumn(eRecord, eLeft); val = parseConstant(eArgument, eRight); } else { // The column is on the right of the expression mi = parseColumn(eRecord, eRight); val = parseConstant(eArgument, eLeft); op = op.invert(); } var res = new expression(mi, op, val); return(new expression[1] { res }); }
public static ident HasName(expression ex, string varname) { var v = new ExprHasNameVisitor(varname); v.ProcessNode(ex); return(v.id); }
public virtual statement mk_return(type ty, Method m) { if (m.Type == T.Void) { return(new empty_statement()); } expression expr = null; if (m.Type.FullName == "char") { expr = new character_literal(new InputElement("'\0'")); } else if (m.Type.IsNumeric && m.Type != T.Decimal) { expr = new integer_literal(new InputElement("0")); } else if (m.Type.IsReferenceType) { expr = new null_literal(new InputElement("null")); } else if (m.Type.IsValueType) { expr = new new_expression(ty, argumentList.New()); } statement stmt = new return_statement(expr); stmt.method = m; return(stmt); }
private expression DesugarRecursiveParameters(expression expression, pattern_node pattern) { List <pattern_parameter> parameters = pattern.parameters; expression conjunction = new is_pattern_expr(expression, pattern, pattern.source_context); for (int i = 0; i < parameters.Count; i++) { if (parameters[i] is recursive_pattern_parameter parameter) { //var parameterType = (parameter.pattern as deconstructor_pattern).type; var newName = NewGeneralName(); pattern_parameter varParameter = null; if (pattern is deconstructor_pattern) { varParameter = new var_deconstructor_parameter(newName, null, false); } else if (pattern is collection_pattern) { varParameter = new collection_pattern_var_parameter(newName, null); } else if (pattern is tuple_pattern) { varParameter = new tuple_pattern_var_parameter(newName, null); } parameters[i] = varParameter; varParameter.Parent = parameters[i]; conjunction = bin_expr.LogicalAnd(conjunction, DesugarRecursiveParameters(newName, parameter.pattern)); } } return(conjunction); }
public expression_node visit(expression expr) { expr.visit(syntax_tree_visitor); /*addressed_expression ad = ret_semantic as addressed_expression; * if (ad != null && ad.is_addressed) * { * if (convertion_data_and_alghoritms.check_for_constant(ad)) * ad.is_addressed = false; * }*/ //Надеюсь, это сильно не скажется на производительности, хотя в другом случае этот же код просто будет разбросан по всем метдам syntax_tree_visitor-а. base_function_call bfc = ret_semantic as base_function_call; if (bfc != null) { if (bfc.simple_function_node.compile_time_executor != null) { expression_node ex = bfc.simple_function_node.compile_time_executor(bfc.location, bfc.parameters.ToArray()); if (ex != null) { return(ex); } } } return(ret_semantic as expression_node); }
private SyntaxTree.if_node CreateIfElse(expression condition, statement thenBody, statement elseBody) { SyntaxTree.if_node res = new SyntaxTree.if_node(); res.condition = condition; res.then_body = thenBody; res.else_body = elseBody; return(res); }
static expression wrap(expression ast, int count) { if (count > 1) { ast = new local_expression(ast); } return(ast); }
/// <summary> /// Создать цикл while /// </summary> /// <param name="condition">Условие цикла</param> /// <param name="body">Тело цикла</param> /// <returns></returns> public static SyntaxTree.while_node CreateWhile(expression condition, statement body) { SyntaxTree.while_node res = new SyntaxTree.while_node(); res.CycleType = WhileCycleType.While; res.expr = condition; res.statements = body; return(res); }
static int TypeArgumentCount(expression ast) { ArgumentCounter c = new ArgumentCounter(); ASTVisitor v = new ASTVisitor(c.fn); ast.visit(v); return(c.Count); }
public ReferenceFinder1(expression expr, ScopeSyntax scope, compilation_unit cu, string new_val) { this.expr = expr; this.cu = cu; global = scope; current = cu; this.new_val = new_val; }
/// <summary> /// Проверяет выражение, сопоставляемое с образцом /// </summary> /// <param name="matchedExpression"></param> private void CheckMatchedExpression(expression matchedExpression) { var convertedExpression = convert_strong(matchedExpression); if (convertedExpression.type.IsPointer) { AddError(get_location(matchedExpression), "PATTERN_MATCHING_DOESNT_SUPPORT_POINTERS"); } }
private expression DesugarDeconstructorPatternParameters(deconstructor_pattern pattern) { expression paramCheckExpr = null; for (int i = 0; i < pattern.parameters.Count; ++i) { if (pattern.parameters[i] is const_pattern_parameter constPattern) { var constParamIdent = new ident(NewDeconstructParamId(), pattern.parameters[i].source_context); var eqParams = new expression_list( new List <expression>() { constPattern.const_param, constParamIdent } ); var constParamCheck = new method_call( new dot_node(new ident("object"), new ident("Equals")), eqParams, pattern.source_context ); pattern.parameters[i] = new var_deconstructor_parameter( constParamIdent, GetTypeDefinitionForConstParam(constPattern.const_param), false, pattern.parameters[i].source_context); paramCheckExpr = paramCheckExpr == null ? (expression)constParamCheck : bin_expr.LogicalAnd(paramCheckExpr, constParamCheck); } if (pattern.parameters[i] is wild_card_deconstructor_parameter) { var wildCardGeneratedParamIdent = new ident(NewDeconstructParamId(), pattern.parameters[i].source_context); pattern.parameters[i] = new var_deconstructor_parameter( wildCardGeneratedParamIdent, null, false, pattern.parameters[i].source_context); } if (pattern.parameters[i] is recursive_deconstructor_parameter deconstructor_param) { if (deconstructor_param.pattern is deconstructor_pattern deconstructor_pattern) { var recursiveChecks = DesugarDeconstructorPatternParameters(deconstructor_pattern); paramCheckExpr = paramCheckExpr == null ? recursiveChecks : bin_expr.LogicalAnd(paramCheckExpr, recursiveChecks); } } } return(paramCheckExpr); }
/// <summary> /// Создать цикл for /// </summary> /// <param name="varName">Имя переменной цикла</param> /// <param name="initValue">Начальное значение переменной цикла</param> /// <param name="finishValue">Конечное значение переменной цикла</param> /// <param name="body">Тело цикла</param> /// <param name="type">Тип цикла(to / downto)</param> /// <returns></returns> public static SyntaxTree.for_node CreateFor(string varName, expression initValue, expression finishValue, statement body, for_cycle_type type) { SyntaxTree.for_node res = new SyntaxTree.for_node(); res.loop_variable = new ident(varName); res.initial_value = initValue; res.finish_value = finishValue; res.statements = body; res.cycle_type = type; return(res); }
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); }
private expression GetCollectionItemsEqualCheckAfterGap(addressed_value matchingExpression, List <pattern_parameter> toCompare, CollectionDesugaringResult desugaringResult) { var elemFromTail = 1; expression equalChecks = null; foreach (var param in toCompare) { var indexerCall = new indexer( matchingExpression, new expression_list( new bin_expr( new method_call( new dot_node( matchingExpression, new ident("Count", matchingExpression.source_context)), new expression_list()), new int32_const(elemFromTail, matchingExpression.source_context), Operators.Minus), matchingExpression.source_context), matchingExpression.source_context); if (param is const_pattern_parameter constParam) { var eqParams = new expression_list( new List <expression>() { indexerCall, constParam.const_param } ); var equalCall = new method_call( new dot_node( new ident("object"), new ident("Equals")), eqParams, matchingExpression.source_context ); equalChecks = equalChecks == null ? (expression)equalCall : bin_expr.LogicalAnd(equalChecks, equalCall); desugaringResult.ElemTypeChecks.Add(GetTypeCompatibilityCheck(indexerCall, constParam.const_param)); } if (param is collection_pattern_var_parameter varParam) { desugaringResult.VarParametersDeclarations.Add( new var_statement(varParam.identifier, indexerCall)); } ++elemFromTail; } return(equalChecks); }
private expression convert_binary_expression(ICSharpCode.NRefactory.Ast.BinaryOperatorExpression expr) { Operators op = Operators.Undefined; expression left = convert_expression(expr.Left); expression right = convert_expression(expr.Right); switch (expr.Op) { case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Add: op = Operators.Plus; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Subtract: op = Operators.Minus; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Multiply: op = Operators.Multiplication; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Divide: op = Operators.Division; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.LessThan: op = Operators.Less; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.LessThanOrEqual: op = Operators.LessEqual; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.GreaterThan: op = Operators.Greater; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.GreaterThanOrEqual: op = Operators.GreaterEqual; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Equality: op = Operators.Equal; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.InEquality: op = Operators.NotEqual; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.LogicalAnd: op = Operators.LogicalAND; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.LogicalOr: op = Operators.LogicalOR; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.ExclusiveOr: op = Operators.BitwiseXOR; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Like: op = Operators.Equal; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.DivideInteger: op = Operators.IntegerDivision; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.Modulus: op = Operators.ModulusRemainder; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.BitwiseAnd: op = Operators.BitwiseAND; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.BitwiseOr: op = Operators.BitwiseOR; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.ReferenceEquality: op = Operators.Equal; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.ReferenceInequality: op = Operators.NotEqual; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.ShiftLeft: op = Operators.BitwiseLeftShift; break; case ICSharpCode.NRefactory.Ast.BinaryOperatorType.ShiftRight: op = Operators.BitwiseRightShift; break; } return(new bin_expr(left, right, op)); }
void DesugarDeconstructorPatternCase(expression matchingExpression, pattern_case patternCase) { Debug.Assert(patternCase.pattern is deconstructor_pattern); var isExpression = new is_pattern_expr(matchingExpression, patternCase.pattern); var ifCondition = patternCase.condition == null ? (expression)isExpression : bin_expr.LogicalAnd(isExpression, patternCase.condition); var ifCheck = SubtreeCreator.CreateIf(ifCondition, patternCase.case_action); // Добавляем полученные statements в результат AddDesugaredCaseToResult(ifCheck, ifCheck); }
/// <summary> /// Создать var-выражение /// </summary> /// <param name="name">Имя переменной</param> /// <param name="initialValue">Начальное значение</param> /// <returns></returns> public static var_def_statement CreateVarDef(string name, expression initialValue) { ident_list list = new ident_list(); list.idents.Add(new ident(name)); var res = new var_def_statement(); res.inital_value = initialValue; res.vars = list; return(res); }
private void DefaultDesugarPattern(expression matchingExpression, pattern_case patternCase) { //var paramCheckExpr = DesugarDeconstructorPatternParameters(patternCase.pattern as deconstructor_pattern); var isExpression = new is_pattern_expr(matchingExpression, patternCase.pattern, patternCase.source_context); var ifCondition = patternCase.condition == null ? (expression)isExpression : bin_expr.LogicalAnd(isExpression, patternCase.condition); var ifCheck = SubtreeCreator.CreateIf(ifCondition, patternCase.case_action); // Добавляем полученные statements в результат AddDesugaredCaseToResult(ifCheck, ifCheck); }
public override void visit(new_expr newExpr) { if (newExpr.params_list != null && newExpr.params_list.expressions != null) { for (int i = 0; i < newExpr.params_list.expressions.Count; i++) { expression expr = newExpr.params_list.expressions[i]; ProcessNode(expr); } } }
public InterpretationPlanCheckCondition(expression.AreAttributesEqual condition, InterpretationPlanEdgeMatcher edgeMatcher, int indexOfCorrespondingEdge) { this.condition = condition; this.edgeMatcher = edgeMatcher; this.indexOfCorrespondingElement = indexOfCorrespondingEdge; AssignId(); }
public override void visit(expression _expression) { executer.visit(_expression); if (_expression.attributes != null) this.visit((dynamic)_expression.attributes); }
public virtual void post_do_visit(expression _expression) { }
public override void visit(expression _expression) { DefaultVisit(_expression); pre_do_visit(_expression); post_do_visit(_expression); }
public virtual void visit(expression _expression) { DefaultVisit(_expression); }
public virtual void visit(expression _expression) { }