diff --git a/src/main/gen/com/javampire/openscad/parser/OpenSCADParser.java b/src/main/gen/com/javampire/openscad/parser/OpenSCADParser.java index d0aab43..e82f032 100644 --- a/src/main/gen/com/javampire/openscad/parser/OpenSCADParser.java +++ b/src/main/gen/com/javampire/openscad/parser/OpenSCADParser.java @@ -41,12 +41,13 @@ static boolean parse_root_(IElementType t, PsiBuilder b, int l) { create_token_set_(BACKGROUND_OP, BUILTIN_OP, DEBUG_OP, DISABLE_OP, MODIFIER_OP, MODULE_CALL_OP, OPERATOR, ROOT_OP), create_token_set_(AND_EXPR, ASSERT_EXPR, BUILTIN_EXPR, CONDITIONAL_EXPR, - DIV_EXPR, ECHO_EXPR, ELVIS_EXPR, EXPR, - FUNCTION_CALL_EXPR, FUNCTION_LITERAL_EXPR, INDEX_EXPR, LIST_EXPR, - LITERAL_EXPR, MINUS_EXPR, MODULO_EXPR, MUL_EXPR, - OR_EXPR, PAREN_EXPR, PLUS_EXPR, POWER_EXPR, - QUALIFICATION_EXPR, RANGE_EXPR, TEST_EXPR, UNARY_MIN_EXPR, - UNARY_NEGATE_EXPR, UNARY_PLUS_EXPR, VARIABLE_REF_EXPR, VECTOR_EXPR), + DIV_EXPR, EACH_EXPR, ECHO_EXPR, ELVIS_EXPR, + EXPR, FUNCTION_CALL_EXPR, FUNCTION_LITERAL_EXPR, INDEX_EXPR, + LIST_EXPR, LITERAL_EXPR, MINUS_EXPR, MODULO_EXPR, + MUL_EXPR, OR_EXPR, PAREN_EXPR, PLUS_EXPR, + POWER_EXPR, QUALIFICATION_EXPR, RANGE_EXPR, TEST_EXPR, + UNARY_MIN_EXPR, UNARY_NEGATE_EXPR, UNARY_PLUS_EXPR, VARIABLE_REF_EXPR, + VECTOR_EXPR), }; /* ********************************************************** */ @@ -80,7 +81,7 @@ private static boolean arg_assignment_0_0(PsiBuilder b, int l) { } /* ********************************************************** */ - // LPARENTH arg_assignment? ( COMMA+ arg_assignment )* RPARENTH + // LPARENTH arg_assignment? ( COMMA arg_assignment )* RPARENTH public static boolean arg_assignment_list(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "arg_assignment_list")) return false; if (!nextTokenIs(b, LPARENTH)) return false; @@ -102,7 +103,7 @@ private static boolean arg_assignment_list_1(PsiBuilder b, int l) { return true; } - // ( COMMA+ arg_assignment )* + // ( COMMA arg_assignment )* private static boolean arg_assignment_list_2(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "arg_assignment_list_2")) return false; while (true) { @@ -113,33 +114,18 @@ private static boolean arg_assignment_list_2(PsiBuilder b, int l) { return true; } - // COMMA+ arg_assignment + // COMMA arg_assignment private static boolean arg_assignment_list_2_0(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "arg_assignment_list_2_0")) return false; boolean r, p; Marker m = enter_section_(b, l, _NONE_); - r = arg_assignment_list_2_0_0(b, l + 1); + r = consumeToken(b, COMMA); p = r; // pin = 1 r = r && arg_assignment(b, l + 1); exit_section_(b, l, m, r, p, null); return r || p; } - // COMMA+ - private static boolean arg_assignment_list_2_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "arg_assignment_list_2_0_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = consumeToken(b, COMMA); - while (r) { - int c = current_position_(b); - if (!consumeToken(b, COMMA)) break; - if (!empty_element_parsed_guard_(b, "arg_assignment_list_2_0_0", c)) break; - } - exit_section_(b, m, null, r); - return r; - } - /* ********************************************************** */ // IDENTIFIER [EQUALS expr] public static boolean arg_declaration(PsiBuilder b, int l) { @@ -224,38 +210,74 @@ private static boolean arg_declaration_list_2_0_1(PsiBuilder b, int l) { } /* ********************************************************** */ - // "assert" LPARENTH expr (',' STRING_LITERAL)? RPARENTH - public static boolean assert_element(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assert_element")) return false; + // LPARENTH (expr | IDENTIFIER) (COMMA (expr | IDENTIFIER | STRING_LITERAL))* RPARENTH + public static boolean assert_arg_list(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_arg_list")) return false; + if (!nextTokenIs(b, LPARENTH)) return false; boolean r; - Marker m = enter_section_(b, l, _NONE_, ASSERT_ELEMENT, ""); - r = consumeToken(b, "assert"); - r = r && consumeToken(b, LPARENTH); - r = r && expr(b, l + 1, -1); - r = r && assert_element_3(b, l + 1); + Marker m = enter_section_(b); + r = consumeToken(b, LPARENTH); + r = r && assert_arg_list_1(b, l + 1); + r = r && assert_arg_list_2(b, l + 1); r = r && consumeToken(b, RPARENTH); - exit_section_(b, l, m, r, false, null); + exit_section_(b, m, ASSERT_ARG_LIST, r); + return r; + } + + // expr | IDENTIFIER + private static boolean assert_arg_list_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_arg_list_1")) return false; + boolean r; + r = expr(b, l + 1, -1); + if (!r) r = consumeToken(b, IDENTIFIER); return r; } - // (',' STRING_LITERAL)? - private static boolean assert_element_3(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assert_element_3")) return false; - assert_element_3_0(b, l + 1); + // (COMMA (expr | IDENTIFIER | STRING_LITERAL))* + private static boolean assert_arg_list_2(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_arg_list_2")) return false; + while (true) { + int c = current_position_(b); + if (!assert_arg_list_2_0(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "assert_arg_list_2", c)) break; + } return true; } - // ',' STRING_LITERAL - private static boolean assert_element_3_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "assert_element_3_0")) return false; + // COMMA (expr | IDENTIFIER | STRING_LITERAL) + private static boolean assert_arg_list_2_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_arg_list_2_0")) return false; boolean r; Marker m = enter_section_(b); - r = consumeToken(b, ","); - r = r && consumeToken(b, STRING_LITERAL); + r = consumeToken(b, COMMA); + r = r && assert_arg_list_2_0_1(b, l + 1); exit_section_(b, m, null, r); return r; } + // expr | IDENTIFIER | STRING_LITERAL + private static boolean assert_arg_list_2_0_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_arg_list_2_0_1")) return false; + boolean r; + r = expr(b, l + 1, -1); + if (!r) r = consumeToken(b, IDENTIFIER); + if (!r) r = consumeToken(b, STRING_LITERAL); + return r; + } + + /* ********************************************************** */ + // ASSERT_KEYWORD assert_arg_list + public static boolean assert_element(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_element")) return false; + if (!nextTokenIs(b, ASSERT_KEYWORD)) return false; + boolean r; + Marker m = enter_section_(b); + r = consumeToken(b, ASSERT_KEYWORD); + r = r && assert_arg_list(b, l + 1); + exit_section_(b, m, ASSERT_ELEMENT, r); + return r; + } + /* ********************************************************** */ // PERC public static boolean background_op(PsiBuilder b, int l) { @@ -383,8 +405,11 @@ public static boolean builtin_expr_ref(PsiBuilder b, int l) { /* ********************************************************** */ // (builtin_obj_ref arg_assignment_list SEMICOLON) + // | (builtin_overridable_obj_ref arg_assignment_list SEMICOLON) // | (builtin_op block_obj) // | (builtin_op statement) + // | (echo_element+ object) + // | (assert_element+ object) public static boolean builtin_obj(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "builtin_obj")) return false; boolean r; @@ -392,6 +417,9 @@ public static boolean builtin_obj(PsiBuilder b, int l) { r = builtin_obj_0(b, l + 1); if (!r) r = builtin_obj_1(b, l + 1); if (!r) r = builtin_obj_2(b, l + 1); + if (!r) r = builtin_obj_3(b, l + 1); + if (!r) r = builtin_obj_4(b, l + 1); + if (!r) r = builtin_obj_5(b, l + 1); exit_section_(b, l, m, r, false, null); return r; } @@ -408,11 +436,23 @@ private static boolean builtin_obj_0(PsiBuilder b, int l) { return r; } - // builtin_op block_obj + // builtin_overridable_obj_ref arg_assignment_list SEMICOLON private static boolean builtin_obj_1(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "builtin_obj_1")) return false; boolean r; Marker m = enter_section_(b); + r = builtin_overridable_obj_ref(b, l + 1); + r = r && arg_assignment_list(b, l + 1); + r = r && consumeToken(b, SEMICOLON); + exit_section_(b, m, null, r); + return r; + } + + // builtin_op block_obj + private static boolean builtin_obj_2(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_2")) return false; + boolean r; + Marker m = enter_section_(b); r = builtin_op(b, l + 1); r = r && block_obj(b, l + 1); exit_section_(b, m, null, r); @@ -420,8 +460,8 @@ private static boolean builtin_obj_1(PsiBuilder b, int l) { } // builtin_op statement - private static boolean builtin_obj_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "builtin_obj_2")) return false; + private static boolean builtin_obj_3(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_3")) return false; boolean r; Marker m = enter_section_(b); r = builtin_op(b, l + 1); @@ -430,21 +470,68 @@ private static boolean builtin_obj_2(PsiBuilder b, int l) { return r; } + // echo_element+ object + private static boolean builtin_obj_4(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_4")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_obj_4_0(b, l + 1); + r = r && object(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // echo_element+ + private static boolean builtin_obj_4_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_4_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = echo_element(b, l + 1); + while (r) { + int c = current_position_(b); + if (!echo_element(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "builtin_obj_4_0", c)) break; + } + exit_section_(b, m, null, r); + return r; + } + + // assert_element+ object + private static boolean builtin_obj_5(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_5")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_obj_5_0(b, l + 1); + r = r && object(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // assert_element+ + private static boolean builtin_obj_5_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_obj_5_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = assert_element(b, l + 1); + while (r) { + int c = current_position_(b); + if (!assert_element(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "builtin_obj_5_0", c)) break; + } + exit_section_(b, m, null, r); + return r; + } + /* ********************************************************** */ // ASSERT_KEYWORD // | CHILD_KEYWORD // | CHILDREN_KEYWORD - // | CIRCLE_KEYWORD - // | CUBE_KEYWORD - // | CYLINDER_KEYWORD // | ECHO_KEYWORD // | IMPORT_KEYWORD // | IMPORT_DXF_KEYWORD // | IMPORT_STL_KEYWORD // | POLYGON_KEYWORD // | POLYHEDRON_KEYWORD - // | SPHERE_KEYWORD - // | SQUARE_KEYWORD // | SURFACE_KEYWORD // | TEXT_KEYWORD public static boolean builtin_obj_ref(PsiBuilder b, int l) { @@ -454,17 +541,12 @@ public static boolean builtin_obj_ref(PsiBuilder b, int l) { r = consumeToken(b, ASSERT_KEYWORD); if (!r) r = consumeToken(b, CHILD_KEYWORD); if (!r) r = consumeToken(b, CHILDREN_KEYWORD); - if (!r) r = consumeToken(b, CIRCLE_KEYWORD); - if (!r) r = consumeToken(b, CUBE_KEYWORD); - if (!r) r = consumeToken(b, CYLINDER_KEYWORD); if (!r) r = consumeToken(b, ECHO_KEYWORD); if (!r) r = consumeToken(b, IMPORT_KEYWORD); if (!r) r = consumeToken(b, IMPORT_DXF_KEYWORD); if (!r) r = consumeToken(b, IMPORT_STL_KEYWORD); if (!r) r = consumeToken(b, POLYGON_KEYWORD); if (!r) r = consumeToken(b, POLYHEDRON_KEYWORD); - if (!r) r = consumeToken(b, SPHERE_KEYWORD); - if (!r) r = consumeToken(b, SQUARE_KEYWORD); if (!r) r = consumeToken(b, SURFACE_KEYWORD); if (!r) r = consumeToken(b, TEXT_KEYWORD); exit_section_(b, l, m, r, false, null); @@ -473,12 +555,157 @@ public static boolean builtin_obj_ref(PsiBuilder b, int l) { /* ********************************************************** */ // common_op_ref arg_assignment_list + // | builtin_overridable_op_ref arg_assignment_list + // | builtin_overridable_op_as_function_ref arg_assignment_list public static boolean builtin_op(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "builtin_op")) return false; boolean r; Marker m = enter_section_(b, l, _NONE_, BUILTIN_OP, ""); + r = builtin_op_0(b, l + 1); + if (!r) r = builtin_op_1(b, l + 1); + if (!r) r = builtin_op_2(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + // common_op_ref arg_assignment_list + private static boolean builtin_op_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_op_0")) return false; + boolean r; + Marker m = enter_section_(b); r = common_op_ref(b, l + 1); r = r && arg_assignment_list(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // builtin_overridable_op_ref arg_assignment_list + private static boolean builtin_op_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_op_1")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_overridable_op_ref(b, l + 1); + r = r && arg_assignment_list(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // builtin_overridable_op_as_function_ref arg_assignment_list + private static boolean builtin_op_2(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_op_2")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_overridable_op_as_function_ref(b, l + 1); + r = r && arg_assignment_list(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // builtin_overridable_op_as_function_ref arg_assignment_list + // | builtin_overridable_op_ref arg_assignment_list + public static boolean builtin_overridable_expr_ref(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_expr_ref")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, BUILTIN_OVERRIDABLE_EXPR_REF, ""); + r = builtin_overridable_expr_ref_0(b, l + 1); + if (!r) r = builtin_overridable_expr_ref_1(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + // builtin_overridable_op_as_function_ref arg_assignment_list + private static boolean builtin_overridable_expr_ref_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_expr_ref_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_overridable_op_as_function_ref(b, l + 1); + r = r && arg_assignment_list(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // builtin_overridable_op_ref arg_assignment_list + private static boolean builtin_overridable_expr_ref_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_expr_ref_1")) return false; + boolean r; + Marker m = enter_section_(b); + r = builtin_overridable_op_ref(b, l + 1); + r = r && arg_assignment_list(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + /* ********************************************************** */ + // CIRCLE_KEYWORD + // | CUBE_KEYWORD + // | CYLINDER_KEYWORD + // | SPHERE_KEYWORD + // | SQUARE_KEYWORD + static boolean builtin_overridable_obj_keywords(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_obj_keywords")) return false; + boolean r; + r = consumeToken(b, CIRCLE_KEYWORD); + if (!r) r = consumeToken(b, CUBE_KEYWORD); + if (!r) r = consumeToken(b, CYLINDER_KEYWORD); + if (!r) r = consumeToken(b, SPHERE_KEYWORD); + if (!r) r = consumeToken(b, SQUARE_KEYWORD); + return r; + } + + /* ********************************************************** */ + // builtin_overridable_obj_keywords + public static boolean builtin_overridable_obj_ref(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_obj_ref")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, BUILTIN_OVERRIDABLE_OBJ_REF, ""); + r = builtin_overridable_obj_keywords(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + /* ********************************************************** */ + // builtin_overridable_op_keywords | builtin_overridable_obj_keywords + public static boolean builtin_overridable_op_as_function_ref(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_op_as_function_ref")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF, ""); + r = builtin_overridable_op_keywords(b, l + 1); + if (!r) r = builtin_overridable_obj_keywords(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + /* ********************************************************** */ + // OFFSET_KEYWORD + // | TRANSLATE_KEYWORD + // | HULL_KEYWORD + // | MIRROR_KEYWORD + // | SCALE_KEYWORD + // | DIFFERENCE_KEYWORD + // | INTERSECTION_KEYWORD + // | UNION_KEYWORD + static boolean builtin_overridable_op_keywords(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_op_keywords")) return false; + boolean r; + r = consumeToken(b, OFFSET_KEYWORD); + if (!r) r = consumeToken(b, TRANSLATE_KEYWORD); + if (!r) r = consumeToken(b, HULL_KEYWORD); + if (!r) r = consumeToken(b, MIRROR_KEYWORD); + if (!r) r = consumeToken(b, SCALE_KEYWORD); + if (!r) r = consumeToken(b, DIFFERENCE_KEYWORD); + if (!r) r = consumeToken(b, INTERSECTION_KEYWORD); + if (!r) r = consumeToken(b, UNION_KEYWORD); + return r; + } + + /* ********************************************************** */ + // builtin_overridable_op_keywords + public static boolean builtin_overridable_op_ref(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "builtin_overridable_op_ref")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, BUILTIN_OVERRIDABLE_OP_REF, ""); + r = builtin_overridable_op_keywords(b, l + 1); exit_section_(b, l, m, r, false, null); return r; } @@ -499,43 +726,27 @@ static boolean comment_item(PsiBuilder b, int l) { /* ********************************************************** */ // COLOR_KEYWORD - // | DIFFERENCE_KEYWORD - // | HULL_KEYWORD - // | INTERSECTION_KEYWORD // | LINEAR_EXTRUDE_KEYWORD // | MINKOWSKI_KEYWORD - // | MIRROR_KEYWORD // | MULTMATRIX_KEYWORD - // | OFFSET_KEYWORD // | PROJECTION_KEYWORD // | RENDER_KEYWORD // | RESIZE_KEYWORD // | ROTATE_KEYWORD // | ROTATE_EXTRUDE_KEYWORD - // | SCALE_KEYWORD - // | TRANSLATE_KEYWORD - // | UNION_KEYWORD public static boolean common_op_ref(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "common_op_ref")) return false; boolean r; Marker m = enter_section_(b, l, _NONE_, COMMON_OP_REF, ""); r = consumeToken(b, COLOR_KEYWORD); - if (!r) r = consumeToken(b, DIFFERENCE_KEYWORD); - if (!r) r = consumeToken(b, HULL_KEYWORD); - if (!r) r = consumeToken(b, INTERSECTION_KEYWORD); if (!r) r = consumeToken(b, LINEAR_EXTRUDE_KEYWORD); if (!r) r = consumeToken(b, MINKOWSKI_KEYWORD); - if (!r) r = consumeToken(b, MIRROR_KEYWORD); if (!r) r = consumeToken(b, MULTMATRIX_KEYWORD); - if (!r) r = consumeToken(b, OFFSET_KEYWORD); if (!r) r = consumeToken(b, PROJECTION_KEYWORD); if (!r) r = consumeToken(b, RENDER_KEYWORD); if (!r) r = consumeToken(b, RESIZE_KEYWORD); if (!r) r = consumeToken(b, ROTATE_KEYWORD); if (!r) r = consumeToken(b, ROTATE_EXTRUDE_KEYWORD); - if (!r) r = consumeToken(b, SCALE_KEYWORD); - if (!r) r = consumeToken(b, TRANSLATE_KEYWORD); - if (!r) r = consumeToken(b, UNION_KEYWORD); exit_section_(b, l, m, r, false, null); return r; } @@ -673,14 +884,15 @@ private static boolean echo_arg_list_2_0_1_0(PsiBuilder b, int l) { } /* ********************************************************** */ - // "echo" echo_arg_list + // ECHO_KEYWORD echo_arg_list public static boolean echo_element(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "echo_element")) return false; + if (!nextTokenIs(b, ECHO_KEYWORD)) return false; boolean r; - Marker m = enter_section_(b, l, _NONE_, ECHO_ELEMENT, ""); - r = consumeToken(b, "echo"); + Marker m = enter_section_(b); + r = consumeToken(b, ECHO_KEYWORD); r = r && echo_arg_list(b, l + 1); - exit_section_(b, l, m, r, false, null); + exit_section_(b, m, ECHO_ELEMENT, r); return r; } @@ -919,17 +1131,32 @@ private static boolean for_obj_2(PsiBuilder b, int l) { } /* ********************************************************** */ - // IDENTIFIER EQUALS expr + // IDENTIFIER EQUALS expr+ public static boolean full_arg_declaration(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "full_arg_declaration")) return false; boolean r; Marker m = enter_section_(b, l, _NONE_, FULL_ARG_DECLARATION, ""); r = consumeTokens(b, 0, IDENTIFIER, EQUALS); - r = r && expr(b, l + 1, -1); + r = r && full_arg_declaration_2(b, l + 1); exit_section_(b, l, m, r, false, OpenSCADParser::recover_arg); return r; } + // expr+ + private static boolean full_arg_declaration_2(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "full_arg_declaration_2")) return false; + boolean r; + Marker m = enter_section_(b); + r = expr(b, l + 1, -1); + while (r) { + int c = current_position_(b); + if (!expr(b, l + 1, -1)) break; + if (!empty_element_parsed_guard_(b, "full_arg_declaration_2", c)) break; + } + exit_section_(b, m, null, r); + return r; + } + /* ********************************************************** */ // LPARENTH full_arg_declaration? ( COMMA+ full_arg_declaration )* RPARENTH public static boolean full_arg_declaration_list(PsiBuilder b, int l) { @@ -1007,15 +1234,16 @@ static boolean full_arg_op_identifier(PsiBuilder b, int l) { } /* ********************************************************** */ - // FUNCTION_KEYWORD IDENTIFIER arg_declaration_list EQUALS expr SEMICOLON + // FUNCTION_KEYWORD (builtin_overridable_op_keywords | builtin_overridable_obj_keywords | IDENTIFIER) arg_declaration_list EQUALS expr SEMICOLON public static boolean function_declaration(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "function_declaration")) return false; if (!nextTokenIs(b, FUNCTION_KEYWORD)) return false; boolean r, p; Marker m = enter_section_(b, l, _NONE_, FUNCTION_DECLARATION, null); - r = consumeTokens(b, 1, FUNCTION_KEYWORD, IDENTIFIER); + r = consumeToken(b, FUNCTION_KEYWORD); p = r; // pin = 1 - r = r && report_error_(b, arg_declaration_list(b, l + 1)); + r = r && report_error_(b, function_declaration_1(b, l + 1)); + r = p && report_error_(b, arg_declaration_list(b, l + 1)) && r; r = p && report_error_(b, consumeToken(b, EQUALS)) && r; r = p && report_error_(b, expr(b, l + 1, -1)) && r; r = p && consumeToken(b, SEMICOLON) && r; @@ -1023,6 +1251,16 @@ public static boolean function_declaration(PsiBuilder b, int l) { return r || p; } + // builtin_overridable_op_keywords | builtin_overridable_obj_keywords | IDENTIFIER + private static boolean function_declaration_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "function_declaration_1")) return false; + boolean r; + r = builtin_overridable_op_keywords(b, l + 1); + if (!r) r = builtin_overridable_obj_keywords(b, l + 1); + if (!r) r = consumeToken(b, IDENTIFIER); + return r; + } + /* ********************************************************** */ // IDENTIFIER public static boolean function_name_ref(PsiBuilder b, int l) { @@ -1448,6 +1686,38 @@ private static boolean recover_vector_0(PsiBuilder b, int l) { return r; } + /* ********************************************************** */ + // comment_item* (echo_element | assert_element) + public static boolean reporting_element(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "reporting_element")) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, REPORTING_ELEMENT, ""); + r = reporting_element_0(b, l + 1); + r = r && reporting_element_1(b, l + 1); + exit_section_(b, l, m, r, false, null); + return r; + } + + // comment_item* + private static boolean reporting_element_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "reporting_element_0")) return false; + while (true) { + int c = current_position_(b); + if (!comment_item(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "reporting_element_0", c)) break; + } + return true; + } + + // echo_element | assert_element + private static boolean reporting_element_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "reporting_element_1")) return false; + boolean r; + r = echo_element(b, l + 1); + if (!r) r = assert_element(b, l + 1); + return r; + } + /* ********************************************************** */ // EXCL public static boolean root_op(PsiBuilder b, int l) { @@ -1461,16 +1731,49 @@ public static boolean root_op(PsiBuilder b, int l) { } /* ********************************************************** */ - // object | declaration | import + // comment_item | (object | declaration | import) comment_item* static boolean statement(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "statement")) return false; boolean r; + Marker m = enter_section_(b); + r = comment_item(b, l + 1); + if (!r) r = statement_1(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // (object | declaration | import) comment_item* + private static boolean statement_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "statement_1")) return false; + boolean r; + Marker m = enter_section_(b); + r = statement_1_0(b, l + 1); + r = r && statement_1_1(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // object | declaration | import + private static boolean statement_1_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "statement_1_0")) return false; + boolean r; r = object(b, l + 1); if (!r) r = declaration(b, l + 1); if (!r) r = import_$(b, l + 1); return r; } + // comment_item* + private static boolean statement_1_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "statement_1_1")) return false; + while (true) { + int c = current_position_(b); + if (!comment_item(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "statement_1_1", c)) break; + } + return true; + } + /* ********************************************************** */ // IS_UNDEF_KEYWORD // | IS_LIST_KEYWORD @@ -1522,39 +1825,141 @@ public static boolean variable_declaration(PsiBuilder b, int l) { } /* ********************************************************** */ - // (for_element | if_element | bind_else_element | else_element | let_element | echo_element | assert_element)* expr + // comment_item* (vector_item_expr | expr ) static boolean vector_item(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "vector_item")) return false; boolean r; Marker m = enter_section_(b, l, _NONE_); r = vector_item_0(b, l + 1); - r = r && expr(b, l + 1, -1); + r = r && vector_item_1(b, l + 1); exit_section_(b, l, m, r, false, OpenSCADParser::recover_vector); return r; } - // (for_element | if_element | bind_else_element | else_element | let_element | echo_element | assert_element)* + // comment_item* private static boolean vector_item_0(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "vector_item_0")) return false; while (true) { int c = current_position_(b); - if (!vector_item_0_0(b, l + 1)) break; + if (!comment_item(b, l + 1)) break; if (!empty_element_parsed_guard_(b, "vector_item_0", c)) break; } return true; } - // for_element | if_element | bind_else_element | else_element | let_element | echo_element | assert_element - private static boolean vector_item_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_item_0_0")) return false; + // vector_item_expr | expr + private static boolean vector_item_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_1")) return false; + boolean r; + r = vector_item_expr(b, l + 1); + if (!r) r = expr(b, l + 1, -1); + return r; + } + + /* ********************************************************** */ + // LPARENTH? (comment_item* (vector_item_prefix_element | reporting_element))+ comment_item* expr? RPARENTH? + static boolean vector_item_expr(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr")) return false; + boolean r; + Marker m = enter_section_(b); + r = vector_item_expr_0(b, l + 1); + r = r && vector_item_expr_1(b, l + 1); + r = r && vector_item_expr_2(b, l + 1); + r = r && vector_item_expr_3(b, l + 1); + r = r && vector_item_expr_4(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // LPARENTH? + private static boolean vector_item_expr_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_0")) return false; + consumeToken(b, LPARENTH); + return true; + } + + // (comment_item* (vector_item_prefix_element | reporting_element))+ + private static boolean vector_item_expr_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_1")) return false; + boolean r; + Marker m = enter_section_(b); + r = vector_item_expr_1_0(b, l + 1); + while (r) { + int c = current_position_(b); + if (!vector_item_expr_1_0(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "vector_item_expr_1", c)) break; + } + exit_section_(b, m, null, r); + return r; + } + + // comment_item* (vector_item_prefix_element | reporting_element) + private static boolean vector_item_expr_1_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_1_0")) return false; + boolean r; + Marker m = enter_section_(b); + r = vector_item_expr_1_0_0(b, l + 1); + r = r && vector_item_expr_1_0_1(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + + // comment_item* + private static boolean vector_item_expr_1_0_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_1_0_0")) return false; + while (true) { + int c = current_position_(b); + if (!comment_item(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "vector_item_expr_1_0_0", c)) break; + } + return true; + } + + // vector_item_prefix_element | reporting_element + private static boolean vector_item_expr_1_0_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_1_0_1")) return false; + boolean r; + r = vector_item_prefix_element(b, l + 1); + if (!r) r = reporting_element(b, l + 1); + return r; + } + + // comment_item* + private static boolean vector_item_expr_2(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_2")) return false; + while (true) { + int c = current_position_(b); + if (!comment_item(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "vector_item_expr_2", c)) break; + } + return true; + } + + // expr? + private static boolean vector_item_expr_3(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_3")) return false; + expr(b, l + 1, -1); + return true; + } + + // RPARENTH? + private static boolean vector_item_expr_4(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_expr_4")) return false; + consumeToken(b, RPARENTH); + return true; + } + + /* ********************************************************** */ + // for_element | if_element | bind_else_element | else_element | let_element | EACH_KEYWORD + static boolean vector_item_prefix_element(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_item_prefix_element")) return false; boolean r; r = for_element(b, l + 1); if (!r) r = if_element(b, l + 1); if (!r) r = bind_else_element(b, l + 1); if (!r) r = else_element(b, l + 1); if (!r) r = let_element(b, l + 1); - if (!r) r = echo_element(b, l + 1); - if (!r) r = assert_element(b, l + 1); + if (!r) r = consumeToken(b, EACH_KEYWORD); return r; } @@ -1566,10 +1971,10 @@ private static boolean vector_item_0_0(PsiBuilder b, int l) { // 2: BINARY(plus_expr) BINARY(minus_expr) // 3: BINARY(mul_expr) BINARY(div_expr) BINARY(modulo_expr) BINARY(power_expr) // 4: PREFIX(unary_plus_expr) PREFIX(unary_min_expr) PREFIX(unary_negate_expr) - // 5: ATOM(range_expr) PREFIX(echo_expr) PREFIX(assert_expr) PREFIX(test_expr) - // ATOM(builtin_expr) ATOM(function_call_expr) ATOM(variable_ref_expr) ATOM(vector_expr) - // PREFIX(paren_expr) ATOM(literal_expr) PREFIX(function_literal_expr) POSTFIX(index_expr) - // POSTFIX(qualification_expr) + // 5: ATOM(range_expr) ATOM(echo_expr) ATOM(assert_expr) PREFIX(test_expr) + // ATOM(builtin_expr) PREFIX(each_expr) ATOM(function_call_expr) ATOM(variable_ref_expr) + // ATOM(vector_expr) PREFIX(paren_expr) ATOM(literal_expr) PREFIX(function_literal_expr) + // POSTFIX(index_expr) POSTFIX(qualification_expr) public static boolean expr(PsiBuilder b, int l, int g) { if (!recursion_guard_(b, l, "expr")) return false; addVariant(b, ""); @@ -1583,6 +1988,7 @@ public static boolean expr(PsiBuilder b, int l, int g) { if (!r) r = assert_expr(b, l + 1); if (!r) r = test_expr(b, l + 1); if (!r) r = builtin_expr(b, l + 1); + if (!r) r = each_expr(b, l + 1); if (!r) r = function_call_expr(b, l + 1); if (!r) r = variable_ref_expr(b, l + 1); if (!r) r = vector_expr(b, l + 1); @@ -1736,40 +2142,32 @@ public static boolean unary_negate_expr(PsiBuilder b, int l) { return r || p; } - // [EACH_KEYWORD] LBRACKET expr COLON expr [ COLON expr ] RBRACKET + // LBRACKET expr COLON expr [ COLON expr ] RBRACKET public static boolean range_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "range_expr")) return false; - if (!nextTokenIsSmart(b, EACH_KEYWORD, LBRACKET)) return false; + if (!nextTokenIsSmart(b, LBRACKET)) return false; boolean r; - Marker m = enter_section_(b, l, _NONE_, RANGE_EXPR, ""); - r = range_expr_0(b, l + 1); - r = r && consumeToken(b, LBRACKET); + Marker m = enter_section_(b); + r = consumeTokenSmart(b, LBRACKET); r = r && expr(b, l + 1, -1); r = r && consumeToken(b, COLON); r = r && expr(b, l + 1, -1); - r = r && range_expr_5(b, l + 1); + r = r && range_expr_4(b, l + 1); r = r && consumeToken(b, RBRACKET); - exit_section_(b, l, m, r, false, null); + exit_section_(b, m, RANGE_EXPR, r); return r; } - // [EACH_KEYWORD] - private static boolean range_expr_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "range_expr_0")) return false; - consumeTokenSmart(b, EACH_KEYWORD); - return true; - } - // [ COLON expr ] - private static boolean range_expr_5(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "range_expr_5")) return false; - range_expr_5_0(b, l + 1); + private static boolean range_expr_4(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "range_expr_4")) return false; + range_expr_4_0(b, l + 1); return true; } // COLON expr - private static boolean range_expr_5_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "range_expr_5_0")) return false; + private static boolean range_expr_4_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "range_expr_4_0")) return false; boolean r; Marker m = enter_section_(b); r = consumeTokenSmart(b, COLON); @@ -1778,26 +2176,42 @@ private static boolean range_expr_5_0(PsiBuilder b, int l) { return r; } + // echo_element expr? public static boolean echo_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "echo_expr")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, null); + if (!nextTokenIsSmart(b, ECHO_KEYWORD)) return false; + boolean r; + Marker m = enter_section_(b); r = echo_element(b, l + 1); - p = r; - r = p && expr(b, l, -1); - exit_section_(b, l, m, ECHO_EXPR, r, p, null); - return r || p; + r = r && echo_expr_1(b, l + 1); + exit_section_(b, m, ECHO_EXPR, r); + return r; + } + + // expr? + private static boolean echo_expr_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "echo_expr_1")) return false; + expr(b, l + 1, -1); + return true; } + // assert_element expr? public static boolean assert_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "assert_expr")) return false; - boolean r, p; - Marker m = enter_section_(b, l, _NONE_, null); + if (!nextTokenIsSmart(b, ASSERT_KEYWORD)) return false; + boolean r; + Marker m = enter_section_(b); r = assert_element(b, l + 1); - p = r; - r = p && expr(b, l, -1); - exit_section_(b, l, m, ASSERT_EXPR, r, p, null); - return r || p; + r = r && assert_expr_1(b, l + 1); + exit_section_(b, m, ASSERT_EXPR, r); + return r; + } + + // expr? + private static boolean assert_expr_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "assert_expr_1")) return false; + expr(b, l + 1, -1); + return true; } public static boolean test_expr(PsiBuilder b, int l) { @@ -1825,12 +2239,14 @@ private static boolean test_expr_0(PsiBuilder b, int l) { // builtin_expr_ref arg_assignment_list // | LET_KEYWORD full_arg_declaration_list expr + // | builtin_overridable_expr_ref public static boolean builtin_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "builtin_expr")) return false; boolean r; Marker m = enter_section_(b, l, _NONE_, BUILTIN_EXPR, ""); r = builtin_expr_0(b, l + 1); if (!r) r = builtin_expr_1(b, l + 1); + if (!r) r = builtin_overridable_expr_ref(b, l + 1); exit_section_(b, l, m, r, false, null); return r; } @@ -1858,6 +2274,18 @@ private static boolean builtin_expr_1(PsiBuilder b, int l) { return r; } + public static boolean each_expr(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "each_expr")) return false; + if (!nextTokenIsSmart(b, EACH_KEYWORD)) return false; + boolean r, p; + Marker m = enter_section_(b, l, _NONE_, null); + r = consumeTokenSmart(b, EACH_KEYWORD); + p = r; + r = p && expr(b, l, -1); + exit_section_(b, l, m, EACH_EXPR, r, p, null); + return r || p; + } + // function_name_ref arg_assignment_list+ public static boolean function_call_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "function_call_expr")) return false; @@ -1896,97 +2324,76 @@ public static boolean variable_ref_expr(PsiBuilder b, int l) { return r; } - // [EACH_KEYWORD] LBRACKET [vector_item ( COMMA+ (vector_item | &RBRACKET) )*] RBRACKET + // LBRACKET [vector_item ( COMMA (vector_item | &RBRACKET) )*] RBRACKET public static boolean vector_expr(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "vector_expr")) return false; - if (!nextTokenIsSmart(b, EACH_KEYWORD, LBRACKET)) return false; + if (!nextTokenIsSmart(b, LBRACKET)) return false; boolean r, p; - Marker m = enter_section_(b, l, _NONE_, VECTOR_EXPR, ""); - r = vector_expr_0(b, l + 1); - r = r && consumeToken(b, LBRACKET); - p = r; // pin = 2 - r = r && report_error_(b, vector_expr_2(b, l + 1)); + Marker m = enter_section_(b, l, _NONE_, VECTOR_EXPR, null); + r = consumeTokenSmart(b, LBRACKET); + p = r; // pin = 1 + r = r && report_error_(b, vector_expr_1(b, l + 1)); r = p && consumeToken(b, RBRACKET) && r; exit_section_(b, l, m, r, p, null); return r || p; } - // [EACH_KEYWORD] - private static boolean vector_expr_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_0")) return false; - consumeTokenSmart(b, EACH_KEYWORD); - return true; - } - - // [vector_item ( COMMA+ (vector_item | &RBRACKET) )*] - private static boolean vector_expr_2(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2")) return false; - vector_expr_2_0(b, l + 1); + // [vector_item ( COMMA (vector_item | &RBRACKET) )*] + private static boolean vector_expr_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1")) return false; + vector_expr_1_0(b, l + 1); return true; } - // vector_item ( COMMA+ (vector_item | &RBRACKET) )* - private static boolean vector_expr_2_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0")) return false; - boolean r; - Marker m = enter_section_(b); + // vector_item ( COMMA (vector_item | &RBRACKET) )* + private static boolean vector_expr_1_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1_0")) return false; + boolean r, p; + Marker m = enter_section_(b, l, _NONE_); r = vector_item(b, l + 1); - r = r && vector_expr_2_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; + p = r; // pin = 1 + r = r && vector_expr_1_0_1(b, l + 1); + exit_section_(b, l, m, r, p, null); + return r || p; } - // ( COMMA+ (vector_item | &RBRACKET) )* - private static boolean vector_expr_2_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0_1")) return false; + // ( COMMA (vector_item | &RBRACKET) )* + private static boolean vector_expr_1_0_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1_0_1")) return false; while (true) { int c = current_position_(b); - if (!vector_expr_2_0_1_0(b, l + 1)) break; - if (!empty_element_parsed_guard_(b, "vector_expr_2_0_1", c)) break; + if (!vector_expr_1_0_1_0(b, l + 1)) break; + if (!empty_element_parsed_guard_(b, "vector_expr_1_0_1", c)) break; } return true; } - // COMMA+ (vector_item | &RBRACKET) - private static boolean vector_expr_2_0_1_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0_1_0")) return false; - boolean r; - Marker m = enter_section_(b); - r = vector_expr_2_0_1_0_0(b, l + 1); - r = r && vector_expr_2_0_1_0_1(b, l + 1); - exit_section_(b, m, null, r); - return r; - } - - // COMMA+ - private static boolean vector_expr_2_0_1_0_0(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0_1_0_0")) return false; - boolean r; - Marker m = enter_section_(b); + // COMMA (vector_item | &RBRACKET) + private static boolean vector_expr_1_0_1_0(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1_0_1_0")) return false; + boolean r, p; + Marker m = enter_section_(b, l, _NONE_); r = consumeTokenSmart(b, COMMA); - while (r) { - int c = current_position_(b); - if (!consumeTokenSmart(b, COMMA)) break; - if (!empty_element_parsed_guard_(b, "vector_expr_2_0_1_0_0", c)) break; - } - exit_section_(b, m, null, r); - return r; + p = r; // pin = 1 + r = r && vector_expr_1_0_1_0_1(b, l + 1); + exit_section_(b, l, m, r, p, null); + return r || p; } // vector_item | &RBRACKET - private static boolean vector_expr_2_0_1_0_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0_1_0_1")) return false; + private static boolean vector_expr_1_0_1_0_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1_0_1_0_1")) return false; boolean r; Marker m = enter_section_(b); r = vector_item(b, l + 1); - if (!r) r = vector_expr_2_0_1_0_1_1(b, l + 1); + if (!r) r = vector_expr_1_0_1_0_1_1(b, l + 1); exit_section_(b, m, null, r); return r; } // &RBRACKET - private static boolean vector_expr_2_0_1_0_1_1(PsiBuilder b, int l) { - if (!recursion_guard_(b, l, "vector_expr_2_0_1_0_1_1")) return false; + private static boolean vector_expr_1_0_1_0_1_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "vector_expr_1_0_1_0_1_1")) return false; boolean r; Marker m = enter_section_(b, l, _AND_); r = consumeTokenSmart(b, RBRACKET); @@ -2048,16 +2455,27 @@ private static boolean function_literal_expr_0(PsiBuilder b, int l) { return r; } - // LBRACKET <> RBRACKET + // LBRACKET (elvis_expr | <>) RBRACKET private static boolean index_expr_0(PsiBuilder b, int l) { if (!recursion_guard_(b, l, "index_expr_0")) return false; boolean r; Marker m = enter_section_(b); r = consumeTokenSmart(b, LBRACKET); - r = r && innerExpression(b, l + 1); + r = r && index_expr_0_1(b, l + 1); r = r && consumeToken(b, RBRACKET); exit_section_(b, m, null, r); return r; } + // elvis_expr | <> + private static boolean index_expr_0_1(PsiBuilder b, int l) { + if (!recursion_guard_(b, l, "index_expr_0_1")) return false; + boolean r; + Marker m = enter_section_(b); + r = expr(b, l + 1, -1); + if (!r) r = innerExpression(b, l + 1); + exit_section_(b, m, null, r); + return r; + } + } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertArgList.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertArgList.java new file mode 100644 index 0000000..d6b8c2f --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertArgList.java @@ -0,0 +1,13 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; + +public interface OpenSCADAssertArgList extends PsiElement { + + @NotNull + List getExprList(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertElement.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertElement.java index fbb2dd3..52f9dda 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertElement.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADAssertElement.java @@ -8,6 +8,6 @@ public interface OpenSCADAssertElement extends PsiElement { @NotNull - OpenSCADExpr getExpr(); + OpenSCADAssertArgList getAssertArgList(); } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinExpr.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinExpr.java index dd5a51b..358973e 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinExpr.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinExpr.java @@ -13,6 +13,9 @@ public interface OpenSCADBuiltinExpr extends OpenSCADExpr { @Nullable OpenSCADBuiltinExprRef getBuiltinExprRef(); + @Nullable + OpenSCADBuiltinOverridableExprRef getBuiltinOverridableExprRef(); + @Nullable OpenSCADExpr getExpr(); diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinObj.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinObj.java index 2617db5..cecb4b4 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinObj.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinObj.java @@ -10,12 +10,21 @@ public interface OpenSCADBuiltinObj extends OpenSCADObject { @Nullable OpenSCADArgAssignmentList getArgAssignmentList(); + @NotNull + List getAssertElementList(); + @Nullable OpenSCADBuiltinObjRef getBuiltinObjRef(); @Nullable OpenSCADBuiltinOp getBuiltinOp(); + @Nullable + OpenSCADBuiltinOverridableObjRef getBuiltinOverridableObjRef(); + + @NotNull + List getEchoElementList(); + @Nullable OpenSCADFunctionDeclaration getFunctionDeclaration(); diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOp.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOp.java index 5fd6cc1..0757eec 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOp.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOp.java @@ -10,7 +10,13 @@ public interface OpenSCADBuiltinOp extends OpenSCADOperator { @NotNull OpenSCADArgAssignmentList getArgAssignmentList(); - @NotNull + @Nullable + OpenSCADBuiltinOverridableOpAsFunctionRef getBuiltinOverridableOpAsFunctionRef(); + + @Nullable + OpenSCADBuiltinOverridableOpRef getBuiltinOverridableOpRef(); + + @Nullable OpenSCADCommonOpRef getCommonOpRef(); } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableExprRef.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableExprRef.java new file mode 100644 index 0000000..342ec60 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableExprRef.java @@ -0,0 +1,19 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; + +public interface OpenSCADBuiltinOverridableExprRef extends PsiElement { + + @NotNull + OpenSCADArgAssignmentList getArgAssignmentList(); + + @Nullable + OpenSCADBuiltinOverridableOpAsFunctionRef getBuiltinOverridableOpAsFunctionRef(); + + @Nullable + OpenSCADBuiltinOverridableOpRef getBuiltinOverridableOpRef(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableObjRef.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableObjRef.java new file mode 100644 index 0000000..f944304 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableObjRef.java @@ -0,0 +1,15 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; +import com.intellij.navigation.ItemPresentation; + +public interface OpenSCADBuiltinOverridableObjRef extends OpenSCADResolvableElement { + + ItemPresentation getPresentation(); + + PsiElement getNameIdentifier(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpAsFunctionRef.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpAsFunctionRef.java new file mode 100644 index 0000000..6226f7f --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpAsFunctionRef.java @@ -0,0 +1,15 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; +import com.intellij.navigation.ItemPresentation; + +public interface OpenSCADBuiltinOverridableOpAsFunctionRef extends OpenSCADResolvableElement { + + ItemPresentation getPresentation(); + + PsiElement getNameIdentifier(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpRef.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpRef.java new file mode 100644 index 0000000..5c3a3fc --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADBuiltinOverridableOpRef.java @@ -0,0 +1,15 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; +import com.intellij.navigation.ItemPresentation; + +public interface OpenSCADBuiltinOverridableOpRef extends OpenSCADResolvableElement { + + ItemPresentation getPresentation(); + + PsiElement getNameIdentifier(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADEachExpr.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADEachExpr.java new file mode 100644 index 0000000..2a2e38e --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADEachExpr.java @@ -0,0 +1,13 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; + +public interface OpenSCADEachExpr extends OpenSCADExpr { + + @Nullable + OpenSCADExpr getExpr(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADFullArgDeclaration.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADFullArgDeclaration.java index 22edd95..a32e814 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADFullArgDeclaration.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADFullArgDeclaration.java @@ -8,7 +8,7 @@ public interface OpenSCADFullArgDeclaration extends OpenSCADNamedElement { @NotNull - OpenSCADExpr getExpr(); + List getExprList(); PsiElement getNameIdentifier(); diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADIndexExpr.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADIndexExpr.java index b1a1294..5be6891 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADIndexExpr.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADIndexExpr.java @@ -8,6 +8,6 @@ public interface OpenSCADIndexExpr extends OpenSCADExpr { @NotNull - OpenSCADExpr getExpr(); + List getExprList(); } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADReportingElement.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADReportingElement.java new file mode 100644 index 0000000..7f1c262 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADReportingElement.java @@ -0,0 +1,16 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.psi.PsiElement; + +public interface OpenSCADReportingElement extends PsiElement { + + @Nullable + OpenSCADAssertElement getAssertElement(); + + @Nullable + OpenSCADEchoElement getEchoElement(); + +} diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADTypes.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADTypes.java index 838baa0..6041514 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADTypes.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADTypes.java @@ -13,6 +13,7 @@ public interface OpenSCADTypes { IElementType ARG_ASSIGNMENT_LIST = OpenSCADElementFactory.getElementType("ARG_ASSIGNMENT_LIST"); IElementType ARG_DECLARATION = OpenSCADElementFactory.getElementType("ARG_DECLARATION"); IElementType ARG_DECLARATION_LIST = OpenSCADElementFactory.getElementType("ARG_DECLARATION_LIST"); + IElementType ASSERT_ARG_LIST = OpenSCADElementFactory.getElementType("ASSERT_ARG_LIST"); IElementType ASSERT_ELEMENT = OpenSCADElementFactory.getElementType("ASSERT_ELEMENT"); IElementType ASSERT_EXPR = OpenSCADElementFactory.getElementType("ASSERT_EXPR"); IElementType BACKGROUND_OP = OpenSCADElementFactory.getElementType("BACKGROUND_OP"); @@ -23,11 +24,16 @@ public interface OpenSCADTypes { IElementType BUILTIN_OBJ = OpenSCADElementFactory.getElementType("BUILTIN_OBJ"); IElementType BUILTIN_OBJ_REF = OpenSCADElementFactory.getElementType("BUILTIN_OBJ_REF"); IElementType BUILTIN_OP = OpenSCADElementFactory.getElementType("BUILTIN_OP"); + IElementType BUILTIN_OVERRIDABLE_EXPR_REF = OpenSCADElementFactory.getElementType("BUILTIN_OVERRIDABLE_EXPR_REF"); + IElementType BUILTIN_OVERRIDABLE_OBJ_REF = OpenSCADElementFactory.getElementType("BUILTIN_OVERRIDABLE_OBJ_REF"); + IElementType BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF = OpenSCADElementFactory.getElementType("BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF"); + IElementType BUILTIN_OVERRIDABLE_OP_REF = OpenSCADElementFactory.getElementType("BUILTIN_OVERRIDABLE_OP_REF"); IElementType COMMON_OP_REF = OpenSCADElementFactory.getElementType("COMMON_OP_REF"); IElementType CONDITIONAL_EXPR = OpenSCADElementFactory.getElementType("CONDITIONAL_EXPR"); IElementType DEBUG_OP = OpenSCADElementFactory.getElementType("DEBUG_OP"); IElementType DISABLE_OP = OpenSCADElementFactory.getElementType("DISABLE_OP"); IElementType DIV_EXPR = OpenSCADElementFactory.getElementType("DIV_EXPR"); + IElementType EACH_EXPR = OpenSCADElementFactory.getElementType("EACH_EXPR"); IElementType ECHO_ARG_LIST = OpenSCADElementFactory.getElementType("ECHO_ARG_LIST"); IElementType ECHO_ELEMENT = OpenSCADElementFactory.getElementType("ECHO_ELEMENT"); IElementType ECHO_EXPR = OpenSCADElementFactory.getElementType("ECHO_EXPR"); @@ -73,6 +79,7 @@ public interface OpenSCADTypes { IElementType POWER_EXPR = OpenSCADElementFactory.getElementType("POWER_EXPR"); IElementType QUALIFICATION_EXPR = OpenSCADElementFactory.getElementType("QUALIFICATION_EXPR"); IElementType RANGE_EXPR = OpenSCADElementFactory.getElementType("RANGE_EXPR"); + IElementType REPORTING_ELEMENT = OpenSCADElementFactory.getElementType("REPORTING_ELEMENT"); IElementType ROOT_OP = OpenSCADElementFactory.getElementType("ROOT_OP"); IElementType TEST_EXPR = OpenSCADElementFactory.getElementType("TEST_EXPR"); IElementType TEST_EXP_REF = OpenSCADElementFactory.getElementType("TEST_EXP_REF"); @@ -229,6 +236,9 @@ else if (type == ARG_DECLARATION) { else if (type == ARG_DECLARATION_LIST) { return new OpenSCADArgDeclarationListImpl(node); } + else if (type == ASSERT_ARG_LIST) { + return new OpenSCADAssertArgListImpl(node); + } else if (type == ASSERT_ELEMENT) { return new OpenSCADAssertElementImpl(node); } @@ -259,6 +269,18 @@ else if (type == BUILTIN_OBJ_REF) { else if (type == BUILTIN_OP) { return new OpenSCADBuiltinOpImpl(node); } + else if (type == BUILTIN_OVERRIDABLE_EXPR_REF) { + return new OpenSCADBuiltinOverridableExprRefImpl(node); + } + else if (type == BUILTIN_OVERRIDABLE_OBJ_REF) { + return new OpenSCADBuiltinOverridableObjRefImpl(node); + } + else if (type == BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF) { + return new OpenSCADBuiltinOverridableOpAsFunctionRefImpl(node); + } + else if (type == BUILTIN_OVERRIDABLE_OP_REF) { + return new OpenSCADBuiltinOverridableOpRefImpl(node); + } else if (type == COMMON_OP_REF) { return new OpenSCADCommonOpRefImpl(node); } @@ -274,6 +296,9 @@ else if (type == DISABLE_OP) { else if (type == DIV_EXPR) { return new OpenSCADDivExprImpl(node); } + else if (type == EACH_EXPR) { + return new OpenSCADEachExprImpl(node); + } else if (type == ECHO_ARG_LIST) { return new OpenSCADEchoArgListImpl(node); } @@ -400,6 +425,9 @@ else if (type == QUALIFICATION_EXPR) { else if (type == RANGE_EXPR) { return new OpenSCADRangeExprImpl(node); } + else if (type == REPORTING_ELEMENT) { + return new OpenSCADReportingElementImpl(node); + } else if (type == ROOT_OP) { return new OpenSCADRootOpImpl(node); } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADVectorExpr.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADVectorExpr.java index fa88065..a60f388 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADVectorExpr.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADVectorExpr.java @@ -7,15 +7,9 @@ public interface OpenSCADVectorExpr extends OpenSCADExpr { - @NotNull - List getAssertElementList(); - @NotNull List getBindElseElementList(); - @NotNull - List getEchoElementList(); - @NotNull List getElseElementList(); @@ -31,4 +25,7 @@ public interface OpenSCADVectorExpr extends OpenSCADExpr { @NotNull List getLetElementList(); + @NotNull + List getReportingElementList(); + } diff --git a/src/main/gen/com/javampire/openscad/psi/OpenSCADVisitor.java b/src/main/gen/com/javampire/openscad/psi/OpenSCADVisitor.java index fa24391..c1ce17d 100644 --- a/src/main/gen/com/javampire/openscad/psi/OpenSCADVisitor.java +++ b/src/main/gen/com/javampire/openscad/psi/OpenSCADVisitor.java @@ -31,6 +31,10 @@ public void visitArgDeclarationList(@NotNull OpenSCADArgDeclarationList o) { visitPsiElement(o); } + public void visitAssertArgList(@NotNull OpenSCADAssertArgList o) { + visitPsiElement(o); + } + public void visitAssertElement(@NotNull OpenSCADAssertElement o) { visitPsiElement(o); } @@ -71,6 +75,22 @@ public void visitBuiltinOp(@NotNull OpenSCADBuiltinOp o) { visitOperator(o); } + public void visitBuiltinOverridableExprRef(@NotNull OpenSCADBuiltinOverridableExprRef o) { + visitPsiElement(o); + } + + public void visitBuiltinOverridableObjRef(@NotNull OpenSCADBuiltinOverridableObjRef o) { + visitResolvableElement(o); + } + + public void visitBuiltinOverridableOpAsFunctionRef(@NotNull OpenSCADBuiltinOverridableOpAsFunctionRef o) { + visitResolvableElement(o); + } + + public void visitBuiltinOverridableOpRef(@NotNull OpenSCADBuiltinOverridableOpRef o) { + visitResolvableElement(o); + } + public void visitCommonOpRef(@NotNull OpenSCADCommonOpRef o) { visitResolvableElement(o); } @@ -91,6 +111,10 @@ public void visitDivExpr(@NotNull OpenSCADDivExpr o) { visitExpr(o); } + public void visitEachExpr(@NotNull OpenSCADEachExpr o) { + visitExpr(o); + } + public void visitEchoArgList(@NotNull OpenSCADEchoArgList o) { visitPsiElement(o); } @@ -274,6 +298,10 @@ public void visitRangeExpr(@NotNull OpenSCADRangeExpr o) { visitExpr(o); } + public void visitReportingElement(@NotNull OpenSCADReportingElement o) { + visitPsiElement(o); + } + public void visitRootOp(@NotNull OpenSCADRootOp o) { visitOperator(o); } diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertArgListImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertArgListImpl.java new file mode 100644 index 0000000..7c46774 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertArgListImpl.java @@ -0,0 +1,36 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.intellij.extapi.psi.ASTWrapperPsiElement; +import com.javampire.openscad.psi.*; + +public class OpenSCADAssertArgListImpl extends ASTWrapperPsiElement implements OpenSCADAssertArgList { + + public OpenSCADAssertArgListImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitAssertArgList(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + @NotNull + public List getExprList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADExpr.class); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertElementImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertElementImpl.java index ad701a2..ec2c630 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertElementImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADAssertElementImpl.java @@ -29,8 +29,8 @@ public void accept(@NotNull PsiElementVisitor visitor) { @Override @NotNull - public OpenSCADExpr getExpr() { - return findNotNullChildByClass(OpenSCADExpr.class); + public OpenSCADAssertArgList getAssertArgList() { + return findNotNullChildByClass(OpenSCADAssertArgList.class); } } diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinExprImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinExprImpl.java index d78f2ef..ecb564c 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinExprImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinExprImpl.java @@ -39,6 +39,12 @@ public OpenSCADBuiltinExprRef getBuiltinExprRef() { return findChildByClass(OpenSCADBuiltinExprRef.class); } + @Override + @Nullable + public OpenSCADBuiltinOverridableExprRef getBuiltinOverridableExprRef() { + return findChildByClass(OpenSCADBuiltinOverridableExprRef.class); + } + @Override @Nullable public OpenSCADExpr getExpr() { diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinObjImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinObjImpl.java index 093e93e..7c1ba0f 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinObjImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinObjImpl.java @@ -33,6 +33,12 @@ public OpenSCADArgAssignmentList getArgAssignmentList() { return findChildByClass(OpenSCADArgAssignmentList.class); } + @Override + @NotNull + public List getAssertElementList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADAssertElement.class); + } + @Override @Nullable public OpenSCADBuiltinObjRef getBuiltinObjRef() { @@ -45,6 +51,18 @@ public OpenSCADBuiltinOp getBuiltinOp() { return findChildByClass(OpenSCADBuiltinOp.class); } + @Override + @Nullable + public OpenSCADBuiltinOverridableObjRef getBuiltinOverridableObjRef() { + return findChildByClass(OpenSCADBuiltinOverridableObjRef.class); + } + + @Override + @NotNull + public List getEchoElementList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADEchoElement.class); + } + @Override @Nullable public OpenSCADFunctionDeclaration getFunctionDeclaration() { diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOpImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOpImpl.java index 884bf37..376085f 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOpImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOpImpl.java @@ -34,9 +34,21 @@ public OpenSCADArgAssignmentList getArgAssignmentList() { } @Override - @NotNull + @Nullable + public OpenSCADBuiltinOverridableOpAsFunctionRef getBuiltinOverridableOpAsFunctionRef() { + return findChildByClass(OpenSCADBuiltinOverridableOpAsFunctionRef.class); + } + + @Override + @Nullable + public OpenSCADBuiltinOverridableOpRef getBuiltinOverridableOpRef() { + return findChildByClass(OpenSCADBuiltinOverridableOpRef.class); + } + + @Override + @Nullable public OpenSCADCommonOpRef getCommonOpRef() { - return findNotNullChildByClass(OpenSCADCommonOpRef.class); + return findChildByClass(OpenSCADCommonOpRef.class); } } diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableExprRefImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableExprRefImpl.java new file mode 100644 index 0000000..624a4da --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableExprRefImpl.java @@ -0,0 +1,48 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.intellij.extapi.psi.ASTWrapperPsiElement; +import com.javampire.openscad.psi.*; + +public class OpenSCADBuiltinOverridableExprRefImpl extends ASTWrapperPsiElement implements OpenSCADBuiltinOverridableExprRef { + + public OpenSCADBuiltinOverridableExprRefImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitBuiltinOverridableExprRef(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + @NotNull + public OpenSCADArgAssignmentList getArgAssignmentList() { + return findNotNullChildByClass(OpenSCADArgAssignmentList.class); + } + + @Override + @Nullable + public OpenSCADBuiltinOverridableOpAsFunctionRef getBuiltinOverridableOpAsFunctionRef() { + return findChildByClass(OpenSCADBuiltinOverridableOpAsFunctionRef.class); + } + + @Override + @Nullable + public OpenSCADBuiltinOverridableOpRef getBuiltinOverridableOpRef() { + return findChildByClass(OpenSCADBuiltinOverridableOpRef.class); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableObjRefImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableObjRefImpl.java new file mode 100644 index 0000000..5f999f0 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableObjRefImpl.java @@ -0,0 +1,41 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.javampire.openscad.psi.OpenSCADResolvableElementImpl; +import com.javampire.openscad.psi.*; +import com.intellij.navigation.ItemPresentation; + +public class OpenSCADBuiltinOverridableObjRefImpl extends OpenSCADResolvableElementImpl implements OpenSCADBuiltinOverridableObjRef { + + public OpenSCADBuiltinOverridableObjRefImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitBuiltinOverridableObjRef(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + public ItemPresentation getPresentation() { + return OpenSCADPsiImplUtil.getPresentation(this); + } + + @Override + public PsiElement getNameIdentifier() { + return OpenSCADPsiImplUtil.getNameIdentifier(this); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpAsFunctionRefImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpAsFunctionRefImpl.java new file mode 100644 index 0000000..19c4574 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpAsFunctionRefImpl.java @@ -0,0 +1,41 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.javampire.openscad.psi.OpenSCADResolvableElementImpl; +import com.javampire.openscad.psi.*; +import com.intellij.navigation.ItemPresentation; + +public class OpenSCADBuiltinOverridableOpAsFunctionRefImpl extends OpenSCADResolvableElementImpl implements OpenSCADBuiltinOverridableOpAsFunctionRef { + + public OpenSCADBuiltinOverridableOpAsFunctionRefImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitBuiltinOverridableOpAsFunctionRef(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + public ItemPresentation getPresentation() { + return OpenSCADPsiImplUtil.getPresentation(this); + } + + @Override + public PsiElement getNameIdentifier() { + return OpenSCADPsiImplUtil.getNameIdentifier(this); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpRefImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpRefImpl.java new file mode 100644 index 0000000..16bce94 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADBuiltinOverridableOpRefImpl.java @@ -0,0 +1,41 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.javampire.openscad.psi.OpenSCADResolvableElementImpl; +import com.javampire.openscad.psi.*; +import com.intellij.navigation.ItemPresentation; + +public class OpenSCADBuiltinOverridableOpRefImpl extends OpenSCADResolvableElementImpl implements OpenSCADBuiltinOverridableOpRef { + + public OpenSCADBuiltinOverridableOpRefImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitBuiltinOverridableOpRef(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + public ItemPresentation getPresentation() { + return OpenSCADPsiImplUtil.getPresentation(this); + } + + @Override + public PsiElement getNameIdentifier() { + return OpenSCADPsiImplUtil.getNameIdentifier(this); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADEachExprImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADEachExprImpl.java new file mode 100644 index 0000000..ce20673 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADEachExprImpl.java @@ -0,0 +1,36 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.javampire.openscad.psi.*; + +public class OpenSCADEachExprImpl extends OpenSCADExprImpl implements OpenSCADEachExpr { + + public OpenSCADEachExprImpl(@NotNull ASTNode node) { + super(node); + } + + @Override + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitEachExpr(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + @Nullable + public OpenSCADExpr getExpr() { + return findChildByClass(OpenSCADExpr.class); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADFullArgDeclarationImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADFullArgDeclarationImpl.java index 8221827..7301d13 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADFullArgDeclarationImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADFullArgDeclarationImpl.java @@ -29,8 +29,8 @@ public void accept(@NotNull PsiElementVisitor visitor) { @Override @NotNull - public OpenSCADExpr getExpr() { - return findNotNullChildByClass(OpenSCADExpr.class); + public List getExprList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADExpr.class); } @Override diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADIndexExprImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADIndexExprImpl.java index 683f26b..7b1246d 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADIndexExprImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADIndexExprImpl.java @@ -29,8 +29,8 @@ public void accept(@NotNull PsiElementVisitor visitor) { @Override @NotNull - public OpenSCADExpr getExpr() { - return findNotNullChildByClass(OpenSCADExpr.class); + public List getExprList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADExpr.class); } } diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADReportingElementImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADReportingElementImpl.java new file mode 100644 index 0000000..ae84420 --- /dev/null +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADReportingElementImpl.java @@ -0,0 +1,42 @@ +// This is a generated file. Not intended for manual editing. +package com.javampire.openscad.psi.impl; + +import java.util.List; +import org.jetbrains.annotations.*; +import com.intellij.lang.ASTNode; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiElementVisitor; +import com.intellij.psi.util.PsiTreeUtil; +import static com.javampire.openscad.psi.OpenSCADTypes.*; +import com.intellij.extapi.psi.ASTWrapperPsiElement; +import com.javampire.openscad.psi.*; + +public class OpenSCADReportingElementImpl extends ASTWrapperPsiElement implements OpenSCADReportingElement { + + public OpenSCADReportingElementImpl(@NotNull ASTNode node) { + super(node); + } + + public void accept(@NotNull OpenSCADVisitor visitor) { + visitor.visitReportingElement(this); + } + + @Override + public void accept(@NotNull PsiElementVisitor visitor) { + if (visitor instanceof OpenSCADVisitor) accept((OpenSCADVisitor)visitor); + else super.accept(visitor); + } + + @Override + @Nullable + public OpenSCADAssertElement getAssertElement() { + return findChildByClass(OpenSCADAssertElement.class); + } + + @Override + @Nullable + public OpenSCADEchoElement getEchoElement() { + return findChildByClass(OpenSCADEchoElement.class); + } + +} diff --git a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADVectorExprImpl.java b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADVectorExprImpl.java index 7673db8..b013ca1 100644 --- a/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADVectorExprImpl.java +++ b/src/main/gen/com/javampire/openscad/psi/impl/OpenSCADVectorExprImpl.java @@ -27,24 +27,12 @@ public void accept(@NotNull PsiElementVisitor visitor) { else super.accept(visitor); } - @Override - @NotNull - public List getAssertElementList() { - return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADAssertElement.class); - } - @Override @NotNull public List getBindElseElementList() { return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADBindElseElement.class); } - @Override - @NotNull - public List getEchoElementList() { - return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADEchoElement.class); - } - @Override @NotNull public List getElseElementList() { @@ -75,4 +63,10 @@ public List getLetElementList() { return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADLetElement.class); } + @Override + @NotNull + public List getReportingElementList() { + return PsiTreeUtil.getChildrenOfTypeAsList(this, OpenSCADReportingElement.class); + } + } diff --git a/src/main/java/com/javampire/openscad/formatter/OpenSCADFormattingModelBuilder.java b/src/main/java/com/javampire/openscad/formatter/OpenSCADFormattingModelBuilder.java index 027c706..fe454bb 100644 --- a/src/main/java/com/javampire/openscad/formatter/OpenSCADFormattingModelBuilder.java +++ b/src/main/java/com/javampire/openscad/formatter/OpenSCADFormattingModelBuilder.java @@ -39,8 +39,10 @@ private SpacingBuilder createSpacingBuilder(CommonCodeStyleSettings settings) { .afterInside(IDENTIFIER, OpenSCADModuleStubElementType.INSTANCE).spaceIf(settings.SPACE_BEFORE_METHOD_PARENTHESES) .beforeInside(ARG_ASSIGNMENT_LIST, MODULE_CALL_OBJ).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) .afterInside(BUILTIN_OBJ_REF, BUILTIN_OBJ).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) + .afterInside(BUILTIN_OVERRIDABLE_OBJ_REF, BUILTIN_OBJ).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) .afterInside(COMMON_OP_REF, BUILTIN_OP).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) .afterInside(BUILTIN_EXPR_REF, BUILTIN_EXPR).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) + .afterInside(BUILTIN_OVERRIDABLE_EXPR_REF, BUILTIN_EXPR).spaceIf(settings.SPACE_BEFORE_METHOD_CALL_PARENTHESES) .after(IF_KEYWORD).spaceIf(settings.SPACE_BEFORE_IF_PARENTHESES) .after(FOR_KEYWORD).spaceIf(settings.SPACE_BEFORE_FOR_PARENTHESES) diff --git a/src/main/java/com/javampire/openscad/formatter/OpenSCADIndentBuilder.java b/src/main/java/com/javampire/openscad/formatter/OpenSCADIndentBuilder.java index cd3a497..4b58454 100644 --- a/src/main/java/com/javampire/openscad/formatter/OpenSCADIndentBuilder.java +++ b/src/main/java/com/javampire/openscad/formatter/OpenSCADIndentBuilder.java @@ -30,7 +30,10 @@ public Indent getChildIndent(final ASTNode node) { if (parentType == BLOCK_OBJ && !BRACES_TOKENS.contains(elementType)) { // Indent all BLOCK_OBJ (surrounded by brackets) children by default return Indent.getNormalIndent(); - } else if (parentType == BUILTIN_OBJ && elementType != BUILTIN_OP && elementType != BUILTIN_OBJ_REF) { // Indent statements in BUILTIN_OBJ without brackets + } else if (parentType == BUILTIN_OBJ && elementType != BUILTIN_OP && elementType != BUILTIN_OBJ_REF + && elementType != BUILTIN_OVERRIDABLE_OBJ_REF) + { + // Indent statements in BUILTIN_OBJ without brackets if (settings.INDENT_CASCADING_TRANSFORMATIONS) { return Indent.getNormalIndent(); } else { @@ -51,6 +54,8 @@ public Indent getChildIndent(final ASTNode node) { return Indent.getNormalIndent(); } else if (parentType == FULL_ARG_DECLARATION_LIST && elementType != RPARENTH) { return Indent.getNormalIndent(); + } else if (parentType == ARG_DECLARATION_LIST && elementType != RPARENTH) { + return Indent.getNormalIndent(); } return Indent.getNoneIndent(); diff --git a/src/main/java/com/javampire/openscad/grammar/openscad.bnf b/src/main/java/com/javampire/openscad/grammar/openscad.bnf index c5506d7..9c08359 100644 --- a/src/main/java/com/javampire/openscad/grammar/openscad.bnf +++ b/src/main/java/com/javampire/openscad/grammar/openscad.bnf @@ -29,7 +29,7 @@ private item ::= ( private comment_item ::= COMMENT_C_STYLE | COMMENT_DOC | COMMENT_SINGLELINE | COMMENT_SINGLELINE_BLOCK | COMMENT_CUSTOMIZER_VALUE | COMMENT_CUSTOMIZER_TABS -private statement ::= object | declaration | import +private statement ::= comment_item | (object | declaration | import) comment_item* import ::= ( include_import @@ -54,22 +54,20 @@ object ::= builtin_obj | empty_obj builtin_obj ::= (builtin_obj_ref arg_assignment_list SEMICOLON) + | (builtin_overridable_obj_ref arg_assignment_list SEMICOLON) | (builtin_op block_obj) | (builtin_op statement) + | (echo_element+ object) + | (assert_element+ object) builtin_obj_ref ::= ASSERT_KEYWORD | CHILD_KEYWORD | CHILDREN_KEYWORD - | CIRCLE_KEYWORD - | CUBE_KEYWORD - | CYLINDER_KEYWORD | ECHO_KEYWORD | IMPORT_KEYWORD | IMPORT_DXF_KEYWORD | IMPORT_STL_KEYWORD | POLYGON_KEYWORD | POLYHEDRON_KEYWORD - | SPHERE_KEYWORD - | SQUARE_KEYWORD | SURFACE_KEYWORD | TEXT_KEYWORD { mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" @@ -77,6 +75,49 @@ builtin_obj_ref ::= ASSERT_KEYWORD methods=[setName getNameIdentifier] } +// These can be a module or a function +private builtin_overridable_obj_keywords ::= + CIRCLE_KEYWORD + | CUBE_KEYWORD + | CYLINDER_KEYWORD + | SPHERE_KEYWORD + | SQUARE_KEYWORD + +builtin_overridable_obj_ref ::= builtin_overridable_obj_keywords + { + mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" + implements="com.javampire.openscad.psi.OpenSCADResolvableElement" + methods=[getPresentation getNameIdentifier] +} + +private builtin_overridable_op_keywords ::= + OFFSET_KEYWORD + | TRANSLATE_KEYWORD + | HULL_KEYWORD + | MIRROR_KEYWORD + | SCALE_KEYWORD + | DIFFERENCE_KEYWORD + | INTERSECTION_KEYWORD + | UNION_KEYWORD + +builtin_overridable_op_as_function_ref ::= builtin_overridable_op_keywords | builtin_overridable_obj_keywords + { + mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" + implements="com.javampire.openscad.psi.OpenSCADResolvableElement" + methods=[getPresentation getNameIdentifier] +} + +// These can be an operator or a function +builtin_overridable_expr_ref ::= builtin_overridable_op_as_function_ref arg_assignment_list + | builtin_overridable_op_ref arg_assignment_list + +builtin_overridable_op_ref ::= builtin_overridable_op_keywords + { + mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" + implements="com.javampire.openscad.psi.OpenSCADResolvableElement" + methods=[getPresentation getNameIdentifier] +} + module_call_obj ::= module_obj_name_ref arg_assignment_list SEMICOLON module_obj_name_ref ::= IDENTIFIER { mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" @@ -113,7 +154,7 @@ module_declaration ::= MODULE_KEYWORD IDENTIFIER arg_declaration_list statement methods=[getPresentation getNameIdentifier] } -function_declaration ::= FUNCTION_KEYWORD IDENTIFIER arg_declaration_list EQUALS expr SEMICOLON { +function_declaration ::= FUNCTION_KEYWORD (builtin_overridable_op_keywords | builtin_overridable_obj_keywords | IDENTIFIER) arg_declaration_list EQUALS expr SEMICOLON { pin=1 mixin="com.javampire.openscad.psi.stub.function.OpenSCADFunctionDeclarationStubElementImpl" implements=[ @@ -146,25 +187,20 @@ debug_op ::= HASH root_op ::= EXCL disable_op ::= MUL -builtin_op ::= common_op_ref arg_assignment_list +builtin_op ::= common_op_ref arg_assignment_list + | builtin_overridable_op_ref arg_assignment_list + | builtin_overridable_op_as_function_ref arg_assignment_list common_op_ref ::= COLOR_KEYWORD - | DIFFERENCE_KEYWORD - | HULL_KEYWORD - | INTERSECTION_KEYWORD | LINEAR_EXTRUDE_KEYWORD | MINKOWSKI_KEYWORD - | MIRROR_KEYWORD | MULTMATRIX_KEYWORD - | OFFSET_KEYWORD | PROJECTION_KEYWORD | RENDER_KEYWORD | RESIZE_KEYWORD | ROTATE_KEYWORD | ROTATE_EXTRUDE_KEYWORD - | SCALE_KEYWORD - | TRANSLATE_KEYWORD - | UNION_KEYWORD { + { mixin="com.javampire.openscad.psi.OpenSCADResolvableElementImpl" implements="com.javampire.openscad.psi.OpenSCADResolvableElement" methods=[setName getNameIdentifier] @@ -193,6 +229,7 @@ private primary_group ::= range_expr | assert_expr | test_expr | builtin_expr + | each_expr | function_call_expr | variable_ref_expr | vector_expr @@ -215,10 +252,12 @@ minus_expr ::= expr MINUS expr plus_expr ::= expr PLUS expr conditional_expr ::= expr ( LT | GT | LE | GE | EQ | NE ) expr echo_arg_list ::= LPARENTH ((IDENTIFIER EQUALS expr) | expr | IDENTIFIER | STRING_LITERAL) (COMMA ((IDENTIFIER EQUALS expr) | expr | IDENTIFIER | STRING_LITERAL))* RPARENTH -echo_element ::= "echo" echo_arg_list -echo_expr ::= echo_element expr -assert_expr ::= assert_element expr -assert_element ::= "assert" LPARENTH expr (',' STRING_LITERAL)? RPARENTH +echo_element ::= ECHO_KEYWORD echo_arg_list +echo_expr ::= echo_element expr? +assert_element ::= ASSERT_KEYWORD assert_arg_list +assert_arg_list ::= LPARENTH (expr | IDENTIFIER) (COMMA (expr | IDENTIFIER | STRING_LITERAL))* RPARENTH +assert_expr ::= assert_element expr? +reporting_element ::= comment_item* (echo_element | assert_element) elvis_expr ::= expr QUERY (elvis_expr | expr) COLON (elvis_expr | expr) test_expr ::= test_exp_ref LPARENTH expr RPARENTH test_exp_ref ::= IS_UNDEF_KEYWORD @@ -233,11 +272,14 @@ test_exp_ref ::= IS_UNDEF_KEYWORD } function_literal_expr ::= FUNCTION_KEYWORD arg_declaration_list expr paren_expr ::= LPARENTH expr RPARENTH -index_expr ::= expr LBRACKET <> RBRACKET -range_expr ::= [EACH_KEYWORD] LBRACKET expr COLON expr [ COLON expr ] RBRACKET +index_expr ::= expr LBRACKET (elvis_expr | <>) RBRACKET +each_expr ::= EACH_KEYWORD expr +range_expr ::= LBRACKET expr COLON expr [ COLON expr ] RBRACKET list_expr ::= LPARENTH expr (COMMA expr)* RPARENTH -vector_expr ::= [EACH_KEYWORD] LBRACKET [vector_item ( COMMA+ (vector_item | &RBRACKET) )*] RBRACKET { pin(".*")=2 } -private vector_item ::= (for_element | if_element | bind_else_element | else_element | let_element | echo_element | assert_element)* expr { recoverWhile=recover_vector } +vector_expr ::= LBRACKET [vector_item ( COMMA (vector_item | &RBRACKET) )*] RBRACKET { pin(".*")=1 } +private vector_item_prefix_element ::= (for_element | if_element | bind_else_element | else_element | let_element | EACH_KEYWORD) +private vector_item_expr ::= LPARENTH? (comment_item* (vector_item_prefix_element | reporting_element))+ comment_item* expr? RPARENTH? +private vector_item ::= comment_item* (vector_item_expr | expr ) { recoverWhile=recover_vector } private recover_vector ::= ! (COMMA | RBRACKET) for_element ::= FOR_KEYWORD for_declaration_list for_declaration_list ::= LPARENTH for_declaration RPARENTH {pin(".*")=1} @@ -249,6 +291,8 @@ else_element ::= ELSE_KEYWORD [if_element] let_element ::= LET_KEYWORD full_arg_declaration_list builtin_expr ::= builtin_expr_ref arg_assignment_list | LET_KEYWORD full_arg_declaration_list expr + | builtin_overridable_expr_ref + builtin_expr_ref ::= ABS_KEYWORD | ACOS_KEYWORD | ASIN_KEYWORD @@ -305,7 +349,7 @@ function_name_ref ::= IDENTIFIER { methods=[getPresentation getNameIdentifier] } -arg_assignment_list ::= LPARENTH arg_assignment? ( COMMA+ arg_assignment )* RPARENTH {pin(".*")=1} +arg_assignment_list ::= LPARENTH arg_assignment? ( COMMA arg_assignment )* RPARENTH {pin(".*")=1} arg_assignment ::= [ parameter_reference EQUALS ] expr { recoverWhile=recover_arg } @@ -325,7 +369,7 @@ arg_declaration ::= IDENTIFIER [EQUALS expr] { } full_arg_declaration_list ::= LPARENTH full_arg_declaration? ( COMMA+ full_arg_declaration )* RPARENTH {pin(".*")=1} -full_arg_declaration ::= IDENTIFIER EQUALS expr { +full_arg_declaration ::= IDENTIFIER EQUALS expr+ { mixin="com.javampire.openscad.psi.OpenSCADNamedElementImpl" implements="com.javampire.openscad.psi.OpenSCADNamedElement" methods=[getNameIdentifier] diff --git a/src/main/java/com/javampire/openscad/highlighting/OpenSCADSyntaxHighlighter.java b/src/main/java/com/javampire/openscad/highlighting/OpenSCADSyntaxHighlighter.java index a2713a7..fbcc440 100644 --- a/src/main/java/com/javampire/openscad/highlighting/OpenSCADSyntaxHighlighter.java +++ b/src/main/java/com/javampire/openscad/highlighting/OpenSCADSyntaxHighlighter.java @@ -33,6 +33,8 @@ public class OpenSCADSyntaxHighlighter extends SyntaxHighlighterBase { public static final TextAttributesKey OPERATOR_KEYWORD = createTextAttributesKey("OPENSCAD_OPERATOR_KEYWORD", KEYWORD); public static final TextAttributesKey OBJECT_KEYWORD = createTextAttributesKey("OPENSCAD_OBJECT_KEYWORD", KEYWORD); public static final TextAttributesKey FUNCTION_KEYWORD = createTextAttributesKey("OPENSCAD_FUNCTION_KEYWORD", KEYWORD); + public static final TextAttributesKey OVERRIDABLE_OBJECT_KEYWORD = createTextAttributesKey("OPENSCAD_OVERRIDABLE_OBJECT_KEYWORD", KEYWORD); + public static final TextAttributesKey OVERRIDABLE_OPERATOR_KEYWORD = createTextAttributesKey("OPENSCAD_OVERRIDABLE_OPERATOR_KEYWORD", KEYWORD); private static final TextAttributesKey[] BAD_CHAR_KEYS = new TextAttributesKey[]{BAD_CHARACTER}; private static final TextAttributesKey[] SEPARATOR_KEYS = new TextAttributesKey[]{SEPARATOR}; @@ -53,6 +55,8 @@ public class OpenSCADSyntaxHighlighter extends SyntaxHighlighterBase { private static final TextAttributesKey[] OBJECT_KEYWORD_KEYS = new TextAttributesKey[]{OBJECT_KEYWORD}; private static final TextAttributesKey[] FUNCTION_KEYWORD_KEYS = new TextAttributesKey[]{FUNCTION_KEYWORD}; private static final TextAttributesKey[] EMPTY_KEYS = new TextAttributesKey[0]; + private static final TextAttributesKey[] OVERRIDABLE_OBJECT_KEYWORDS_KEYS = new TextAttributesKey[]{OVERRIDABLE_OBJECT_KEYWORD}; + private static final TextAttributesKey[] OVERRIDABLE_OPERATOR_KEYWORDS_KEYS = new TextAttributesKey[]{OVERRIDABLE_OPERATOR_KEYWORD}; @NotNull @Override @@ -87,6 +91,10 @@ public TextAttributesKey[] getTokenHighlights(IElementType tokenType) { return OPERATOR_KEYWORD_KEYS; } else if (OBJECT_KEYWORDS.contains(tokenType)) { return OBJECT_KEYWORD_KEYS; + } else if (OVERRIDABLE_OBJECT_KEYWORDS.contains(tokenType)) { + return OVERRIDABLE_OBJECT_KEYWORDS_KEYS; + } else if (OVERRIDABLE_OPERATOR_KEYWORDS.contains(tokenType)) { + return OVERRIDABLE_OPERATOR_KEYWORDS_KEYS; } else if (FUNCTION_KEYWORDS.contains(tokenType)) { return FUNCTION_KEYWORD_KEYS; } else if (LANGUAGE_KEYWORDS.contains(tokenType)) { diff --git a/src/main/java/com/javampire/openscad/parser/OpenSCADParserTokenSets.java b/src/main/java/com/javampire/openscad/parser/OpenSCADParserTokenSets.java index e531e81..e376274 100644 --- a/src/main/java/com/javampire/openscad/parser/OpenSCADParserTokenSets.java +++ b/src/main/java/com/javampire/openscad/parser/OpenSCADParserTokenSets.java @@ -28,9 +28,9 @@ public class OpenSCADParserTokenSets { ); public static final TokenSet OPERATOR_KEYWORDS = TokenSet.create( - LINEAR_EXTRUDE_KEYWORD, ROTATE_EXTRUDE_KEYWORD, ROTATE_KEYWORD, TRANSLATE_KEYWORD, SCALE_KEYWORD, - RESIZE_KEYWORD, MIRROR_KEYWORD, MULTMATRIX_KEYWORD, COLOR_KEYWORD, OFFSET_KEYWORD, MINKOWSKI_KEYWORD, - HULL_KEYWORD, UNION_KEYWORD, DIFFERENCE_KEYWORD, INTERSECTION_KEYWORD, RENDER_KEYWORD, PROJECTION_KEYWORD + LINEAR_EXTRUDE_KEYWORD, ROTATE_EXTRUDE_KEYWORD, ROTATE_KEYWORD, + RESIZE_KEYWORD, MULTMATRIX_KEYWORD, COLOR_KEYWORD, MINKOWSKI_KEYWORD, + UNION_KEYWORD, DIFFERENCE_KEYWORD, RENDER_KEYWORD, PROJECTION_KEYWORD ); public static final TokenSet LANGUAGE_KEYWORDS = TokenSet.create( @@ -41,11 +41,20 @@ public class OpenSCADParserTokenSets { ); public static final TokenSet OBJECT_KEYWORDS = TokenSet.create( - CUBE_KEYWORD, CYLINDER_KEYWORD, ASSERT_KEYWORD, ECHO_KEYWORD, SPHERE_KEYWORD, POLYHEDRON_KEYWORD, - SQUARE_KEYWORD, CIRCLE_KEYWORD, POLYGON_KEYWORD, TEXT_KEYWORD, SURFACE_KEYWORD, CHILD_KEYWORD, + ASSERT_KEYWORD, ECHO_KEYWORD, POLYHEDRON_KEYWORD, + POLYGON_KEYWORD, TEXT_KEYWORD, SURFACE_KEYWORD, CHILD_KEYWORD, CHILDREN_KEYWORD, IMPORT_KEYWORD, IMPORT_DXF_KEYWORD, IMPORT_STL_KEYWORD ); + public static final TokenSet OVERRIDABLE_OBJECT_KEYWORDS = TokenSet.create( + CUBE_KEYWORD, CYLINDER_KEYWORD, SPHERE_KEYWORD, SQUARE_KEYWORD, CIRCLE_KEYWORD + ); + + public static final TokenSet OVERRIDABLE_OPERATOR_KEYWORDS = TokenSet.create( + DIFFERENCE_KEYWORD, HULL_KEYWORD, INTERSECTION_KEYWORD, MIRROR_KEYWORD, OFFSET_KEYWORD, + SCALE_KEYWORD, TRANSLATE_KEYWORD, UNION_KEYWORD + ); + public static final TokenSet FUNCTION_KEYWORDS = TokenSet.create( IS_UNDEF_KEYWORD, IS_LIST_KEYWORD, IS_NUM_KEYWORD, IS_BOOL_KEYWORD, IS_STRING_KEYWORD, IS_FUNCTION_KEYWORD, COS_KEYWORD, SIN_KEYWORD, TAN_KEYWORD, ACOS_KEYWORD, ASIN_KEYWORD, ATAN_KEYWORD, ATAN2_KEYWORD, ABS_KEYWORD, @@ -139,9 +148,9 @@ public class OpenSCADParserTokenSets { * builtin_obj_ref keywords */ public static final TokenSet BUILTIN_OBJ_REF_KEYWORDS = TokenSet.create( - ASSERT_KEYWORD, CHILD_KEYWORD, CHILDREN_KEYWORD, CIRCLE_KEYWORD, CUBE_KEYWORD, CYLINDER_KEYWORD, + ASSERT_KEYWORD, CHILD_KEYWORD, CHILDREN_KEYWORD, ECHO_KEYWORD, IMPORT_KEYWORD, IMPORT_DXF_KEYWORD, IMPORT_STL_KEYWORD, POLYGON_KEYWORD, POLYHEDRON_KEYWORD, - SPHERE_KEYWORD, SQUARE_KEYWORD, SURFACE_KEYWORD, TEXT_KEYWORD + SURFACE_KEYWORD, TEXT_KEYWORD ); /** @@ -155,10 +164,24 @@ public class OpenSCADParserTokenSets { * common_op_ref keywords */ public static final TokenSet COMMON_OP_REF_KEYWORDS = TokenSet.create( - COLOR_KEYWORD, DIFFERENCE_KEYWORD, HULL_KEYWORD, INTERSECTION_KEYWORD, LINEAR_EXTRUDE_KEYWORD, - MINKOWSKI_KEYWORD, MIRROR_KEYWORD, MULTMATRIX_KEYWORD, OFFSET_KEYWORD, PROJECTION_KEYWORD, RENDER_KEYWORD, - RESIZE_KEYWORD, ROTATE_KEYWORD, ROTATE_EXTRUDE_KEYWORD, SCALE_KEYWORD, TRANSLATE_KEYWORD, UNION_KEYWORD + COLOR_KEYWORD, DIFFERENCE_KEYWORD, LINEAR_EXTRUDE_KEYWORD, + MINKOWSKI_KEYWORD, MULTMATRIX_KEYWORD, PROJECTION_KEYWORD, RENDER_KEYWORD, + RESIZE_KEYWORD, ROTATE_KEYWORD, ROTATE_EXTRUDE_KEYWORD, UNION_KEYWORD + ); + + /** + * Overridable object and operators, also a combined set where the operators and objects are used as functions + */ + public static final TokenSet BUILTIN_OVERRIDABLE_OBJ_REF_KEYWORDS = TokenSet.create( + CIRCLE_KEYWORD, CUBE_KEYWORD, CYLINDER_KEYWORD, SPHERE_KEYWORD, SQUARE_KEYWORD + ); + public static final TokenSet BUILTIN_OVERRIDABLE_OP_REF_KEYWORDS = TokenSet.create( + DIFFERENCE_KEYWORD, HULL_KEYWORD, INTERSECTION_KEYWORD, MIRROR_KEYWORD, OFFSET_KEYWORD, + SCALE_KEYWORD, TRANSLATE_KEYWORD, UNION_KEYWORD + ); + public static final TokenSet BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF_KEYWORDS = + TokenSet.orSet(BUILTIN_OVERRIDABLE_OBJ_REF_KEYWORDS, BUILTIN_OVERRIDABLE_OP_REF_KEYWORDS); /** * These elements can't be renamed diff --git a/src/main/java/com/javampire/openscad/psi/OpenSCADNamedElementImpl.java b/src/main/java/com/javampire/openscad/psi/OpenSCADNamedElementImpl.java index 6c93ccc..895b573 100644 --- a/src/main/java/com/javampire/openscad/psi/OpenSCADNamedElementImpl.java +++ b/src/main/java/com/javampire/openscad/psi/OpenSCADNamedElementImpl.java @@ -56,6 +56,12 @@ public static ASTNode getNameNode(@NotNull final ASTNode node) { return node.findChildByType(BUILTIN_EXPR_REF_KEYWORDS); } else if (node.getElementType() == OpenSCADTypes.BUILTIN_OBJ_REF) { return node.findChildByType(BUILTIN_OBJ_REF_KEYWORDS); + } else if (node.getElementType() == OpenSCADTypes.BUILTIN_OVERRIDABLE_OBJ_REF) { + return node.findChildByType(BUILTIN_OVERRIDABLE_OBJ_REF_KEYWORDS); + } else if (node.getElementType() == OpenSCADTypes.BUILTIN_OVERRIDABLE_OP_REF) { + return node.findChildByType(BUILTIN_OVERRIDABLE_OP_REF_KEYWORDS); + } else if (node.getElementType() == OpenSCADTypes.BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF) { + return node.findChildByType(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF_KEYWORDS); } else if (node.getElementType() == OpenSCADTypes.TEST_EXP_REF) { return node.findChildByType(TEST_EXP_REF_KEYWORDS); } else if (node.getElementType() == OpenSCADTypes.COMMON_OP_REF) { diff --git a/src/test/java/com/javampire/openscad/parser/BOSL2ParsingTest.java b/src/test/java/com/javampire/openscad/parser/BOSL2ParsingTest.java new file mode 100644 index 0000000..06ae821 --- /dev/null +++ b/src/test/java/com/javampire/openscad/parser/BOSL2ParsingTest.java @@ -0,0 +1,31 @@ +package com.javampire.openscad.parser; + +import com.intellij.testFramework.ParsingTestCase; + +import java.io.IOException; + +public class BOSL2ParsingTest extends ParsingTestCase { + public BOSL2ParsingTest() { + super("", "scad", new OpenSCADParserDefinition()); + } + + @Override + protected String getTestDataPath() { + return "src/test/testData/openscad/parser/bosl2"; + } + + @Override + protected boolean skipSpaces() { + return false; + } + + @Override + protected boolean includeRanges() { + return true; + } + + public void testFunctionsAndModules() throws IOException { + doTest("_psidump"); + } + +} diff --git a/src/test/java/com/javampire/openscad/parser/BaseParsingTest.java b/src/test/java/com/javampire/openscad/parser/BaseParsingTest.java index 76e265f..e1f0c10 100644 --- a/src/test/java/com/javampire/openscad/parser/BaseParsingTest.java +++ b/src/test/java/com/javampire/openscad/parser/BaseParsingTest.java @@ -25,6 +25,10 @@ protected boolean includeRanges() { return true; } + public void testassert() throws IOException { + doTest("_psidump"); + } + @Test public void testassign() throws IOException { doTest("_psidump"); diff --git a/src/test/testData/openscad/parser/ColorProvider_psidump.txt b/src/test/testData/openscad/parser/ColorProvider_psidump.txt index 2505319..d3787e4 100644 --- a/src/test/testData/openscad/parser/ColorProvider_psidump.txt +++ b/src/test/testData/openscad/parser/ColorProvider_psidump.txt @@ -40,7 +40,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(90,91) PsiWhiteSpace(' ')(91,92) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(92,117) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(92,96) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(92,96) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(92,96) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(96,116) PsiElement(OpenSCADTokenType.LPARENTH)('(')(96,97) @@ -78,7 +78,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(139,140) PsiWhiteSpace(' ')(140,141) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(141,166) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(141,145) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(141,145) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(141,145) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(145,165) PsiElement(OpenSCADTokenType.LPARENTH)('(')(145,146) @@ -126,7 +126,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(203,204) PsiWhiteSpace(' ')(204,205) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(205,230) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(205,209) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(205,209) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(205,209) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(209,229) PsiElement(OpenSCADTokenType.LPARENTH)('(')(209,210) @@ -188,7 +188,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(273,274) PsiWhiteSpace(' ')(274,275) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(275,300) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(275,279) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(275,279) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(275,279) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(279,299) PsiElement(OpenSCADTokenType.LPARENTH)('(')(279,280) @@ -255,7 +255,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(346,347) PsiWhiteSpace(' ')(347,348) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(348,373) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(348,352) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(348,352) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(348,352) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(352,372) PsiElement(OpenSCADTokenType.LPARENTH)('(')(352,353) @@ -332,7 +332,7 @@ OpenSCAD File(0,564) PsiElement(OpenSCADTokenType.RPARENTH)(')')(432,433) PsiWhiteSpace(' ')(433,434) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(434,459) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(434,438) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(434,438) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(434,438) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(438,458) PsiElement(OpenSCADTokenType.LPARENTH)('(')(438,439) diff --git a/src/test/testData/openscad/parser/CyclicUsedFile_psidump.txt b/src/test/testData/openscad/parser/CyclicUsedFile_psidump.txt index 179f87c..0e13d7a 100644 --- a/src/test/testData/openscad/parser/CyclicUsedFile_psidump.txt +++ b/src/test/testData/openscad/parser/CyclicUsedFile_psidump.txt @@ -161,7 +161,7 @@ OpenSCAD File(0,221) PsiElement(OpenSCADTokenType.RPARENTH)(')')(201,202) PsiWhiteSpace(' ')(202,203) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(203,221) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(203,207) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(203,207) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(203,207) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(207,220) PsiElement(OpenSCADTokenType.LPARENTH)('(')(207,208) diff --git a/src/test/testData/openscad/parser/Main_psidump.txt b/src/test/testData/openscad/parser/Main_psidump.txt index 5184345..f097b60 100644 --- a/src/test/testData/openscad/parser/Main_psidump.txt +++ b/src/test/testData/openscad/parser/Main_psidump.txt @@ -231,7 +231,7 @@ OpenSCAD File(0,981) PsiElement(OpenSCADTokenType.RPARENTH)(')')(700,701) PsiWhiteSpace('\n ')(701,714) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(714,732) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(714,718) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(714,718) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(714,718) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(718,731) PsiElement(OpenSCADTokenType.LPARENTH)('(')(718,719) @@ -254,7 +254,7 @@ OpenSCAD File(0,981) PsiWhiteSpace('\n\n ')(732,742) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(742,775) OpenSCADBuiltinOpImpl(BUILTIN_OP)(742,762) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(742,751) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(742,751) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(742,751) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(751,762) PsiElement(OpenSCADTokenType.LPARENTH)('(')(751,752) @@ -319,24 +319,28 @@ OpenSCAD File(0,981) OpenSCADAssertExprImpl(ASSERT_EXPR)(908,980) OpenSCADAssertElementImpl(ASSERT_ELEMENT)(908,926) PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(908,914) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(914,915) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(915,919) - PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(915,919) - PsiElement(OpenSCADTokenType.COMMA)(',')(919,920) - PsiWhiteSpace(' ')(920,921) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"xx"')(921,925) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(925,926) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(914,926) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(914,915) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(915,919) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(915,919) + PsiElement(OpenSCADTokenType.COMMA)(',')(919,920) + PsiWhiteSpace(' ')(920,921) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(921,925) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"xx"')(921,925) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(925,926) PsiWhiteSpace(' ')(926,927) OpenSCADAssertExprImpl(ASSERT_EXPR)(927,980) OpenSCADAssertElementImpl(ASSERT_ELEMENT)(927,945) PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(927,933) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(933,934) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(934,938) - PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(934,938) - PsiElement(OpenSCADTokenType.COMMA)(',')(938,939) - PsiWhiteSpace(' ')(939,940) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"yy"')(940,944) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(944,945) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(933,945) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(933,934) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(934,938) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(934,938) + PsiElement(OpenSCADTokenType.COMMA)(',')(938,939) + PsiWhiteSpace(' ')(939,940) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(940,944) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"yy"')(940,944) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(944,945) PsiWhiteSpace(' ')(945,946) OpenSCADEchoExprImpl(ECHO_EXPR)(946,980) OpenSCADEchoElementImpl(ECHO_ELEMENT)(946,959) diff --git a/src/test/testData/openscad/parser/SubColorProvider_psidump.txt b/src/test/testData/openscad/parser/SubColorProvider_psidump.txt index 4c7af82..61d7ab0 100644 --- a/src/test/testData/openscad/parser/SubColorProvider_psidump.txt +++ b/src/test/testData/openscad/parser/SubColorProvider_psidump.txt @@ -279,7 +279,7 @@ OpenSCAD File(0,450) PsiElement(OpenSCADTokenType.RPARENTH)(')')(425,426) PsiWhiteSpace(' ')(426,427) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(427,450) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(427,435) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(427,435) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(427,435) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(435,449) PsiElement(OpenSCADTokenType.LPARENTH)('(')(435,436) diff --git a/src/test/testData/openscad/parser/base/assert.scad b/src/test/testData/openscad/parser/base/assert.scad new file mode 100644 index 0000000..c2ea8c7 --- /dev/null +++ b/src/test/testData/openscad/parser/base/assert.scad @@ -0,0 +1,41 @@ +function f2(x) = + false ? false : assert(x,str("Failed2")) "Not okay"; +echo(f2(true)); + +function fa2(x) = +assert(assert(true, x) true, str("in test")) false ? assert(x,str("in first part")) false : assert(x,str("in second part")) "Okay"; +echo(fa2(true)); + +function unit(v, error=[[["ASSERT"]]]) = +assert(is_vector(v), "Invalid vector") + norm(v)=EPSILON,"Cannot normalize a zero vector") : error) : + v/norm(v); + +echo(str("First echo")); +assert(true,str("Success")); + +function fe(x) = +echo(x,str("in test")) false ? echo(x,str("in first part")) false : echo(x,str("in second part")) "Okay"; +echo(f(true)); + + +function f(x) = + false ? false : assert(x,str("Failed")) "Okay"; +echo(f(true)); + + + +function f3(x) = + false ? false : assert(x,str("Failed3")) assert(!x,str("Failed4")) "None of the above"; +echo(f3(true)); +echo(f3(false)); + + +result = false ? 1 + : false ? 2 + : false ? 3 + : assert(false, "With one expression", "and another"); + +assert(all_nonnegative([endcap_extent1])) +assert(all_nonnegative([endcap_extent2])) +assert(all_nonnegative([joint_extent])); diff --git a/src/test/testData/openscad/parser/base/assert_psidump.txt b/src/test/testData/openscad/parser/base/assert_psidump.txt new file mode 100644 index 0000000..120741e --- /dev/null +++ b/src/test/testData/openscad/parser/base/assert_psidump.txt @@ -0,0 +1,732 @@ +OpenSCAD File(0,1164) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(0,73) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(0,8) + PsiWhiteSpace(' ')(8,9) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f2')(9,11) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(11,14) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(11,12) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(12,13) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(12,13) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(13,14) + PsiWhiteSpace(' ')(14,15) + PsiElement(OpenSCADTokenType.EQUALS)('=')(15,16) + PsiWhiteSpace('\n ')(16,21) + OpenSCADElvisExprImpl(ELVIS_EXPR)(21,72) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(21,26) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(21,26) + PsiWhiteSpace(' ')(26,27) + PsiElement(OpenSCADTokenType.QUERY)('?')(27,28) + PsiWhiteSpace(' ')(28,29) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(29,34) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(29,34) + PsiWhiteSpace(' ')(34,35) + PsiElement(OpenSCADTokenType.COLON)(':')(35,36) + PsiWhiteSpace(' ')(36,37) + OpenSCADAssertExprImpl(ASSERT_EXPR)(37,72) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(37,61) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(37,43) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(43,61) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(43,44) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(44,45) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(44,45) + PsiElement(OpenSCADTokenType.COMMA)(',')(45,46) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(46,60) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(46,49) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(46,49) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(49,60) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(49,50) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(50,59) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(50,59) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Failed2"')(50,59) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(59,60) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(60,61) + PsiWhiteSpace(' ')(61,62) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(62,72) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Not okay"')(62,72) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(72,73) + PsiWhiteSpace('\n')(73,74) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(74,89) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(74,78) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(74,78) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(78,88) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(78,79) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(79,87) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(79,87) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(79,81) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f2')(79,81) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(81,87) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(81,82) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(82,86) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(82,86) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(82,86) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(86,87) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(87,88) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(88,89) + PsiWhiteSpace('\n\n')(89,91) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(91,240) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(91,99) + PsiWhiteSpace(' ')(99,100) + PsiElement(OpenSCADTokenType.IDENTIFIER)('fa2')(100,103) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(103,106) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(103,104) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(104,105) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(104,105) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(105,106) + PsiWhiteSpace(' ')(106,107) + PsiElement(OpenSCADTokenType.EQUALS)('=')(107,108) + PsiWhiteSpace('\n')(108,109) + OpenSCADAssertExprImpl(ASSERT_EXPR)(109,239) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(109,153) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(109,115) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(115,153) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(115,116) + OpenSCADAssertExprImpl(ASSERT_EXPR)(116,136) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(116,131) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(116,122) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(122,131) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(122,123) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(123,127) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(123,127) + PsiElement(OpenSCADTokenType.COMMA)(',')(127,128) + PsiWhiteSpace(' ')(128,129) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(129,130) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(129,130) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(130,131) + PsiWhiteSpace(' ')(131,132) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(132,136) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(132,136) + PsiElement(OpenSCADTokenType.COMMA)(',')(136,137) + PsiWhiteSpace(' ')(137,138) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(138,152) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(138,141) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(138,141) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(141,152) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(141,142) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(142,151) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(142,151) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in test"')(142,151) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(151,152) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(152,153) + PsiWhiteSpace(' ')(153,154) + OpenSCADElvisExprImpl(ELVIS_EXPR)(154,239) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(154,159) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(154,159) + PsiWhiteSpace(' ')(159,160) + PsiElement(OpenSCADTokenType.QUERY)('?')(160,161) + PsiWhiteSpace(' ')(161,162) + OpenSCADAssertExprImpl(ASSERT_EXPR)(162,198) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(162,192) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(162,168) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(168,192) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(168,169) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(169,170) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(169,170) + PsiElement(OpenSCADTokenType.COMMA)(',')(170,171) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(171,191) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(171,174) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(171,174) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(174,191) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(174,175) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(175,190) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(175,190) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in first part"')(175,190) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(190,191) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(191,192) + PsiWhiteSpace(' ')(192,193) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(193,198) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(193,198) + PsiWhiteSpace(' ')(198,199) + PsiElement(OpenSCADTokenType.COLON)(':')(199,200) + PsiWhiteSpace(' ')(200,201) + OpenSCADAssertExprImpl(ASSERT_EXPR)(201,239) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(201,232) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(201,207) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(207,232) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(207,208) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(208,209) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(208,209) + PsiElement(OpenSCADTokenType.COMMA)(',')(209,210) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(210,231) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(210,213) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(210,213) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(213,231) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(213,214) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(214,230) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(214,230) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in second part"')(214,230) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(230,231) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(231,232) + PsiWhiteSpace(' ')(232,233) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(233,239) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Okay"')(233,239) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(239,240) + PsiWhiteSpace('\n')(240,241) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(241,257) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(241,245) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(241,245) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(245,256) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(245,246) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(246,255) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(246,255) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(246,249) + PsiElement(OpenSCADTokenType.IDENTIFIER)('fa2')(246,249) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(249,255) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(249,250) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(250,254) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(250,254) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(250,254) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(254,255) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(255,256) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(256,257) + PsiWhiteSpace('\n\n')(257,259) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(259,475) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(259,267) + PsiWhiteSpace(' ')(267,268) + PsiElement(OpenSCADTokenType.IDENTIFIER)('unit')(268,272) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(272,297) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(272,273) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(273,274) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(273,274) + PsiElement(OpenSCADTokenType.COMMA)(',')(274,275) + PsiWhiteSpace(' ')(275,276) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(276,296) + PsiElement(OpenSCADTokenType.IDENTIFIER)('error')(276,281) + PsiElement(OpenSCADTokenType.EQUALS)('=')(281,282) + OpenSCADVectorExprImpl(VECTOR_EXPR)(282,296) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(282,283) + OpenSCADVectorExprImpl(VECTOR_EXPR)(283,295) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(283,284) + OpenSCADVectorExprImpl(VECTOR_EXPR)(284,294) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(284,285) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(285,293) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"ASSERT"')(285,293) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(293,294) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(294,295) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(295,296) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(296,297) + PsiWhiteSpace(' ')(297,298) + PsiElement(OpenSCADTokenType.EQUALS)('=')(298,299) + PsiWhiteSpace('\n')(299,300) + OpenSCADAssertExprImpl(ASSERT_EXPR)(300,474) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(300,338) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(300,306) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(306,338) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(306,307) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(307,319) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(307,316) + PsiElement(OpenSCADTokenType.IDENTIFIER)('is_vector')(307,316) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(316,319) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(316,317) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(317,318) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(317,318) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(317,318) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(318,319) + PsiElement(OpenSCADTokenType.COMMA)(',')(319,320) + PsiWhiteSpace(' ')(320,321) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(321,337) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Invalid vector"')(321,337) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(337,338) + PsiWhiteSpace('\n ')(338,343) + OpenSCADElvisExprImpl(ELVIS_EXPR)(343,474) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(343,358) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(343,350) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(343,347) + PsiElement(OpenSCADTokenType.NORM_KEYWORD)('norm')(343,347) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(347,350) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(347,348) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(348,349) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(348,349) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(348,349) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(349,350) + PsiElement(OpenSCADTokenType.LT)('<')(350,351) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(351,358) + PsiElement(OpenSCADTokenType.IDENTIFIER)('EPSILON')(351,358) + PsiElement(OpenSCADTokenType.QUERY)('?')(358,359) + PsiWhiteSpace(' ')(359,360) + OpenSCADParenExprImpl(PAREN_EXPR)(360,450) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(360,361) + OpenSCADElvisExprImpl(ELVIS_EXPR)(361,449) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(361,382) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(361,366) + PsiElement(OpenSCADTokenType.IDENTIFIER)('error')(361,366) + PsiElement(OpenSCADTokenType.EQ)('==')(366,368) + OpenSCADVectorExprImpl(VECTOR_EXPR)(368,382) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(368,369) + OpenSCADVectorExprImpl(VECTOR_EXPR)(369,381) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(369,370) + OpenSCADVectorExprImpl(VECTOR_EXPR)(370,380) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(370,371) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(371,379) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"ASSERT"')(371,379) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(379,380) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(380,381) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(381,382) + PsiElement(OpenSCADTokenType.QUERY)('?')(382,383) + PsiWhiteSpace(' ')(383,384) + OpenSCADAssertExprImpl(ASSERT_EXPR)(384,441) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(384,441) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(384,390) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(390,441) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(390,391) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(391,407) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(391,398) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(391,395) + PsiElement(OpenSCADTokenType.NORM_KEYWORD)('norm')(391,395) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(395,398) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(395,396) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(396,397) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(396,397) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(396,397) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(397,398) + PsiElement(OpenSCADTokenType.GE)('>=')(398,400) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(400,407) + PsiElement(OpenSCADTokenType.IDENTIFIER)('EPSILON')(400,407) + PsiElement(OpenSCADTokenType.COMMA)(',')(407,408) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(408,440) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Cannot normalize a zero vector"')(408,440) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(440,441) + PsiWhiteSpace(' ')(441,442) + PsiElement(OpenSCADTokenType.COLON)(':')(442,443) + PsiWhiteSpace(' ')(443,444) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(444,449) + PsiElement(OpenSCADTokenType.IDENTIFIER)('error')(444,449) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(449,450) + PsiWhiteSpace(' ')(450,451) + PsiElement(OpenSCADTokenType.COLON)(':')(451,452) + PsiWhiteSpace('\n ')(452,465) + OpenSCADDivExprImpl(DIV_EXPR)(465,474) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(465,466) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(465,466) + PsiElement(OpenSCADTokenType.DIV)('/')(466,467) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(467,474) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(467,471) + PsiElement(OpenSCADTokenType.NORM_KEYWORD)('norm')(467,471) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(471,474) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(471,472) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(472,473) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(472,473) + PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(472,473) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(473,474) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(474,475) + PsiWhiteSpace('\n\n')(475,477) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(477,501) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(477,481) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(477,481) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(481,500) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(481,482) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(482,499) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(482,499) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(482,485) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(482,485) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(485,499) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(485,486) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(486,498) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(486,498) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"First echo"')(486,498) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(498,499) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(499,500) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(500,501) + PsiWhiteSpace('\n')(501,502) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(502,530) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(502,508) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(502,508) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(508,529) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(508,509) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(509,513) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(509,513) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(509,513) + PsiElement(OpenSCADTokenType.COMMA)(',')(513,514) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(514,528) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(514,528) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(514,517) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(514,517) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(517,528) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(517,518) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(518,527) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(518,527) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Success"')(518,527) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(527,528) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(528,529) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(529,530) + PsiWhiteSpace('\n\n')(530,532) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(532,654) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(532,540) + PsiWhiteSpace(' ')(540,541) + PsiElement(OpenSCADTokenType.IDENTIFIER)('fe')(541,543) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(543,546) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(543,544) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(544,545) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(544,545) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(545,546) + PsiWhiteSpace(' ')(546,547) + PsiElement(OpenSCADTokenType.EQUALS)('=')(547,548) + PsiWhiteSpace('\n')(548,549) + OpenSCADEchoExprImpl(ECHO_EXPR)(549,653) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(549,571) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(549,553) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(553,571) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(553,554) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(554,555) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(554,555) + PsiElement(OpenSCADTokenType.COMMA)(',')(555,556) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(556,570) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(556,559) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(556,559) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(559,570) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(559,560) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(560,569) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(560,569) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in test"')(560,569) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(569,570) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(570,571) + PsiWhiteSpace(' ')(571,572) + OpenSCADElvisExprImpl(ELVIS_EXPR)(572,653) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(572,577) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(572,577) + PsiWhiteSpace(' ')(577,578) + PsiElement(OpenSCADTokenType.QUERY)('?')(578,579) + PsiWhiteSpace(' ')(579,580) + OpenSCADEchoExprImpl(ECHO_EXPR)(580,614) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(580,608) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(580,584) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(584,608) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(584,585) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(585,586) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(585,586) + PsiElement(OpenSCADTokenType.COMMA)(',')(586,587) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(587,607) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(587,590) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(587,590) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(590,607) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(590,591) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(591,606) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(591,606) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in first part"')(591,606) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(606,607) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(607,608) + PsiWhiteSpace(' ')(608,609) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(609,614) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(609,614) + PsiWhiteSpace(' ')(614,615) + PsiElement(OpenSCADTokenType.COLON)(':')(615,616) + PsiWhiteSpace(' ')(616,617) + OpenSCADEchoExprImpl(ECHO_EXPR)(617,653) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(617,646) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(617,621) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(621,646) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(621,622) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(622,623) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(622,623) + PsiElement(OpenSCADTokenType.COMMA)(',')(623,624) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(624,645) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(624,627) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(624,627) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(627,645) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(627,628) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(628,644) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(628,644) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"in second part"')(628,644) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(644,645) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(645,646) + PsiWhiteSpace(' ')(646,647) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(647,653) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Okay"')(647,653) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(653,654) + PsiWhiteSpace('\n')(654,655) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(655,669) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(655,659) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(655,659) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(659,668) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(659,660) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(660,667) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(660,667) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(660,661) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f')(660,661) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(661,667) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(661,662) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(662,666) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(662,666) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(662,666) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(666,667) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(667,668) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(668,669) + PsiWhiteSpace('\n\n\n')(669,672) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(672,739) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(672,680) + PsiWhiteSpace(' ')(680,681) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f')(681,682) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(682,685) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(682,683) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(683,684) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(683,684) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(684,685) + PsiWhiteSpace(' ')(685,686) + PsiElement(OpenSCADTokenType.EQUALS)('=')(686,687) + PsiWhiteSpace('\n ')(687,692) + OpenSCADElvisExprImpl(ELVIS_EXPR)(692,738) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(692,697) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(692,697) + PsiWhiteSpace(' ')(697,698) + PsiElement(OpenSCADTokenType.QUERY)('?')(698,699) + PsiWhiteSpace(' ')(699,700) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(700,705) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(700,705) + PsiWhiteSpace(' ')(705,706) + PsiElement(OpenSCADTokenType.COLON)(':')(706,707) + PsiWhiteSpace(' ')(707,708) + OpenSCADAssertExprImpl(ASSERT_EXPR)(708,738) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(708,731) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(708,714) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(714,731) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(714,715) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(715,716) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(715,716) + PsiElement(OpenSCADTokenType.COMMA)(',')(716,717) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(717,730) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(717,720) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(717,720) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(720,730) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(720,721) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(721,729) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(721,729) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Failed"')(721,729) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(729,730) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(730,731) + PsiWhiteSpace(' ')(731,732) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(732,738) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Okay"')(732,738) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(738,739) + PsiWhiteSpace('\n')(739,740) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(740,754) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(740,744) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(740,744) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(744,753) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(744,745) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(745,752) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(745,752) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(745,746) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f')(745,746) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(746,752) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(746,747) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(747,751) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(747,751) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(747,751) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(751,752) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(752,753) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(753,754) + PsiWhiteSpace('\n\n\n\n')(754,758) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(758,866) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(758,766) + PsiWhiteSpace(' ')(766,767) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f3')(767,769) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(769,772) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(769,770) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(770,771) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(770,771) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(771,772) + PsiWhiteSpace(' ')(772,773) + PsiElement(OpenSCADTokenType.EQUALS)('=')(773,774) + PsiWhiteSpace('\n ')(774,779) + OpenSCADElvisExprImpl(ELVIS_EXPR)(779,865) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(779,784) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(779,784) + PsiWhiteSpace(' ')(784,785) + PsiElement(OpenSCADTokenType.QUERY)('?')(785,786) + PsiWhiteSpace(' ')(786,787) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(787,792) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(787,792) + PsiWhiteSpace(' ')(792,793) + PsiElement(OpenSCADTokenType.COLON)(':')(793,794) + PsiWhiteSpace(' ')(794,795) + OpenSCADAssertExprImpl(ASSERT_EXPR)(795,865) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(795,819) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(795,801) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(801,819) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(801,802) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(802,803) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(802,803) + PsiElement(OpenSCADTokenType.COMMA)(',')(803,804) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(804,818) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(804,807) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(804,807) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(807,818) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(807,808) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(808,817) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(808,817) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Failed3"')(808,817) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(817,818) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(818,819) + PsiWhiteSpace(' ')(819,820) + OpenSCADAssertExprImpl(ASSERT_EXPR)(820,865) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(820,845) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(820,826) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(826,845) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(826,827) + OpenSCADUnaryNegateExprImpl(UNARY_NEGATE_EXPR)(827,829) + PsiElement(OpenSCADTokenType.EXCL)('!')(827,828) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(828,829) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(828,829) + PsiElement(OpenSCADTokenType.COMMA)(',')(829,830) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(830,844) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(830,833) + PsiElement(OpenSCADTokenType.STR_KEYWORD)('str')(830,833) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(833,844) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(833,834) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(834,843) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(834,843) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Failed4"')(834,843) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(843,844) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(844,845) + PsiWhiteSpace(' ')(845,846) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(846,865) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"None of the above"')(846,865) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(865,866) + PsiWhiteSpace('\n')(866,867) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(867,882) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(867,871) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(867,871) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(871,881) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(871,872) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(872,880) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(872,880) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(872,874) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f3')(872,874) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(874,880) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(874,875) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(875,879) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(875,879) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(875,879) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(879,880) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(880,881) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(881,882) + PsiWhiteSpace('\n')(882,883) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(883,899) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(883,887) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(883,887) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(887,898) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(887,888) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(888,897) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(888,897) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(888,890) + PsiElement(OpenSCADTokenType.IDENTIFIER)('f3')(888,890) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(890,897) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(890,891) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(891,896) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(891,896) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(891,896) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(896,897) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(897,898) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(898,899) + PsiWhiteSpace('\n\n\n')(899,902) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(902,1038) + PsiElement(OpenSCADTokenType.IDENTIFIER)('result')(902,908) + PsiWhiteSpace(' ')(908,909) + PsiElement(OpenSCADTokenType.EQUALS)('=')(909,910) + PsiWhiteSpace(' ')(910,911) + OpenSCADElvisExprImpl(ELVIS_EXPR)(911,1037) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(911,916) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(911,916) + PsiWhiteSpace(' ')(916,917) + PsiElement(OpenSCADTokenType.QUERY)('?')(917,918) + PsiWhiteSpace(' ')(918,919) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(919,920) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(919,920) + PsiWhiteSpace('\n ')(920,925) + PsiElement(OpenSCADTokenType.COLON)(':')(925,926) + PsiWhiteSpace(' ')(926,928) + OpenSCADElvisExprImpl(ELVIS_EXPR)(928,1037) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(928,933) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(928,933) + PsiWhiteSpace(' ')(933,934) + PsiElement(OpenSCADTokenType.QUERY)('?')(934,935) + PsiWhiteSpace(' ')(935,936) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(936,937) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(936,937) + PsiWhiteSpace('\n ')(937,950) + PsiElement(OpenSCADTokenType.COLON)(':')(950,951) + PsiWhiteSpace(' ')(951,953) + OpenSCADElvisExprImpl(ELVIS_EXPR)(953,1037) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(953,958) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(953,958) + PsiWhiteSpace(' ')(958,959) + PsiElement(OpenSCADTokenType.QUERY)('?')(959,960) + PsiWhiteSpace(' ')(960,961) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(961,962) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(961,962) + PsiWhiteSpace('\n ')(962,983) + PsiElement(OpenSCADTokenType.COLON)(':')(983,984) + PsiWhiteSpace(' ')(984,986) + OpenSCADAssertExprImpl(ASSERT_EXPR)(986,1037) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(986,1037) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(986,992) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(992,1037) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(992,993) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(993,998) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(993,998) + PsiElement(OpenSCADTokenType.COMMA)(',')(998,999) + PsiWhiteSpace(' ')(999,1000) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1000,1021) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"With one expression"')(1000,1021) + PsiElement(OpenSCADTokenType.COMMA)(',')(1021,1022) + PsiWhiteSpace(' ')(1022,1023) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1023,1036) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"and another"')(1023,1036) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1036,1037) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1037,1038) + PsiWhiteSpace('\n\n')(1038,1040) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1040,1164) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(1040,1081) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(1040,1046) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(1046,1081) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1046,1047) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(1047,1080) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(1047,1062) + PsiElement(OpenSCADTokenType.IDENTIFIER)('all_nonnegative')(1047,1062) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1062,1080) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1062,1063) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1063,1079) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1063,1079) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1063,1064) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1064,1078) + PsiElement(OpenSCADTokenType.IDENTIFIER)('endcap_extent1')(1064,1078) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1078,1079) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1079,1080) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1080,1081) + PsiWhiteSpace('\n')(1081,1082) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(1082,1123) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(1082,1088) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(1088,1123) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1088,1089) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(1089,1122) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(1089,1104) + PsiElement(OpenSCADTokenType.IDENTIFIER)('all_nonnegative')(1089,1104) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1104,1122) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1104,1105) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1105,1121) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1105,1121) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1105,1106) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1106,1120) + PsiElement(OpenSCADTokenType.IDENTIFIER)('endcap_extent2')(1106,1120) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1120,1121) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1121,1122) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1122,1123) + PsiWhiteSpace('\n')(1123,1124) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(1124,1163) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(1124,1130) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(1130,1163) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1130,1131) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(1131,1162) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(1131,1146) + PsiElement(OpenSCADTokenType.IDENTIFIER)('all_nonnegative')(1131,1146) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1146,1162) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1146,1147) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1147,1161) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1147,1161) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1147,1148) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1148,1160) + PsiElement(OpenSCADTokenType.IDENTIFIER)('joint_extent')(1148,1160) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1160,1161) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1161,1162) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1162,1163) + OpenSCADEmptyObjImpl(EMPTY_OBJ)(1163,1164) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1163,1164) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/assign_psidump.txt b/src/test/testData/openscad/parser/base/assign_psidump.txt index df9d9cc..81af880 100644 --- a/src/test/testData/openscad/parser/base/assign_psidump.txt +++ b/src/test/testData/openscad/parser/base/assign_psidump.txt @@ -113,7 +113,7 @@ OpenSCAD File(0,386) PsiWhiteSpace('\n ')(125,138) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(138,196) OpenSCADBuiltinOpImpl(BUILTIN_OP)(138,165) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(138,147) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(138,147) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(138,147) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(147,165) PsiElement(OpenSCADTokenType.LPARENTH)('(')(147,148) @@ -134,7 +134,7 @@ OpenSCAD File(0,386) PsiElement(OpenSCADTokenType.RPARENTH)(')')(164,165) PsiWhiteSpace('\n ')(165,182) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(182,196) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(182,188) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(182,188) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(182,188) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(188,195) PsiElement(OpenSCADTokenType.LPARENTH)('(')(188,189) @@ -259,7 +259,7 @@ OpenSCAD File(0,386) PsiWhiteSpace('\n ')(321,330) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(330,384) OpenSCADBuiltinOpImpl(BUILTIN_OP)(330,357) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(330,339) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(330,339) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(330,339) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(339,357) PsiElement(OpenSCADTokenType.LPARENTH)('(')(339,340) @@ -280,7 +280,7 @@ OpenSCAD File(0,386) PsiElement(OpenSCADTokenType.RPARENTH)(')')(356,357) PsiWhiteSpace('\n ')(357,370) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(370,384) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(370,376) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(370,376) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(370,376) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(376,383) PsiElement(OpenSCADTokenType.LPARENTH)('(')(376,377) diff --git a/src/test/testData/openscad/parser/base/each.scad b/src/test/testData/openscad/parser/base/each.scad index 5c6f081..f0e6ca7 100644 --- a/src/test/testData/openscad/parser/base/each.scad +++ b/src/test/testData/openscad/parser/base/each.scad @@ -11,3 +11,30 @@ echo(A); // ECHO: [-2, 1, 3, 5, 6, 4, 2, 0, -1] echo([for (a = A) 2 * a]); // ECHO: [-4, 2, 6, 10, 12, 8, 4, 0, -2] + +// Identifiers and expressions are allowed after the each keyword +k = [1, 2, 3]; +B = [0, each k, 0]; +echo(B); +// ECHO: [0, 1, 2, 3, 0] +k2 = [4, 5, 6]; +C = [0, each k+k2, 0]; +echo(C); +// ECHO: [0, 5, 7, 9, 0] + +function flatten(l) = + !is_list(l)? l : + [for (a=l) if (is_list(a)) (each a) else a]; + +y = [ + [0, 1], + if (true) each flatten([1, 2]) else [5, 6]]; +echo(y); +// ECHO: [[0, 1], 1, 2] + +x = [for(i=[0:1]) + [for(k=["a", "bc", "def"]) + each if (len(k)>1) i]]; +echo(x); +// ECHO: [[0, 0], [1, 1]] + diff --git a/src/test/testData/openscad/parser/base/each_psidump.txt b/src/test/testData/openscad/parser/base/each_psidump.txt index 386c742..d80c557 100644 --- a/src/test/testData/openscad/parser/base/each_psidump.txt +++ b/src/test/testData/openscad/parser/base/each_psidump.txt @@ -1,4 +1,4 @@ -OpenSCAD File(0,447) +OpenSCAD File(0,983) PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Without using "each", a nested list is generated')(0,51) PsiWhiteSpace('\n')(51,52) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(52,89) @@ -84,9 +84,9 @@ OpenSCAD File(0,447) PsiElement(OpenSCADTokenType.RBRACKET)(']')(228,229) PsiElement(OpenSCADTokenType.RPARENTH)(')')(229,230) PsiWhiteSpace(' ')(230,231) - OpenSCADVectorExprImpl(VECTOR_EXPR)(231,246) - PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(231,235) - PsiWhiteSpace(' ')(235,236) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(231,235) + PsiWhiteSpace(' ')(235,236) + OpenSCADVectorExprImpl(VECTOR_EXPR)(236,246) PsiElement(OpenSCADTokenType.LBRACKET)('[')(236,237) OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(237,238) PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(237,238) @@ -121,9 +121,9 @@ OpenSCAD File(0,447) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(293,294) PsiElement(OpenSCADTokenType.COMMA)(',')(294,295) PsiWhiteSpace(' ')(295,296) - OpenSCADRangeExprImpl(RANGE_EXPR)(296,308) - PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(296,300) - PsiWhiteSpace(' ')(300,301) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(296,300) + PsiWhiteSpace(' ')(300,301) + OpenSCADRangeExprImpl(RANGE_EXPR)(301,308) PsiElement(OpenSCADTokenType.LBRACKET)('[')(301,302) OpenSCADLiteralExprImpl(LITERAL_EXPR)(302,303) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(302,303) @@ -136,9 +136,9 @@ OpenSCAD File(0,447) PsiElement(OpenSCADTokenType.RBRACKET)(']')(307,308) PsiElement(OpenSCADTokenType.COMMA)(',')(308,309) PsiWhiteSpace(' ')(309,310) - OpenSCADRangeExprImpl(RANGE_EXPR)(310,324) - PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(310,314) - PsiWhiteSpace(' ')(314,315) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(310,314) + PsiWhiteSpace(' ')(314,315) + OpenSCADRangeExprImpl(RANGE_EXPR)(315,324) PsiElement(OpenSCADTokenType.LBRACKET)('[')(315,316) OpenSCADLiteralExprImpl(LITERAL_EXPR)(316,317) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(316,317) @@ -209,4 +209,356 @@ OpenSCAD File(0,447) PsiElement(OpenSCADTokenType.RPARENTH)(')')(404,405) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(405,406) PsiWhiteSpace('\n')(406,407) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [-4, 2, 6, 10, 12, 8, 4, 0, -2]')(407,447) \ No newline at end of file + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [-4, 2, 6, 10, 12, 8, 4, 0, -2]')(407,447) + PsiWhiteSpace('\n\n')(447,449) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Identifiers and expressions are allowed after the each keyword')(449,514) + PsiWhiteSpace('\n')(514,515) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(515,529) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k')(515,516) + PsiWhiteSpace(' ')(516,517) + PsiElement(OpenSCADTokenType.EQUALS)('=')(517,518) + PsiWhiteSpace(' ')(518,519) + OpenSCADVectorExprImpl(VECTOR_EXPR)(519,528) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(519,520) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(520,521) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(520,521) + PsiElement(OpenSCADTokenType.COMMA)(',')(521,522) + PsiWhiteSpace(' ')(522,523) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(523,524) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(523,524) + PsiElement(OpenSCADTokenType.COMMA)(',')(524,525) + PsiWhiteSpace(' ')(525,526) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(526,527) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(526,527) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(527,528) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(528,529) + PsiWhiteSpace('\n')(529,530) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(530,549) + PsiElement(OpenSCADTokenType.IDENTIFIER)('B')(530,531) + PsiWhiteSpace(' ')(531,532) + PsiElement(OpenSCADTokenType.EQUALS)('=')(532,533) + PsiWhiteSpace(' ')(533,534) + OpenSCADVectorExprImpl(VECTOR_EXPR)(534,548) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(534,535) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(535,536) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(535,536) + PsiElement(OpenSCADTokenType.COMMA)(',')(536,537) + PsiWhiteSpace(' ')(537,538) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(538,542) + PsiWhiteSpace(' ')(542,543) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(543,544) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k')(543,544) + PsiElement(OpenSCADTokenType.COMMA)(',')(544,545) + PsiWhiteSpace(' ')(545,546) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(546,547) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(546,547) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(547,548) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(548,549) + PsiWhiteSpace('\n')(549,550) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(550,558) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(550,554) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(550,554) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(554,557) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(554,555) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(555,556) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(555,556) + PsiElement(OpenSCADTokenType.IDENTIFIER)('B')(555,556) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(556,557) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(557,558) + PsiWhiteSpace('\n')(558,559) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0, 1, 2, 3, 0]')(559,583) + PsiWhiteSpace('\n')(583,584) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(584,599) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k2')(584,586) + PsiWhiteSpace(' ')(586,587) + PsiElement(OpenSCADTokenType.EQUALS)('=')(587,588) + PsiWhiteSpace(' ')(588,589) + OpenSCADVectorExprImpl(VECTOR_EXPR)(589,598) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(589,590) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(590,591) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(590,591) + PsiElement(OpenSCADTokenType.COMMA)(',')(591,592) + PsiWhiteSpace(' ')(592,593) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(593,594) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(593,594) + PsiElement(OpenSCADTokenType.COMMA)(',')(594,595) + PsiWhiteSpace(' ')(595,596) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(596,597) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(596,597) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(597,598) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(598,599) + PsiWhiteSpace('\n')(599,600) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(600,622) + PsiElement(OpenSCADTokenType.IDENTIFIER)('C')(600,601) + PsiWhiteSpace(' ')(601,602) + PsiElement(OpenSCADTokenType.EQUALS)('=')(602,603) + PsiWhiteSpace(' ')(603,604) + OpenSCADVectorExprImpl(VECTOR_EXPR)(604,621) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(604,605) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(605,606) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(605,606) + PsiElement(OpenSCADTokenType.COMMA)(',')(606,607) + PsiWhiteSpace(' ')(607,608) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(608,612) + PsiWhiteSpace(' ')(612,613) + OpenSCADPlusExprImpl(PLUS_EXPR)(613,617) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(613,614) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k')(613,614) + PsiElement(OpenSCADTokenType.PLUS)('+')(614,615) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(615,617) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k2')(615,617) + PsiElement(OpenSCADTokenType.COMMA)(',')(617,618) + PsiWhiteSpace(' ')(618,619) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(619,620) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(619,620) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(620,621) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(621,622) + PsiWhiteSpace('\n')(622,623) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(623,631) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(623,627) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(623,627) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(627,630) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(627,628) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(628,629) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(628,629) + PsiElement(OpenSCADTokenType.IDENTIFIER)('C')(628,629) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(629,630) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(630,631) + PsiWhiteSpace('\n')(631,632) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0, 5, 7, 9, 0]')(632,656) + PsiWhiteSpace('\n\n')(656,658) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(658,757) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(658,666) + PsiWhiteSpace(' ')(666,667) + PsiElement(OpenSCADTokenType.IDENTIFIER)('flatten')(667,674) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(674,677) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(674,675) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(675,676) + PsiElement(OpenSCADTokenType.IDENTIFIER)('l')(675,676) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(676,677) + PsiWhiteSpace(' ')(677,678) + PsiElement(OpenSCADTokenType.EQUALS)('=')(678,679) + PsiWhiteSpace('\n ')(679,684) + OpenSCADElvisExprImpl(ELVIS_EXPR)(684,756) + OpenSCADUnaryNegateExprImpl(UNARY_NEGATE_EXPR)(684,695) + PsiElement(OpenSCADTokenType.EXCL)('!')(684,685) + OpenSCADTestExprImpl(TEST_EXPR)(685,695) + OpenSCADTestExpRefImpl(TEST_EXP_REF)(685,692) + PsiElement(OpenSCADTokenType.IS_LIST_KEYWORD)('is_list')(685,692) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(692,693) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(693,694) + PsiElement(OpenSCADTokenType.IDENTIFIER)('l')(693,694) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(694,695) + PsiElement(OpenSCADTokenType.QUERY)('?')(695,696) + PsiWhiteSpace(' ')(696,697) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(697,698) + PsiElement(OpenSCADTokenType.IDENTIFIER)('l')(697,698) + PsiWhiteSpace(' ')(698,699) + PsiElement(OpenSCADTokenType.COLON)(':')(699,700) + PsiWhiteSpace('\n ')(700,713) + OpenSCADVectorExprImpl(VECTOR_EXPR)(713,756) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(713,714) + OpenSCADForElementImpl(FOR_ELEMENT)(714,723) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(714,717) + PsiWhiteSpace(' ')(717,718) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(718,723) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(718,719) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(719,722) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(719,720) + PsiElement(OpenSCADTokenType.EQUALS)('=')(720,721) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(721,722) + PsiElement(OpenSCADTokenType.IDENTIFIER)('l')(721,722) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(722,723) + PsiWhiteSpace(' ')(723,724) + OpenSCADIfElementImpl(IF_ELEMENT)(724,748) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(724,726) + PsiWhiteSpace(' ')(726,727) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(727,728) + OpenSCADTestExprImpl(TEST_EXPR)(728,738) + OpenSCADTestExpRefImpl(TEST_EXP_REF)(728,735) + PsiElement(OpenSCADTokenType.IS_LIST_KEYWORD)('is_list')(728,735) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(735,736) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(736,737) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(736,737) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(737,738) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(738,739) + PsiWhiteSpace(' ')(739,740) + OpenSCADParenExprImpl(PAREN_EXPR)(740,748) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(740,741) + OpenSCADEachExprImpl(EACH_EXPR)(741,747) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(741,745) + PsiWhiteSpace(' ')(745,746) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(746,747) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(746,747) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(747,748) + PsiWhiteSpace(' ')(748,749) + OpenSCADElseElementImpl(ELSE_ELEMENT)(749,753) + PsiElement(OpenSCADTokenType.ELSE_KEYWORD)('else')(749,753) + PsiWhiteSpace(' ')(753,754) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(754,755) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(754,755) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(755,756) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(756,757) + PsiWhiteSpace('\n\n')(757,759) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(759,829) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(759,760) + PsiWhiteSpace(' ')(760,761) + PsiElement(OpenSCADTokenType.EQUALS)('=')(761,762) + PsiWhiteSpace(' ')(762,763) + OpenSCADVectorExprImpl(VECTOR_EXPR)(763,828) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(763,764) + PsiWhiteSpace('\n ')(764,773) + OpenSCADVectorExprImpl(VECTOR_EXPR)(773,779) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(773,774) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(774,775) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(774,775) + PsiElement(OpenSCADTokenType.COMMA)(',')(775,776) + PsiWhiteSpace(' ')(776,777) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(777,778) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(777,778) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(778,779) + PsiElement(OpenSCADTokenType.COMMA)(',')(779,780) + PsiWhiteSpace('\n ')(780,785) + OpenSCADIfElementImpl(IF_ELEMENT)(785,815) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(785,787) + PsiWhiteSpace(' ')(787,788) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(788,789) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(789,793) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(789,793) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(793,794) + PsiWhiteSpace(' ')(794,795) + OpenSCADEachExprImpl(EACH_EXPR)(795,815) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(795,799) + PsiWhiteSpace(' ')(799,800) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(800,815) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(800,807) + PsiElement(OpenSCADTokenType.IDENTIFIER)('flatten')(800,807) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(807,815) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(807,808) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(808,814) + OpenSCADVectorExprImpl(VECTOR_EXPR)(808,814) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(808,809) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(809,810) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(809,810) + PsiElement(OpenSCADTokenType.COMMA)(',')(810,811) + PsiWhiteSpace(' ')(811,812) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(812,813) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(812,813) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(813,814) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(814,815) + PsiWhiteSpace(' ')(815,816) + OpenSCADElseElementImpl(ELSE_ELEMENT)(816,820) + PsiElement(OpenSCADTokenType.ELSE_KEYWORD)('else')(816,820) + PsiWhiteSpace(' ')(820,821) + OpenSCADVectorExprImpl(VECTOR_EXPR)(821,827) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(821,822) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(822,823) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(822,823) + PsiElement(OpenSCADTokenType.COMMA)(',')(823,824) + PsiWhiteSpace(' ')(824,825) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(825,826) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(825,826) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(826,827) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(827,828) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(828,829) + PsiWhiteSpace('\n')(829,830) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(830,838) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(830,834) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(830,834) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(834,837) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(834,835) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(835,836) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(835,836) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(835,836) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(836,837) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(837,838) + PsiWhiteSpace('\n')(838,839) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [[0, 1], 1, 2]')(839,862) + PsiWhiteSpace('\n\n')(862,864) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(864,948) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(864,865) + PsiWhiteSpace(' ')(865,866) + PsiElement(OpenSCADTokenType.EQUALS)('=')(866,867) + PsiWhiteSpace(' ')(867,868) + OpenSCADVectorExprImpl(VECTOR_EXPR)(868,947) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(868,869) + OpenSCADForElementImpl(FOR_ELEMENT)(869,881) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(869,872) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(872,881) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(872,873) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(873,880) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(873,874) + PsiElement(OpenSCADTokenType.EQUALS)('=')(874,875) + OpenSCADRangeExprImpl(RANGE_EXPR)(875,880) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(875,876) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(876,877) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(876,877) + PsiElement(OpenSCADTokenType.COLON)(':')(877,878) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(878,879) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(878,879) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(879,880) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(880,881) + PsiWhiteSpace('\n ')(881,890) + OpenSCADVectorExprImpl(VECTOR_EXPR)(890,946) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(890,891) + OpenSCADForElementImpl(FOR_ELEMENT)(891,916) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(891,894) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(894,916) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(894,895) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(895,915) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k')(895,896) + PsiElement(OpenSCADTokenType.EQUALS)('=')(896,897) + OpenSCADVectorExprImpl(VECTOR_EXPR)(897,915) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(897,898) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(898,901) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"a"')(898,901) + PsiElement(OpenSCADTokenType.COMMA)(',')(901,902) + PsiWhiteSpace(' ')(902,903) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(903,907) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"bc"')(903,907) + PsiElement(OpenSCADTokenType.COMMA)(',')(907,908) + PsiWhiteSpace(' ')(908,909) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(909,914) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"def"')(909,914) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(914,915) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(915,916) + PsiWhiteSpace('\n ')(916,925) + PsiElement(OpenSCADTokenType.EACH_KEYWORD)('each')(925,929) + PsiWhiteSpace(' ')(929,930) + OpenSCADIfElementImpl(IF_ELEMENT)(930,943) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(930,932) + PsiWhiteSpace(' ')(932,933) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(933,934) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(934,942) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(934,940) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(934,937) + PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(934,937) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(937,940) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(937,938) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(938,939) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(938,939) + PsiElement(OpenSCADTokenType.IDENTIFIER)('k')(938,939) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(939,940) + PsiElement(OpenSCADTokenType.GT)('>')(940,941) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(941,942) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(941,942) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(942,943) + PsiWhiteSpace(' ')(943,944) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(944,945) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(944,945) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(945,946) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(946,947) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(947,948) + PsiWhiteSpace('\n')(948,949) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(949,957) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(949,953) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(949,953) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(953,956) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(953,954) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(954,955) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(954,955) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(954,955) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(955,956) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(956,957) + PsiWhiteSpace('\n')(957,958) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [[0, 0], [1, 1]]')(958,983) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/echo.scad b/src/test/testData/openscad/parser/base/echo.scad index 7654739..f023c9b 100644 --- a/src/test/testData/openscad/parser/base/echo.scad +++ b/src/test/testData/openscad/parser/base/echo.scad @@ -40,3 +40,15 @@ function result(x) = echo(result = x) x; function sum(x, i = 0) = echo(str("x[", i, "]=", x[i])) result(len(x) > i ? x[i] + sum(x, i + 1) : 0); echo("sum(v) = ", sum(v)); +// Echo doesn't need to be followed by an expr in the elvis_expr +dummy = true ? echo("Is true") : 0; +// ECHO: "Is true" +echo(dummy); +// ECHO: undef + +function echo_row(matstr) = +let( + dummy=[for(row=matstr) echo(row) ] +) +dummy; + diff --git a/src/test/testData/openscad/parser/base/echo_psidump.txt b/src/test/testData/openscad/parser/base/echo_psidump.txt index a35f877..c0c9851 100644 --- a/src/test/testData/openscad/parser/base/echo_psidump.txt +++ b/src/test/testData/openscad/parser/base/echo_psidump.txt @@ -1,4 +1,4 @@ -OpenSCAD File(0,920) +OpenSCAD File(0,1151) OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(0,10) PsiElement(OpenSCADTokenType.IDENTIFIER)('my_h')(0,4) PsiWhiteSpace(' ')(4,5) @@ -72,7 +72,7 @@ OpenSCAD File(0,920) PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// shortcut')(114,125) PsiWhiteSpace('\n')(125,126) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(126,155) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(126,134) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(126,134) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(126,134) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(134,154) PsiElement(OpenSCADTokenType.LPARENTH)('(')(134,135) @@ -607,4 +607,97 @@ OpenSCAD File(0,920) PsiElement(OpenSCADTokenType.IDENTIFIER)('v')(916,917) PsiElement(OpenSCADTokenType.RPARENTH)(')')(917,918) PsiElement(OpenSCADTokenType.RPARENTH)(')')(918,919) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(919,920) \ No newline at end of file + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(919,920) + PsiWhiteSpace('\n\n')(920,922) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Echo doesn't need to be followed by an expr in the elvis_expr')(922,986) + PsiWhiteSpace('\n')(986,987) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(987,1022) + PsiElement(OpenSCADTokenType.IDENTIFIER)('dummy')(987,992) + PsiWhiteSpace(' ')(992,993) + PsiElement(OpenSCADTokenType.EQUALS)('=')(993,994) + PsiWhiteSpace(' ')(994,995) + OpenSCADElvisExprImpl(ELVIS_EXPR)(995,1021) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(995,999) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(995,999) + PsiWhiteSpace(' ')(999,1000) + PsiElement(OpenSCADTokenType.QUERY)('?')(1000,1001) + PsiWhiteSpace(' ')(1001,1002) + OpenSCADEchoExprImpl(ECHO_EXPR)(1002,1017) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(1002,1017) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1002,1006) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(1006,1017) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1006,1007) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1007,1016) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Is true"')(1007,1016) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1016,1017) + PsiWhiteSpace(' ')(1017,1018) + PsiElement(OpenSCADTokenType.COLON)(':')(1018,1019) + PsiWhiteSpace(' ')(1019,1020) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1020,1021) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1020,1021) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1021,1022) + PsiWhiteSpace('\n')(1022,1023) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: "Is true"')(1023,1041) + PsiWhiteSpace('\n')(1041,1042) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1042,1054) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1042,1046) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1042,1046) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1046,1053) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1046,1047) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1047,1052) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1047,1052) + PsiElement(OpenSCADTokenType.IDENTIFIER)('dummy')(1047,1052) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1052,1053) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1053,1054) + PsiWhiteSpace('\n')(1054,1055) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: undef')(1055,1069) + PsiWhiteSpace('\n\n')(1069,1071) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(1071,1151) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(1071,1079) + PsiWhiteSpace(' ')(1079,1080) + PsiElement(OpenSCADTokenType.IDENTIFIER)('echo_row')(1080,1088) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(1088,1096) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1088,1089) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(1089,1095) + PsiElement(OpenSCADTokenType.IDENTIFIER)('matstr')(1089,1095) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1095,1096) + PsiWhiteSpace(' ')(1096,1097) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1097,1098) + PsiWhiteSpace('\n')(1098,1099) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(1099,1150) + PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(1099,1102) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(1102,1144) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1102,1103) + PsiWhiteSpace('\n ')(1103,1108) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(1108,1142) + PsiElement(OpenSCADTokenType.IDENTIFIER)('dummy')(1108,1113) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1113,1114) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1114,1142) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1114,1115) + OpenSCADForElementImpl(FOR_ELEMENT)(1115,1130) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(1115,1118) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(1118,1130) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1118,1119) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(1119,1129) + PsiElement(OpenSCADTokenType.IDENTIFIER)('row')(1119,1122) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1122,1123) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1123,1129) + PsiElement(OpenSCADTokenType.IDENTIFIER)('matstr')(1123,1129) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1129,1130) + PsiWhiteSpace(' ')(1130,1131) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(1131,1140) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(1131,1140) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1131,1135) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(1135,1140) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1135,1136) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1136,1139) + PsiElement(OpenSCADTokenType.IDENTIFIER)('row')(1136,1139) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1139,1140) + PsiWhiteSpace(' ')(1140,1141) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1141,1142) + PsiWhiteSpace('\n')(1142,1143) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1143,1144) + PsiWhiteSpace('\n')(1144,1145) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1145,1150) + PsiElement(OpenSCADTokenType.IDENTIFIER)('dummy')(1145,1150) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1150,1151) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/elvis.scad b/src/test/testData/openscad/parser/base/elvis.scad index 1b07289..9709e69 100644 --- a/src/test/testData/openscad/parser/base/elvis.scad +++ b/src/test/testData/openscad/parser/base/elvis.scad @@ -32,3 +32,6 @@ echo(a > 2 ? (a < 3 ? "1" : "2") : "3"); echo(a > 2 ? a < 3 ? "1" : "2" : "3"); echo(a > 2 ? (a < 3 ? (a < 3 ? "1" : "1") : (a < 3 ? "1" : "1")) : (a < 3 ? "1" : "1")); echo(a > 2 ? a < 3 ? a < 3 ? "1" : "1" : a < 3 ? "1" : "1" : a < 3 ? "1" : "1"); + +edgetype = "profile"; +offsets = edgetype == "profile"? maxv(-1,1) : [0, 0]; diff --git a/src/test/testData/openscad/parser/base/elvis_psidump.txt b/src/test/testData/openscad/parser/base/elvis_psidump.txt index 0ca9ee1..d54e469 100644 --- a/src/test/testData/openscad/parser/base/elvis_psidump.txt +++ b/src/test/testData/openscad/parser/base/elvis_psidump.txt @@ -1,4 +1,4 @@ -OpenSCAD File(0,1272) +OpenSCAD File(0,1349) OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(0,6) PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(0,1) PsiWhiteSpace(' ')(1,2) @@ -948,4 +948,58 @@ OpenSCAD File(0,1272) OpenSCADLiteralExprImpl(LITERAL_EXPR)(1267,1270) PsiElement(OpenSCADTokenType.STRING_LITERAL)('"1"')(1267,1270) PsiElement(OpenSCADTokenType.RPARENTH)(')')(1270,1271) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1271,1272) \ No newline at end of file + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1271,1272) + PsiWhiteSpace('\n\n')(1272,1274) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1274,1295) + PsiElement(OpenSCADTokenType.IDENTIFIER)('edgetype')(1274,1282) + PsiWhiteSpace(' ')(1282,1283) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1283,1284) + PsiWhiteSpace(' ')(1284,1285) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1285,1294) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"profile"')(1285,1294) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1294,1295) + PsiWhiteSpace('\n')(1295,1296) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1296,1349) + PsiElement(OpenSCADTokenType.IDENTIFIER)('offsets')(1296,1303) + PsiWhiteSpace(' ')(1303,1304) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1304,1305) + PsiWhiteSpace(' ')(1305,1306) + OpenSCADElvisExprImpl(ELVIS_EXPR)(1306,1348) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(1306,1327) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1306,1314) + PsiElement(OpenSCADTokenType.IDENTIFIER)('edgetype')(1306,1314) + PsiWhiteSpace(' ')(1314,1315) + PsiElement(OpenSCADTokenType.EQ)('==')(1315,1317) + PsiWhiteSpace(' ')(1317,1318) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1318,1327) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"profile"')(1318,1327) + PsiElement(OpenSCADTokenType.QUERY)('?')(1327,1328) + PsiWhiteSpace(' ')(1328,1329) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(1329,1339) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(1329,1333) + PsiElement(OpenSCADTokenType.IDENTIFIER)('maxv')(1329,1333) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1333,1339) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1333,1334) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1334,1336) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(1334,1336) + PsiElement(OpenSCADTokenType.MINUS)('-')(1334,1335) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1335,1336) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(1335,1336) + PsiElement(OpenSCADTokenType.COMMA)(',')(1336,1337) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1337,1338) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1337,1338) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(1337,1338) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1338,1339) + PsiWhiteSpace(' ')(1339,1340) + PsiElement(OpenSCADTokenType.COLON)(':')(1340,1341) + PsiWhiteSpace(' ')(1341,1342) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1342,1348) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1342,1343) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1343,1344) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1343,1344) + PsiElement(OpenSCADTokenType.COMMA)(',')(1344,1345) + PsiWhiteSpace(' ')(1345,1346) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1346,1347) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1346,1347) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1347,1348) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1348,1349) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/for_psidump.txt b/src/test/testData/openscad/parser/base/for_psidump.txt index 9f0b267..43c27ea 100644 --- a/src/test/testData/openscad/parser/base/for_psidump.txt +++ b/src/test/testData/openscad/parser/base/for_psidump.txt @@ -311,7 +311,7 @@ OpenSCAD File(0,3044) PsiElement(OpenSCADTokenType.LBRACE)('{')(381,382) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(382,418) OpenSCADBuiltinOpImpl(BUILTIN_OP)(382,411) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(382,391) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(382,391) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(382,391) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(391,411) PsiElement(OpenSCADTokenType.LPARENTH)('(')(391,392) @@ -343,7 +343,7 @@ OpenSCAD File(0,3044) PsiElement(OpenSCADTokenType.RBRACKET)(']')(409,410) PsiElement(OpenSCADTokenType.RPARENTH)(')')(410,411) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(411,418) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(411,415) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(411,415) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(411,415) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(415,417) PsiElement(OpenSCADTokenType.LPARENTH)('(')(415,416) @@ -446,7 +446,7 @@ OpenSCAD File(0,3044) PsiWhiteSpace('\n')(543,544) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(544,602) OpenSCADBuiltinOpImpl(BUILTIN_OP)(544,573) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(544,553) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(544,553) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(544,553) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(553,573) PsiElement(OpenSCADTokenType.LPARENTH)('(')(553,554) @@ -496,7 +496,7 @@ OpenSCAD File(0,3044) PsiElement(OpenSCADTokenType.RBRACKET)(']')(592,593) PsiElement(OpenSCADTokenType.RPARENTH)(')')(593,594) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(594,601) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(594,598) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(594,598) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(594,598) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(598,600) PsiElement(OpenSCADTokenType.LPARENTH)('(')(598,599) @@ -654,7 +654,7 @@ OpenSCAD File(0,3044) PsiWhiteSpace('\n ')(773,778) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(778,844) OpenSCADBuiltinOpImpl(BUILTIN_OP)(778,814) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(778,787) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(778,787) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(778,787) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(787,814) PsiElement(OpenSCADTokenType.LPARENTH)('(')(787,788) @@ -701,7 +701,7 @@ OpenSCAD File(0,3044) PsiElement(OpenSCADTokenType.RPARENTH)(')')(813,814) PsiWhiteSpace('\n ')(814,823) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(823,844) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(823,827) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(823,827) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(823,827) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(827,843) PsiElement(OpenSCADTokenType.LPARENTH)('(')(827,828) diff --git a/src/test/testData/openscad/parser/base/if_psidump.txt b/src/test/testData/openscad/parser/base/if_psidump.txt index 01adf49..4259e26 100644 --- a/src/test/testData/openscad/parser/base/if_psidump.txt +++ b/src/test/testData/openscad/parser/base/if_psidump.txt @@ -15,7 +15,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(10,11) PsiWhiteSpace(' ')(11,13) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(13,21) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(13,17) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(13,17) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(13,17) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(17,20) PsiElement(OpenSCADTokenType.LPARENTH)('(')(17,18) @@ -43,7 +43,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(33,56) PsiElement(OpenSCADTokenType.LBRACE)('{')(33,34) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(34,42) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(34,38) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(34,38) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(34,38) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(38,41) PsiElement(OpenSCADTokenType.LPARENTH)('(')(38,39) @@ -54,7 +54,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(41,42) PsiWhiteSpace(' ')(42,43) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(43,55) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(43,51) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(43,51) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(43,51) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(51,54) PsiElement(OpenSCADTokenType.LPARENTH)('(')(51,52) @@ -83,7 +83,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(69,92) PsiElement(OpenSCADTokenType.LBRACE)('{')(69,70) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(70,78) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(70,74) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(70,74) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(70,74) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(74,77) PsiElement(OpenSCADTokenType.LPARENTH)('(')(74,75) @@ -94,7 +94,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(77,78) PsiWhiteSpace(' ')(78,79) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(79,91) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(79,87) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(79,87) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(79,87) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(87,90) PsiElement(OpenSCADTokenType.LPARENTH)('(')(87,88) @@ -121,7 +121,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(103,104) PsiWhiteSpace(' ')(104,106) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(106,114) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(106,110) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(106,110) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(106,110) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(110,113) PsiElement(OpenSCADTokenType.LPARENTH)('(')(110,111) @@ -134,7 +134,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.ELSE_KEYWORD)('else')(115,119) PsiWhiteSpace(' ')(119,120) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(120,132) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(120,128) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(120,128) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(120,128) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(128,131) PsiElement(OpenSCADTokenType.LPARENTH)('(')(128,129) @@ -156,7 +156,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(140,163) PsiElement(OpenSCADTokenType.LBRACE)('{')(140,141) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(141,149) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(141,145) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(141,145) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(141,145) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(145,148) PsiElement(OpenSCADTokenType.LPARENTH)('(')(145,146) @@ -167,7 +167,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(148,149) PsiWhiteSpace(' ')(149,150) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(150,162) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(150,158) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(150,158) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(150,158) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(158,161) PsiElement(OpenSCADTokenType.LPARENTH)('(')(158,159) @@ -183,7 +183,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(169,190) PsiElement(OpenSCADTokenType.LBRACE)('{')(169,170) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(170,189) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(170,178) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(170,178) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(170,178) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(178,188) PsiElement(OpenSCADTokenType.LPARENTH)('(')(178,179) @@ -218,7 +218,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(202,225) PsiElement(OpenSCADTokenType.LBRACE)('{')(202,203) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(203,211) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(203,207) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(203,207) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(203,207) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(207,210) PsiElement(OpenSCADTokenType.LPARENTH)('(')(207,208) @@ -229,7 +229,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(210,211) PsiWhiteSpace(' ')(211,212) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(212,224) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(212,220) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(212,220) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(212,220) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(220,223) PsiElement(OpenSCADTokenType.LPARENTH)('(')(220,221) @@ -243,7 +243,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.ELSE_KEYWORD)('else')(226,230) PsiWhiteSpace(' ')(230,232) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(232,251) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(232,240) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(232,240) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(232,240) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(240,250) PsiElement(OpenSCADTokenType.LPARENTH)('(')(240,241) @@ -279,7 +279,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(261,262) PsiWhiteSpace(' ')(262,265) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(265,289) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(265,269) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(265,269) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(265,269) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(269,288) PsiElement(OpenSCADTokenType.LPARENTH)('(')(269,270) @@ -304,7 +304,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(295,327) PsiElement(OpenSCADTokenType.LBRACE)('{')(295,296) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(296,326) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(296,300) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(296,300) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(296,300) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(300,325) PsiElement(OpenSCADTokenType.LPARENTH)('(')(300,301) @@ -398,7 +398,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(393,403) PsiElement(OpenSCADTokenType.LBRACE)('{')(393,394) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(394,402) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(394,398) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(394,398) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(394,398) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(398,401) PsiElement(OpenSCADTokenType.LPARENTH)('(')(398,399) @@ -414,7 +414,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(409,423) PsiElement(OpenSCADTokenType.LBRACE)('{')(409,410) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(410,422) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(410,418) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(410,418) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(410,418) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(418,421) PsiElement(OpenSCADTokenType.LPARENTH)('(')(418,419) @@ -453,7 +453,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(442,443) PsiWhiteSpace(' ')(443,450) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(450,458) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(450,454) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(450,454) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(450,454) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(454,457) PsiElement(OpenSCADTokenType.LPARENTH)('(')(454,455) @@ -466,7 +466,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.ELSE_KEYWORD)('else')(459,463) PsiWhiteSpace(' ')(463,465) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(465,477) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(465,473) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(465,473) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(465,473) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(473,476) PsiElement(OpenSCADTokenType.LPARENTH)('(')(473,474) @@ -510,7 +510,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(501,502) PsiWhiteSpace(' ')(502,503) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(503,512) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(503,507) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(503,507) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(503,507) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(507,511) PsiElement(OpenSCADTokenType.LPARENTH)('(')(507,508) @@ -539,7 +539,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(530,551) PsiElement(OpenSCADTokenType.LBRACE)('{')(530,531) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(531,541) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(531,537) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(531,537) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(531,537) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(537,540) PsiElement(OpenSCADTokenType.LPARENTH)('(')(537,538) @@ -549,7 +549,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(539,540) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(540,541) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(541,550) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(541,545) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(541,545) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(541,545) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(545,549) PsiElement(OpenSCADTokenType.LPARENTH)('(')(545,546) @@ -587,7 +587,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.STRING_LITERAL)('"blue"')(578,584) PsiElement(OpenSCADTokenType.RPARENTH)(')')(584,585) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(585,595) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(585,591) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(585,591) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(585,591) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(591,594) PsiElement(OpenSCADTokenType.LPARENTH)('(')(591,592) @@ -622,7 +622,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(617,648) PsiElement(OpenSCADTokenType.LBRACE)('{')(617,618) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(618,637) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(618,626) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(618,626) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(618,626) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(626,636) PsiElement(OpenSCADTokenType.LPARENTH)('(')(626,627) @@ -642,7 +642,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(635,636) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(636,637) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(637,647) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(637,643) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(637,643) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(637,643) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(643,646) PsiElement(OpenSCADTokenType.LPARENTH)('(')(643,644) @@ -669,7 +669,7 @@ OpenSCAD File(0,1705) OpenSCADBlockObjImpl(BLOCK_OBJ)(681,712) PsiElement(OpenSCADTokenType.LBRACE)('{')(681,682) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(682,701) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(682,690) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(682,690) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(682,690) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(690,700) PsiElement(OpenSCADTokenType.LPARENTH)('(')(690,691) @@ -689,7 +689,7 @@ OpenSCAD File(0,1705) PsiElement(OpenSCADTokenType.RPARENTH)(')')(699,700) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(700,701) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(701,711) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(701,707) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(701,707) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(701,707) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(707,710) PsiElement(OpenSCADTokenType.LPARENTH)('(')(707,708) diff --git a/src/test/testData/openscad/parser/base/include_psidump.txt b/src/test/testData/openscad/parser/base/include_psidump.txt index 6eddd4d..9017fd9 100644 --- a/src/test/testData/openscad/parser/base/include_psidump.txt +++ b/src/test/testData/openscad/parser/base/include_psidump.txt @@ -96,7 +96,7 @@ OpenSCAD File(0,268) PsiWhiteSpace('\n\n ')(204,210) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(210,247) OpenSCADBuiltinOpImpl(BUILTIN_OP)(210,231) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(210,219) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(210,219) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(210,219) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(219,231) PsiElement(OpenSCADTokenType.LPARENTH)('(')(219,220) diff --git a/src/test/testData/openscad/parser/base/intersection_for_psidump.txt b/src/test/testData/openscad/parser/base/intersection_for_psidump.txt index f6d107b..8f816f0 100644 --- a/src/test/testData/openscad/parser/base/intersection_for_psidump.txt +++ b/src/test/testData/openscad/parser/base/intersection_for_psidump.txt @@ -56,7 +56,7 @@ OpenSCAD File(0,310) PsiWhiteSpace('\n ')(68,81) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(81,133) OpenSCADBuiltinOpImpl(BUILTIN_OP)(81,101) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(81,90) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(81,90) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(81,90) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(90,101) PsiElement(OpenSCADTokenType.LPARENTH)('(')(90,91) @@ -77,7 +77,7 @@ OpenSCAD File(0,310) PsiElement(OpenSCADTokenType.RPARENTH)(')')(100,101) PsiWhiteSpace('\n ')(101,118) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(118,133) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(118,124) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(118,124) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(118,124) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(124,132) PsiElement(OpenSCADTokenType.LPARENTH)('(')(124,125) @@ -183,7 +183,7 @@ OpenSCAD File(0,310) PsiElement(OpenSCADTokenType.RPARENTH)(')')(263,264) PsiWhiteSpace('\n ')(264,273) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(273,308) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(273,277) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(273,277) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(273,277) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(277,307) PsiElement(OpenSCADTokenType.LPARENTH)('(')(277,278) diff --git a/src/test/testData/openscad/parser/base/is_list_psidump.txt b/src/test/testData/openscad/parser/base/is_list_psidump.txt index 3d5b99e..ba06a33 100644 --- a/src/test/testData/openscad/parser/base/is_list_psidump.txt +++ b/src/test/testData/openscad/parser/base/is_list_psidump.txt @@ -322,6 +322,6 @@ OpenSCAD File(0,415) PsiWhiteSpace(' ')(410,411) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(411,412) PsiElement(OpenSCADTokenType.RPARENTH)(')')(412,413) - PsiErrorElement:OpenSCADTokenType.SEMICOLON expected, got ')'(413,414) + PsiErrorElement:, OpenSCADTokenType.ECHO_KEYWORD or OpenSCADTokenType.SEMICOLON expected, got ')'(413,414) PsiElement(OpenSCADTokenType.RPARENTH)(')')(413,414) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(414,415) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/is_undef_psidump.txt b/src/test/testData/openscad/parser/base/is_undef_psidump.txt index d432a01..a24f696 100644 --- a/src/test/testData/openscad/parser/base/is_undef_psidump.txt +++ b/src/test/testData/openscad/parser/base/is_undef_psidump.txt @@ -18,7 +18,7 @@ OpenSCAD File(0,138) PsiElement(OpenSCADTokenType.LBRACE)('{')(16,17) PsiWhiteSpace('\n ')(17,22) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(22,30) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(22,26) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(22,26) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(22,26) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(26,29) PsiElement(OpenSCADTokenType.LPARENTH)('(')(26,27) diff --git a/src/test/testData/openscad/parser/base/let.scad b/src/test/testData/openscad/parser/base/let.scad index d6c512a..6cf4a46 100644 --- a/src/test/testData/openscad/parser/base/let.scad +++ b/src/test/testData/openscad/parser/base/let.scad @@ -6,7 +6,7 @@ for (i = [10:50]) { rotate(angle, [1, 0, 0]) translate([0, distance, 0]) - sphere(r = r); + sphere(r = r); } } @@ -18,4 +18,15 @@ function quicksort(arr) = !(len(arr) > 0) ? [] : let( lesser = [for (y = arr) if (y < pivot) y], equal = [for (y = arr) if (y == pivot) y], greater = [for (y = arr) if (y > pivot) y] -) concat(quicksort(lesser), equal, quicksort(greater)); \ No newline at end of file +) concat(quicksort(lesser), equal, quicksort(greater)); + +geom = [0, 1, 2, [0, 1], [0, 1, 2], quicksort]; +for (i = [10:50]) +{ + let( + size=geom[1], size2=geom[2], + shift=point2d(geom[3]), axis=point3d(geom[4]), + override = geom[5]([2, 3, 4]) + ) + cylinder(h=size, r=size2); +} diff --git a/src/test/testData/openscad/parser/base/let_psidump.txt b/src/test/testData/openscad/parser/base/let_psidump.txt index b3d511e..ec7133d 100644 --- a/src/test/testData/openscad/parser/base/let_psidump.txt +++ b/src/test/testData/openscad/parser/base/let_psidump.txt @@ -1,4 +1,4 @@ -OpenSCAD File(0,705) +OpenSCAD File(0,948) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(0,50) OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(0,4) PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(0,4) @@ -64,7 +64,7 @@ OpenSCAD File(0,705) PsiWhiteSpace(' ')(50,51) PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0.707107, -0.707107]')(51,81) PsiWhiteSpace('\n\n')(81,83) - OpenSCADForObjImpl(FOR_OBJ)(83,280) + OpenSCADForObjImpl(FOR_OBJ)(83,276) PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(83,86) PsiWhiteSpace(' ')(86,87) OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(87,100) @@ -84,10 +84,10 @@ OpenSCAD File(0,705) PsiElement(OpenSCADTokenType.RBRACKET)(']')(98,99) PsiElement(OpenSCADTokenType.RPARENTH)(')')(99,100) PsiWhiteSpace('\n')(100,101) - OpenSCADBlockObjImpl(BLOCK_OBJ)(101,280) + OpenSCADBlockObjImpl(BLOCK_OBJ)(101,276) PsiElement(OpenSCADTokenType.LBRACE)('{')(101,102) PsiWhiteSpace('\n ')(102,107) - OpenSCADForObjImpl(FOR_OBJ)(107,278) + OpenSCADForObjImpl(FOR_OBJ)(107,274) PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(107,110) PsiWhiteSpace(' ')(110,111) OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(111,162) @@ -143,10 +143,10 @@ OpenSCAD File(0,705) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(160,161) PsiElement(OpenSCADTokenType.RPARENTH)(')')(161,162) PsiWhiteSpace('\n ')(162,167) - OpenSCADBlockObjImpl(BLOCK_OBJ)(167,278) + OpenSCADBlockObjImpl(BLOCK_OBJ)(167,274) PsiElement(OpenSCADTokenType.LBRACE)('{')(167,168) PsiWhiteSpace('\n ')(168,177) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(177,272) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(177,268) OpenSCADBuiltinOpImpl(BUILTIN_OP)(177,201) OpenSCADCommonOpRefImpl(COMMON_OP_REF)(177,183) PsiElement(OpenSCADTokenType.ROTATE_KEYWORD)('rotate')(177,183) @@ -173,9 +173,9 @@ OpenSCAD File(0,705) PsiElement(OpenSCADTokenType.RBRACKET)(']')(199,200) PsiElement(OpenSCADTokenType.RPARENTH)(')')(200,201) PsiWhiteSpace('\n ')(201,214) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(214,272) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(214,268) OpenSCADBuiltinOpImpl(BUILTIN_OP)(214,241) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(214,223) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(214,223) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(214,223) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(223,241) PsiElement(OpenSCADTokenType.LPARENTH)('(')(223,224) @@ -194,353 +194,548 @@ OpenSCAD File(0,705) PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(238,239) PsiElement(OpenSCADTokenType.RBRACKET)(']')(239,240) PsiElement(OpenSCADTokenType.RPARENTH)(')')(240,241) - PsiWhiteSpace('\n ')(241,258) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(258,272) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(258,264) - PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(258,264) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(264,271) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(264,265) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(265,270) - OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(265,266) + PsiWhiteSpace('\n ')(241,254) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(254,268) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(254,260) + PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(254,260) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(260,267) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(260,261) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(261,266) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(261,262) + PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(261,262) + PsiWhiteSpace(' ')(262,263) + PsiElement(OpenSCADTokenType.EQUALS)('=')(263,264) + PsiWhiteSpace(' ')(264,265) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(265,266) PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(265,266) - PsiWhiteSpace(' ')(266,267) - PsiElement(OpenSCADTokenType.EQUALS)('=')(267,268) - PsiWhiteSpace(' ')(268,269) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(269,270) - PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(269,270) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(270,271) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(271,272) - PsiWhiteSpace('\n ')(272,277) - PsiElement(OpenSCADTokenType.RBRACE)('}')(277,278) - PsiWhiteSpace('\n')(278,279) - PsiElement(OpenSCADTokenType.RBRACE)('}')(279,280) - PsiWhiteSpace('\n\n')(280,282) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(282,346) - PsiElement(OpenSCADTokenType.IDENTIFIER)('list')(282,286) - PsiWhiteSpace(' ')(286,287) - PsiElement(OpenSCADTokenType.EQUALS)('=')(287,288) - PsiWhiteSpace(' ')(288,289) - OpenSCADVectorExprImpl(VECTOR_EXPR)(289,345) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(289,290) - OpenSCADForElementImpl(FOR_ELEMENT)(290,307) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(290,293) - PsiWhiteSpace(' ')(293,294) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(294,307) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(294,295) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(295,306) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(295,296) - PsiWhiteSpace(' ')(296,297) - PsiElement(OpenSCADTokenType.EQUALS)('=')(297,298) - PsiWhiteSpace(' ')(298,299) - OpenSCADRangeExprImpl(RANGE_EXPR)(299,306) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(299,300) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(266,267) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(267,268) + PsiWhiteSpace('\n ')(268,273) + PsiElement(OpenSCADTokenType.RBRACE)('}')(273,274) + PsiWhiteSpace('\n')(274,275) + PsiElement(OpenSCADTokenType.RBRACE)('}')(275,276) + PsiWhiteSpace('\n\n')(276,278) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(278,342) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list')(278,282) + PsiWhiteSpace(' ')(282,283) + PsiElement(OpenSCADTokenType.EQUALS)('=')(283,284) + PsiWhiteSpace(' ')(284,285) + OpenSCADVectorExprImpl(VECTOR_EXPR)(285,341) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(285,286) + OpenSCADForElementImpl(FOR_ELEMENT)(286,303) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(286,289) + PsiWhiteSpace(' ')(289,290) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(290,303) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(290,291) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(291,302) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(291,292) + PsiWhiteSpace(' ')(292,293) + PsiElement(OpenSCADTokenType.EQUALS)('=')(293,294) + PsiWhiteSpace(' ')(294,295) + OpenSCADRangeExprImpl(RANGE_EXPR)(295,302) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(295,296) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(296,297) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(296,297) + PsiWhiteSpace(' ')(297,298) + PsiElement(OpenSCADTokenType.COLON)(':')(298,299) + PsiWhiteSpace(' ')(299,300) OpenSCADLiteralExprImpl(LITERAL_EXPR)(300,301) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(300,301) - PsiWhiteSpace(' ')(301,302) - PsiElement(OpenSCADTokenType.COLON)(':')(302,303) - PsiWhiteSpace(' ')(303,304) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(304,305) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(304,305) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(305,306) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(306,307) - PsiWhiteSpace(' ')(307,308) - OpenSCADLetElementImpl(LET_ELEMENT)(308,334) - PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(308,311) - PsiWhiteSpace(' ')(311,312) - OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(312,334) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(312,313) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(313,322) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(313,314) - PsiWhiteSpace(' ')(314,315) - PsiElement(OpenSCADTokenType.EQUALS)('=')(315,316) - PsiWhiteSpace(' ')(316,317) - OpenSCADMulExprImpl(MUL_EXPR)(317,322) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(300,301) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(301,302) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(302,303) + PsiWhiteSpace(' ')(303,304) + OpenSCADLetElementImpl(LET_ELEMENT)(304,330) + PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(304,307) + PsiWhiteSpace(' ')(307,308) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(308,330) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(308,309) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(309,318) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(309,310) + PsiWhiteSpace(' ')(310,311) + PsiElement(OpenSCADTokenType.EQUALS)('=')(311,312) + PsiWhiteSpace(' ')(312,313) + OpenSCADMulExprImpl(MUL_EXPR)(313,318) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(313,314) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(313,314) + PsiWhiteSpace(' ')(314,315) + PsiElement(OpenSCADTokenType.MUL)('*')(315,316) + PsiWhiteSpace(' ')(316,317) OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(317,318) PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(317,318) - PsiWhiteSpace(' ')(318,319) - PsiElement(OpenSCADTokenType.MUL)('*')(319,320) - PsiWhiteSpace(' ')(320,321) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(321,322) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(321,322) - PsiElement(OpenSCADTokenType.COMMA)(',')(322,323) - PsiWhiteSpace(' ')(323,324) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(324,333) - PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(324,325) - PsiWhiteSpace(' ')(325,326) - PsiElement(OpenSCADTokenType.EQUALS)('=')(326,327) - PsiWhiteSpace(' ')(327,328) - OpenSCADMulExprImpl(MUL_EXPR)(328,333) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(328,329) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(328,329) - PsiWhiteSpace(' ')(329,330) - PsiElement(OpenSCADTokenType.MUL)('*')(330,331) - PsiWhiteSpace(' ')(331,332) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(332,333) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(332,333) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(333,334) - PsiWhiteSpace(' ')(334,335) - OpenSCADVectorExprImpl(VECTOR_EXPR)(335,344) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(335,336) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(336,337) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(336,337) - PsiElement(OpenSCADTokenType.COMMA)(',')(337,338) - PsiWhiteSpace(' ')(338,339) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(339,340) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(339,340) - PsiElement(OpenSCADTokenType.COMMA)(',')(340,341) - PsiWhiteSpace(' ')(341,342) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(342,343) - PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(342,343) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(343,344) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(344,345) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(345,346) - PsiWhiteSpace('\n')(346,347) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(347,358) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(347,351) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(347,351) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(351,357) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(351,352) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(352,356) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(352,356) - PsiElement(OpenSCADTokenType.IDENTIFIER)('list')(352,356) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(356,357) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(357,358) - PsiWhiteSpace(' ')(358,359) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [[1, 1, 2], [2, 4, 8], [3, 9, 18], [4, 16, 32]]')(359,415) - PsiWhiteSpace('\n\n')(415,417) - OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(417,705) - PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(417,425) - PsiWhiteSpace(' ')(425,426) - PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(426,435) - OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(435,440) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(435,436) - OpenSCADArgDeclarationImpl(ARG_DECLARATION)(436,439) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(436,439) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(439,440) - PsiWhiteSpace(' ')(440,441) - PsiElement(OpenSCADTokenType.EQUALS)('=')(441,442) - PsiWhiteSpace(' ')(442,443) - OpenSCADElvisExprImpl(ELVIS_EXPR)(443,704) - OpenSCADUnaryNegateExprImpl(UNARY_NEGATE_EXPR)(443,458) - PsiElement(OpenSCADTokenType.EXCL)('!')(443,444) - OpenSCADParenExprImpl(PAREN_EXPR)(444,458) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(444,445) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(445,457) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(445,453) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(445,448) - PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(445,448) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(448,453) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(448,449) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(449,452) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(449,452) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(449,452) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(452,453) - PsiWhiteSpace(' ')(453,454) - PsiElement(OpenSCADTokenType.GT)('>')(454,455) - PsiWhiteSpace(' ')(455,456) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(456,457) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(456,457) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(457,458) - PsiWhiteSpace(' ')(458,459) - PsiElement(OpenSCADTokenType.QUERY)('?')(459,460) - PsiWhiteSpace(' ')(460,461) - OpenSCADVectorExprImpl(VECTOR_EXPR)(461,463) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(461,462) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(462,463) - PsiWhiteSpace(' ')(463,464) - PsiElement(OpenSCADTokenType.COLON)(':')(464,465) - PsiWhiteSpace(' ')(465,466) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(466,704) - PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(466,469) - OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(469,651) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(469,470) - PsiWhiteSpace('\n ')(470,475) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(475,507) - PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(475,480) - PsiWhiteSpace(' ')(480,481) - PsiElement(OpenSCADTokenType.EQUALS)('=')(481,482) - PsiWhiteSpace(' ')(482,483) - OpenSCADIndexExprImpl(INDEX_EXPR)(483,507) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(483,486) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(483,486) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(486,487) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(487,506) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(487,492) - PsiElement(OpenSCADTokenType.FLOOR_KEYWORD)('floor')(487,492) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(492,506) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(492,493) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(493,505) - OpenSCADDivExprImpl(DIV_EXPR)(493,505) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(493,501) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(493,496) - PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(493,496) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(496,501) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(496,497) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(497,500) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(497,500) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(497,500) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(500,501) - PsiWhiteSpace(' ')(501,502) - PsiElement(OpenSCADTokenType.DIV)('/')(502,503) - PsiWhiteSpace(' ')(503,504) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(504,505) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(504,505) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(505,506) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(506,507) - PsiElement(OpenSCADTokenType.COMMA)(',')(507,508) - PsiWhiteSpace('\n ')(508,513) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(513,554) - PsiElement(OpenSCADTokenType.IDENTIFIER)('lesser')(513,519) - PsiWhiteSpace(' ')(519,520) - PsiElement(OpenSCADTokenType.EQUALS)('=')(520,521) - PsiWhiteSpace(' ')(521,522) - OpenSCADVectorExprImpl(VECTOR_EXPR)(522,554) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(522,523) - OpenSCADForElementImpl(FOR_ELEMENT)(523,536) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(523,526) - PsiWhiteSpace(' ')(526,527) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(527,536) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(527,528) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(528,535) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(528,529) - PsiWhiteSpace(' ')(529,530) - PsiElement(OpenSCADTokenType.EQUALS)('=')(530,531) - PsiWhiteSpace(' ')(531,532) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(532,535) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(532,535) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(535,536) - PsiWhiteSpace(' ')(536,537) - OpenSCADIfElementImpl(IF_ELEMENT)(537,551) - PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(537,539) - PsiWhiteSpace(' ')(539,540) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(540,541) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(541,550) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(541,542) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(541,542) - PsiWhiteSpace(' ')(542,543) - PsiElement(OpenSCADTokenType.LT)('<')(543,544) - PsiWhiteSpace(' ')(544,545) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(545,550) - PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(545,550) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(550,551) - PsiWhiteSpace(' ')(551,552) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(552,553) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(552,553) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(553,554) - PsiElement(OpenSCADTokenType.COMMA)(',')(554,555) - PsiWhiteSpace('\n ')(555,560) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(560,601) - PsiElement(OpenSCADTokenType.IDENTIFIER)('equal')(560,565) - PsiWhiteSpace(' ')(565,566) - PsiElement(OpenSCADTokenType.EQUALS)('=')(566,567) - PsiWhiteSpace(' ')(567,568) - OpenSCADVectorExprImpl(VECTOR_EXPR)(568,601) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(568,569) - OpenSCADForElementImpl(FOR_ELEMENT)(569,582) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(569,572) - PsiWhiteSpace(' ')(572,573) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(573,582) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(573,574) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(574,581) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(574,575) - PsiWhiteSpace(' ')(575,576) - PsiElement(OpenSCADTokenType.EQUALS)('=')(576,577) - PsiWhiteSpace(' ')(577,578) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(578,581) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(578,581) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(581,582) - PsiWhiteSpace(' ')(582,583) - OpenSCADIfElementImpl(IF_ELEMENT)(583,598) - PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(583,585) - PsiWhiteSpace(' ')(585,586) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(586,587) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(587,597) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(587,588) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(587,588) - PsiWhiteSpace(' ')(588,589) - PsiElement(OpenSCADTokenType.EQ)('==')(589,591) - PsiWhiteSpace(' ')(591,592) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(592,597) - PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(592,597) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(597,598) - PsiWhiteSpace(' ')(598,599) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(599,600) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(599,600) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(600,601) - PsiElement(OpenSCADTokenType.COMMA)(',')(601,602) - PsiWhiteSpace('\n ')(602,607) - OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(607,649) - PsiElement(OpenSCADTokenType.IDENTIFIER)('greater')(607,614) - PsiWhiteSpace(' ')(614,615) - PsiElement(OpenSCADTokenType.EQUALS)('=')(615,616) - PsiWhiteSpace(' ')(616,617) - OpenSCADVectorExprImpl(VECTOR_EXPR)(617,649) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(617,618) - OpenSCADForElementImpl(FOR_ELEMENT)(618,631) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(618,621) - PsiWhiteSpace(' ')(621,622) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(622,631) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(622,623) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(623,630) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(623,624) - PsiWhiteSpace(' ')(624,625) - PsiElement(OpenSCADTokenType.EQUALS)('=')(625,626) - PsiWhiteSpace(' ')(626,627) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(627,630) - PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(627,630) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(630,631) - PsiWhiteSpace(' ')(631,632) - OpenSCADIfElementImpl(IF_ELEMENT)(632,646) - PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(632,634) - PsiWhiteSpace(' ')(634,635) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(635,636) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(636,645) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(636,637) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(636,637) - PsiWhiteSpace(' ')(637,638) - PsiElement(OpenSCADTokenType.GT)('>')(638,639) - PsiWhiteSpace(' ')(639,640) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(640,645) - PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(640,645) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(645,646) - PsiWhiteSpace(' ')(646,647) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(647,648) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(647,648) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(648,649) - PsiWhiteSpace('\n')(649,650) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(650,651) - PsiWhiteSpace(' ')(651,652) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(652,704) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(652,658) - PsiElement(OpenSCADTokenType.CONCAT_KEYWORD)('concat')(652,658) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(658,704) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(658,659) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(659,676) - OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(659,676) - OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(659,668) - PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(659,668) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(668,676) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(668,669) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(669,675) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(669,675) - PsiElement(OpenSCADTokenType.IDENTIFIER)('lesser')(669,675) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(675,676) - PsiElement(OpenSCADTokenType.COMMA)(',')(676,677) - PsiWhiteSpace(' ')(677,678) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(678,683) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(678,683) - PsiElement(OpenSCADTokenType.IDENTIFIER)('equal')(678,683) - PsiElement(OpenSCADTokenType.COMMA)(',')(683,684) - PsiWhiteSpace(' ')(684,685) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(685,703) - OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(685,703) - OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(685,694) - PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(685,694) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(694,703) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(694,695) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(695,702) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(695,702) - PsiElement(OpenSCADTokenType.IDENTIFIER)('greater')(695,702) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(702,703) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(703,704) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(704,705) \ No newline at end of file + PsiElement(OpenSCADTokenType.COMMA)(',')(318,319) + PsiWhiteSpace(' ')(319,320) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(320,329) + PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(320,321) + PsiWhiteSpace(' ')(321,322) + PsiElement(OpenSCADTokenType.EQUALS)('=')(322,323) + PsiWhiteSpace(' ')(323,324) + OpenSCADMulExprImpl(MUL_EXPR)(324,329) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(324,325) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(324,325) + PsiWhiteSpace(' ')(325,326) + PsiElement(OpenSCADTokenType.MUL)('*')(326,327) + PsiWhiteSpace(' ')(327,328) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(328,329) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(328,329) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(329,330) + PsiWhiteSpace(' ')(330,331) + OpenSCADVectorExprImpl(VECTOR_EXPR)(331,340) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(331,332) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(332,333) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(332,333) + PsiElement(OpenSCADTokenType.COMMA)(',')(333,334) + PsiWhiteSpace(' ')(334,335) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(335,336) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(335,336) + PsiElement(OpenSCADTokenType.COMMA)(',')(336,337) + PsiWhiteSpace(' ')(337,338) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(338,339) + PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(338,339) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(339,340) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(340,341) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(341,342) + PsiWhiteSpace('\n')(342,343) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(343,354) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(343,347) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(343,347) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(347,353) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(347,348) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(348,352) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(348,352) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list')(348,352) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(352,353) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(353,354) + PsiWhiteSpace(' ')(354,355) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [[1, 1, 2], [2, 4, 8], [3, 9, 18], [4, 16, 32]]')(355,411) + PsiWhiteSpace('\n\n')(411,413) + OpenSCADFunctionDeclarationImpl(OPEN_SCAD_FUNCTION)(413,701) + PsiElement(OpenSCADTokenType.FUNCTION_KEYWORD)('function')(413,421) + PsiWhiteSpace(' ')(421,422) + PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(422,431) + OpenSCADArgDeclarationListImpl(ARG_DECLARATION_LIST)(431,436) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(431,432) + OpenSCADArgDeclarationImpl(ARG_DECLARATION)(432,435) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(432,435) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(435,436) + PsiWhiteSpace(' ')(436,437) + PsiElement(OpenSCADTokenType.EQUALS)('=')(437,438) + PsiWhiteSpace(' ')(438,439) + OpenSCADElvisExprImpl(ELVIS_EXPR)(439,700) + OpenSCADUnaryNegateExprImpl(UNARY_NEGATE_EXPR)(439,454) + PsiElement(OpenSCADTokenType.EXCL)('!')(439,440) + OpenSCADParenExprImpl(PAREN_EXPR)(440,454) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(440,441) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(441,453) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(441,449) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(441,444) + PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(441,444) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(444,449) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(444,445) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(445,448) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(445,448) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(445,448) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(448,449) + PsiWhiteSpace(' ')(449,450) + PsiElement(OpenSCADTokenType.GT)('>')(450,451) + PsiWhiteSpace(' ')(451,452) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(452,453) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(452,453) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(453,454) + PsiWhiteSpace(' ')(454,455) + PsiElement(OpenSCADTokenType.QUERY)('?')(455,456) + PsiWhiteSpace(' ')(456,457) + OpenSCADVectorExprImpl(VECTOR_EXPR)(457,459) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(457,458) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(458,459) + PsiWhiteSpace(' ')(459,460) + PsiElement(OpenSCADTokenType.COLON)(':')(460,461) + PsiWhiteSpace(' ')(461,462) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(462,700) + PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(462,465) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(465,647) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(465,466) + PsiWhiteSpace('\n ')(466,471) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(471,503) + PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(471,476) + PsiWhiteSpace(' ')(476,477) + PsiElement(OpenSCADTokenType.EQUALS)('=')(477,478) + PsiWhiteSpace(' ')(478,479) + OpenSCADIndexExprImpl(INDEX_EXPR)(479,503) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(479,482) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(479,482) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(482,483) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(483,502) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(483,488) + PsiElement(OpenSCADTokenType.FLOOR_KEYWORD)('floor')(483,488) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(488,502) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(488,489) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(489,501) + OpenSCADDivExprImpl(DIV_EXPR)(489,501) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(489,497) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(489,492) + PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(489,492) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(492,497) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(492,493) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(493,496) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(493,496) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(493,496) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(496,497) + PsiWhiteSpace(' ')(497,498) + PsiElement(OpenSCADTokenType.DIV)('/')(498,499) + PsiWhiteSpace(' ')(499,500) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(500,501) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(500,501) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(501,502) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(502,503) + PsiElement(OpenSCADTokenType.COMMA)(',')(503,504) + PsiWhiteSpace('\n ')(504,509) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(509,550) + PsiElement(OpenSCADTokenType.IDENTIFIER)('lesser')(509,515) + PsiWhiteSpace(' ')(515,516) + PsiElement(OpenSCADTokenType.EQUALS)('=')(516,517) + PsiWhiteSpace(' ')(517,518) + OpenSCADVectorExprImpl(VECTOR_EXPR)(518,550) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(518,519) + OpenSCADForElementImpl(FOR_ELEMENT)(519,532) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(519,522) + PsiWhiteSpace(' ')(522,523) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(523,532) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(523,524) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(524,531) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(524,525) + PsiWhiteSpace(' ')(525,526) + PsiElement(OpenSCADTokenType.EQUALS)('=')(526,527) + PsiWhiteSpace(' ')(527,528) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(528,531) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(528,531) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(531,532) + PsiWhiteSpace(' ')(532,533) + OpenSCADIfElementImpl(IF_ELEMENT)(533,547) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(533,535) + PsiWhiteSpace(' ')(535,536) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(536,537) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(537,546) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(537,538) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(537,538) + PsiWhiteSpace(' ')(538,539) + PsiElement(OpenSCADTokenType.LT)('<')(539,540) + PsiWhiteSpace(' ')(540,541) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(541,546) + PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(541,546) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(546,547) + PsiWhiteSpace(' ')(547,548) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(548,549) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(548,549) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(549,550) + PsiElement(OpenSCADTokenType.COMMA)(',')(550,551) + PsiWhiteSpace('\n ')(551,556) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(556,597) + PsiElement(OpenSCADTokenType.IDENTIFIER)('equal')(556,561) + PsiWhiteSpace(' ')(561,562) + PsiElement(OpenSCADTokenType.EQUALS)('=')(562,563) + PsiWhiteSpace(' ')(563,564) + OpenSCADVectorExprImpl(VECTOR_EXPR)(564,597) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(564,565) + OpenSCADForElementImpl(FOR_ELEMENT)(565,578) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(565,568) + PsiWhiteSpace(' ')(568,569) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(569,578) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(569,570) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(570,577) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(570,571) + PsiWhiteSpace(' ')(571,572) + PsiElement(OpenSCADTokenType.EQUALS)('=')(572,573) + PsiWhiteSpace(' ')(573,574) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(574,577) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(574,577) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(577,578) + PsiWhiteSpace(' ')(578,579) + OpenSCADIfElementImpl(IF_ELEMENT)(579,594) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(579,581) + PsiWhiteSpace(' ')(581,582) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(582,583) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(583,593) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(583,584) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(583,584) + PsiWhiteSpace(' ')(584,585) + PsiElement(OpenSCADTokenType.EQ)('==')(585,587) + PsiWhiteSpace(' ')(587,588) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(588,593) + PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(588,593) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(593,594) + PsiWhiteSpace(' ')(594,595) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(595,596) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(595,596) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(596,597) + PsiElement(OpenSCADTokenType.COMMA)(',')(597,598) + PsiWhiteSpace('\n ')(598,603) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(603,645) + PsiElement(OpenSCADTokenType.IDENTIFIER)('greater')(603,610) + PsiWhiteSpace(' ')(610,611) + PsiElement(OpenSCADTokenType.EQUALS)('=')(611,612) + PsiWhiteSpace(' ')(612,613) + OpenSCADVectorExprImpl(VECTOR_EXPR)(613,645) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(613,614) + OpenSCADForElementImpl(FOR_ELEMENT)(614,627) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(614,617) + PsiWhiteSpace(' ')(617,618) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(618,627) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(618,619) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(619,626) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(619,620) + PsiWhiteSpace(' ')(620,621) + PsiElement(OpenSCADTokenType.EQUALS)('=')(621,622) + PsiWhiteSpace(' ')(622,623) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(623,626) + PsiElement(OpenSCADTokenType.IDENTIFIER)('arr')(623,626) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(626,627) + PsiWhiteSpace(' ')(627,628) + OpenSCADIfElementImpl(IF_ELEMENT)(628,642) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(628,630) + PsiWhiteSpace(' ')(630,631) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(631,632) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(632,641) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(632,633) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(632,633) + PsiWhiteSpace(' ')(633,634) + PsiElement(OpenSCADTokenType.GT)('>')(634,635) + PsiWhiteSpace(' ')(635,636) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(636,641) + PsiElement(OpenSCADTokenType.IDENTIFIER)('pivot')(636,641) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(641,642) + PsiWhiteSpace(' ')(642,643) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(643,644) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(643,644) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(644,645) + PsiWhiteSpace('\n')(645,646) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(646,647) + PsiWhiteSpace(' ')(647,648) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(648,700) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(648,654) + PsiElement(OpenSCADTokenType.CONCAT_KEYWORD)('concat')(648,654) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(654,700) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(654,655) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(655,672) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(655,672) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(655,664) + PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(655,664) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(664,672) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(664,665) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(665,671) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(665,671) + PsiElement(OpenSCADTokenType.IDENTIFIER)('lesser')(665,671) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(671,672) + PsiElement(OpenSCADTokenType.COMMA)(',')(672,673) + PsiWhiteSpace(' ')(673,674) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(674,679) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(674,679) + PsiElement(OpenSCADTokenType.IDENTIFIER)('equal')(674,679) + PsiElement(OpenSCADTokenType.COMMA)(',')(679,680) + PsiWhiteSpace(' ')(680,681) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(681,699) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(681,699) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(681,690) + PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(681,690) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(690,699) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(690,691) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(691,698) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(691,698) + PsiElement(OpenSCADTokenType.IDENTIFIER)('greater')(691,698) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(698,699) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(699,700) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(700,701) + PsiWhiteSpace('\n\n')(701,703) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(703,750) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(703,707) + PsiWhiteSpace(' ')(707,708) + PsiElement(OpenSCADTokenType.EQUALS)('=')(708,709) + PsiWhiteSpace(' ')(709,710) + OpenSCADVectorExprImpl(VECTOR_EXPR)(710,749) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(710,711) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(711,712) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(711,712) + PsiElement(OpenSCADTokenType.COMMA)(',')(712,713) + PsiWhiteSpace(' ')(713,714) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(714,715) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(714,715) + PsiElement(OpenSCADTokenType.COMMA)(',')(715,716) + PsiWhiteSpace(' ')(716,717) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(717,718) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(717,718) + PsiElement(OpenSCADTokenType.COMMA)(',')(718,719) + PsiWhiteSpace(' ')(719,720) + OpenSCADVectorExprImpl(VECTOR_EXPR)(720,726) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(720,721) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(721,722) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(721,722) + PsiElement(OpenSCADTokenType.COMMA)(',')(722,723) + PsiWhiteSpace(' ')(723,724) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(724,725) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(724,725) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(725,726) + PsiElement(OpenSCADTokenType.COMMA)(',')(726,727) + PsiWhiteSpace(' ')(727,728) + OpenSCADVectorExprImpl(VECTOR_EXPR)(728,737) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(728,729) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(729,730) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(729,730) + PsiElement(OpenSCADTokenType.COMMA)(',')(730,731) + PsiWhiteSpace(' ')(731,732) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(732,733) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(732,733) + PsiElement(OpenSCADTokenType.COMMA)(',')(733,734) + PsiWhiteSpace(' ')(734,735) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(735,736) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(735,736) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(736,737) + PsiElement(OpenSCADTokenType.COMMA)(',')(737,738) + PsiWhiteSpace(' ')(738,739) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(739,748) + PsiElement(OpenSCADTokenType.IDENTIFIER)('quicksort')(739,748) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(748,749) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(749,750) + PsiWhiteSpace('\n')(750,751) + OpenSCADForObjImpl(FOR_OBJ)(751,948) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(751,754) + PsiWhiteSpace(' ')(754,755) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(755,768) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(755,756) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(756,767) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(756,757) + PsiWhiteSpace(' ')(757,758) + PsiElement(OpenSCADTokenType.EQUALS)('=')(758,759) + PsiWhiteSpace(' ')(759,760) + OpenSCADRangeExprImpl(RANGE_EXPR)(760,767) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(760,761) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(761,763) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(761,763) + PsiElement(OpenSCADTokenType.COLON)(':')(763,764) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(764,766) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('50')(764,766) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(766,767) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(767,768) + PsiWhiteSpace('\n')(768,769) + OpenSCADBlockObjImpl(BLOCK_OBJ)(769,948) + PsiElement(OpenSCADTokenType.LBRACE)('{')(769,770) + PsiWhiteSpace('\n ')(770,775) + OpenSCADForObjImpl(FOR_OBJ)(775,946) + PsiElement(OpenSCADTokenType.LET_KEYWORD)('let')(775,778) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(778,915) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(778,779) + PsiWhiteSpace('\n ')(779,788) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(788,800) + PsiElement(OpenSCADTokenType.IDENTIFIER)('size')(788,792) + PsiElement(OpenSCADTokenType.EQUALS)('=')(792,793) + OpenSCADIndexExprImpl(INDEX_EXPR)(793,800) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(793,797) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(793,797) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(797,798) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(798,799) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(798,799) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(799,800) + PsiElement(OpenSCADTokenType.COMMA)(',')(800,801) + PsiWhiteSpace(' ')(801,802) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(802,815) + PsiElement(OpenSCADTokenType.IDENTIFIER)('size2')(802,807) + PsiElement(OpenSCADTokenType.EQUALS)('=')(807,808) + OpenSCADIndexExprImpl(INDEX_EXPR)(808,815) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(808,812) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(808,812) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(812,813) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(813,814) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(813,814) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(814,815) + PsiElement(OpenSCADTokenType.COMMA)(',')(815,816) + PsiWhiteSpace('\n ')(816,825) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(825,847) + PsiElement(OpenSCADTokenType.IDENTIFIER)('shift')(825,830) + PsiElement(OpenSCADTokenType.EQUALS)('=')(830,831) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(831,847) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(831,838) + PsiElement(OpenSCADTokenType.IDENTIFIER)('point2d')(831,838) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(838,847) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(838,839) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(839,846) + OpenSCADIndexExprImpl(INDEX_EXPR)(839,846) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(839,843) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(839,843) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(843,844) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(844,845) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(844,845) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(845,846) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(846,847) + PsiElement(OpenSCADTokenType.COMMA)(',')(847,848) + PsiWhiteSpace(' ')(848,849) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(849,870) + PsiElement(OpenSCADTokenType.IDENTIFIER)('axis')(849,853) + PsiElement(OpenSCADTokenType.EQUALS)('=')(853,854) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(854,870) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(854,861) + PsiElement(OpenSCADTokenType.IDENTIFIER)('point3d')(854,861) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(861,870) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(861,862) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(862,869) + OpenSCADIndexExprImpl(INDEX_EXPR)(862,869) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(862,866) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(862,866) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(866,867) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(867,868) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(867,868) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(868,869) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(869,870) + PsiElement(OpenSCADTokenType.COMMA)(',')(870,871) + PsiWhiteSpace('\n ')(871,880) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(880,909) + PsiElement(OpenSCADTokenType.IDENTIFIER)('override')(880,888) + PsiWhiteSpace(' ')(888,889) + PsiElement(OpenSCADTokenType.EQUALS)('=')(889,890) + PsiWhiteSpace(' ')(890,891) + OpenSCADIndexExprImpl(INDEX_EXPR)(891,898) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(891,895) + PsiElement(OpenSCADTokenType.IDENTIFIER)('geom')(891,895) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(895,896) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(896,897) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(896,897) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(897,898) + OpenSCADParenExprImpl(PAREN_EXPR)(898,909) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(898,899) + OpenSCADVectorExprImpl(VECTOR_EXPR)(899,908) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(899,900) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(900,901) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(900,901) + PsiElement(OpenSCADTokenType.COMMA)(',')(901,902) + PsiWhiteSpace(' ')(902,903) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(903,904) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(903,904) + PsiElement(OpenSCADTokenType.COMMA)(',')(904,905) + PsiWhiteSpace(' ')(905,906) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(906,907) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(906,907) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(907,908) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(908,909) + PsiWhiteSpace('\n ')(909,914) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(914,915) + PsiWhiteSpace('\n ')(915,920) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(920,946) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(920,928) + PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(920,928) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(928,945) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(928,929) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(929,935) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(929,930) + PsiElement(OpenSCADTokenType.IDENTIFIER)('h')(929,930) + PsiElement(OpenSCADTokenType.EQUALS)('=')(930,931) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(931,935) + PsiElement(OpenSCADTokenType.IDENTIFIER)('size')(931,935) + PsiElement(OpenSCADTokenType.COMMA)(',')(935,936) + PsiWhiteSpace(' ')(936,937) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(937,944) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(937,938) + PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(937,938) + PsiElement(OpenSCADTokenType.EQUALS)('=')(938,939) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(939,944) + PsiElement(OpenSCADTokenType.IDENTIFIER)('size2')(939,944) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(944,945) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(945,946) + PsiWhiteSpace('\n')(946,947) + PsiElement(OpenSCADTokenType.RBRACE)('}')(947,948) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/base/types.scad b/src/test/testData/openscad/parser/base/types.scad index 545fc77..934e80b 100644 --- a/src/test/testData/openscad/parser/base/types.scad +++ b/src/test/testData/openscad/parser/base/types.scad @@ -23,6 +23,7 @@ logic = true; MyString = "This is a string"; a_vector = [1, 2, 3]; rr = a_vector[2]; // member of vector +rr2 = a_vector[logic ? 0: 1]; // selected member of vector range1 = [- 1.5:0.5:3]; // for() loop range xx = [0:5]; // alternate for() loop range p = pow(var, rr[0]); @@ -76,6 +77,7 @@ a = ["a", "b", "string"]; a = [[1, r], [x, y, z, 4, 5]]; a = [3, 5, [6, 7], [[8, 9], [10, [11, 12], 13], c, "string"]]; a = [4 / 3, 6 * 1.5, cos(60)]; +a = [(2*3+4)*b, b*(2*b)]; cube([width, depth, height]); // optional spaces shown for clarity translate([x, y, z]) @@ -87,16 +89,17 @@ a2 = [4, 5]; a3 = [6, 7, 8, 9]; b = [a1, a2, a3]; // [ [1,2,3], [4,5], [6,7,8,9] ] note increased nesting depth -a = e[5]; // element no 5 (sixth) at 1st nesting level -a = e[5][2]; // element 2 of element 5 2nd nesting level -a = e[5][2][0]; // element 0 of 2 of 5 3rd nesting level -a = e[5][2][0][1]; // element 1 of 0 of 2 of 5 4th nesting level - e = [[1], [], [3, 4, 5], "string", "x", [[10, 11], [12, 13, 14], [[15, 16], [17]]]]; // length 6 -a = e.x; //equivalent to e[0] -a = e.y; //equivalent to e[1] -a = e.z; //equivalent to e[2] +e_5 = e[5]; // element no 5 (sixth) at 1st nesting level +e_5_2 = e[5][2]; // element 2 of element 5 2nd nesting level +e_5_2_0 = e[5][2][0]; // element 0 of 2 of 5 3rd nesting level +e_5_2_0_1 = e[5][2][0][1]; // element 1 of 0 of 2 of 5 4th nesting level + +e_0 = e.x; //equivalent to e[0] +e_1 = e.y; //equivalent to e[1] +e_2 = e.z; //equivalent to e[2] +echo("e_0 = ", e_0, " e_1 = ", e_1, " e_2 = ", e_2); //Example which defines a 2D rotation matrix mr = [ @@ -119,4 +122,31 @@ sma = 20; // semi-minor axis smb = 30; // semi-major axis polygon( [for (a = [0 : 5 : 359]) [sma * sin(a), smb * cos(a)]] -); \ No newline at end of file +); + +// Optional parentheses around the body of the for loop in the vector item, or around the vector item +list_items = [ for(i=[0:1:2]) /* a comment */ echo(i)]; +list_items = [ for(i=[0:1:2]) /* a comment */ if (true) i]; +list_items = [ for(i=[0:1:2]) if (true) i]; +list_items = [ for(i=[0:1:2]) if (true) (i)]; +list_items = [ for(i=[0:1:2]) if (true) /* a comment */ + // + echo(i) echo(1) assert(true, "assert string") (i)]; +list_items = [ /* a comment */ for(i=[0:1:2]) /* a comment */ if (true) /* a comment */ i]; +list_items = [ for(i=[0:1:2]) if (true) /* a comment */ echo(i) echo(1) assert(true, "was true, returning i") (i)]; +list_items = [ for(i=[0:1:2]) if (true) /* a comment */ echo(i) echo(1) assert(true, "was true, just report")]; +echo(list_items); + +// ECHO: [0, 1, 2] +list_items_with_paren = [ ( for(i=[0:1:2]) if (true) i )]; +echo(list_items_with_paren); +// ECHO: [0, 1, 2] +list_items_with_paren_for_body = [ for(i=[0:1:2]) ( if (true) i )]; +echo(list_items_with_paren_for_body); +// ECHO: [0, 1, 2] +q = [for(i=[len(a)-1:-1:1]) a[i]*n, (a[0]-line[0])*n]; + +a = 2 + /* adfadf */ 3; + +// This next line will give an error +too_many_commas = [1,,2]; diff --git a/src/test/testData/openscad/parser/base/types_psidump.txt b/src/test/testData/openscad/parser/base/types_psidump.txt index a019a95..0ed77ed 100644 --- a/src/test/testData/openscad/parser/base/types_psidump.txt +++ b/src/test/testData/openscad/parser/base/types_psidump.txt @@ -1,6 +1,6 @@ -OpenSCAD File(0,3539) +OpenSCAD File(0,4867) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(0,8) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(0,4) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(0,4) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(0,4) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(4,7) PsiElement(OpenSCADTokenType.LPARENTH)('(')(4,5) @@ -37,7 +37,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.RPARENTH)(')')(29,30) PsiWhiteSpace(' ')(30,31) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(31,45) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(31,37) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(31,37) PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(31,37) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(37,44) PsiElement(OpenSCADTokenType.LPARENTH)('(')(37,38) @@ -54,7 +54,7 @@ OpenSCAD File(0,3539) PsiWhiteSpace('\n')(45,46) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(46,88) OpenSCADBuiltinOpImpl(BUILTIN_OP)(46,64) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(46,55) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(46,55) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(46,55) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(55,64) PsiElement(OpenSCADTokenType.LPARENTH)('(')(55,56) @@ -73,7 +73,7 @@ OpenSCAD File(0,3539) OpenSCADBlockObjImpl(BLOCK_OBJ)(65,88) PsiElement(OpenSCADTokenType.LBRACE)('{')(65,66) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(66,76) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(66,72) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(66,72) PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(66,72) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(72,75) PsiElement(OpenSCADTokenType.LPARENTH)('(')(72,73) @@ -84,7 +84,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(75,76) PsiWhiteSpace(' ')(76,77) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(77,87) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(77,83) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(77,83) PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(77,83) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(83,86) PsiElement(OpenSCADTokenType.LPARENTH)('(')(83,84) @@ -120,7 +120,7 @@ OpenSCAD File(0,3539) OpenSCADBlockObjImpl(BLOCK_OBJ)(113,136) PsiElement(OpenSCADTokenType.LBRACE)('{')(113,114) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(114,124) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(114,120) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(114,120) PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(114,120) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(120,123) PsiElement(OpenSCADTokenType.LPARENTH)('(')(120,121) @@ -131,7 +131,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(123,124) PsiWhiteSpace(' ')(124,125) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(125,135) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(125,131) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(125,131) PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(125,131) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(131,134) PsiElement(OpenSCADTokenType.LPARENTH)('(')(131,132) @@ -157,7 +157,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.LBRACE)('{')(151,152) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(152,183) OpenSCADBuiltinOpImpl(BUILTIN_OP)(152,172) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(152,161) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(152,161) PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(152,161) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(161,172) PsiElement(OpenSCADTokenType.LPARENTH)('(')(161,162) @@ -178,7 +178,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.RPARENTH)(')')(171,172) PsiWhiteSpace(' ')(172,173) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(173,183) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(173,179) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(173,179) PsiElement(OpenSCADTokenType.SPHERE_KEYWORD)('sphere')(173,179) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(179,182) PsiElement(OpenSCADTokenType.LPARENTH)('(')(179,180) @@ -213,7 +213,7 @@ OpenSCAD File(0,3539) OpenSCADBlockObjImpl(BLOCK_OBJ)(204,236) PsiElement(OpenSCADTokenType.LBRACE)('{')(204,205) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(205,218) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(205,213) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(205,213) PsiElement(OpenSCADTokenType.CYLINDER_KEYWORD)('cylinder')(205,213) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(213,217) PsiElement(OpenSCADTokenType.LPARENTH)('(')(213,214) @@ -224,7 +224,7 @@ OpenSCAD File(0,3539) PsiElement(OpenSCADTokenType.SEMICOLON)(';')(217,218) PsiWhiteSpace(' ')(218,219) OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(219,235) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(219,223) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(219,223) PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(219,223) OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(223,234) PsiElement(OpenSCADTokenType.LPARENTH)('(')(223,224) @@ -469,1511 +469,2306 @@ OpenSCAD File(0,3539) PsiWhiteSpace(' ')(622,628) PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// member of vector')(628,647) PsiWhiteSpace('\n')(647,648) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(648,671) - PsiElement(OpenSCADTokenType.IDENTIFIER)('range1')(648,654) - PsiWhiteSpace(' ')(654,655) - PsiElement(OpenSCADTokenType.EQUALS)('=')(655,656) - PsiWhiteSpace(' ')(656,657) - OpenSCADRangeExprImpl(RANGE_EXPR)(657,670) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(657,658) - OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(658,663) - PsiElement(OpenSCADTokenType.MINUS)('-')(658,659) - PsiWhiteSpace(' ')(659,660) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(660,663) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1.5')(660,663) - PsiElement(OpenSCADTokenType.COLON)(':')(663,664) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(664,667) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0.5')(664,667) - PsiElement(OpenSCADTokenType.COLON)(':')(667,668) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(668,669) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(668,669) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(669,670) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(670,671) - PsiWhiteSpace(' ')(671,672) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// for() loop range')(672,691) - PsiWhiteSpace('\n')(691,692) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(692,703) - PsiElement(OpenSCADTokenType.IDENTIFIER)('xx')(692,694) - PsiWhiteSpace(' ')(694,695) - PsiElement(OpenSCADTokenType.EQUALS)('=')(695,696) - PsiWhiteSpace(' ')(696,697) - OpenSCADRangeExprImpl(RANGE_EXPR)(697,702) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(697,698) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(698,699) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(698,699) - PsiElement(OpenSCADTokenType.COLON)(':')(699,700) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(700,701) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(700,701) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(701,702) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(702,703) - PsiWhiteSpace(' ')(703,715) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// alternate for() loop range')(715,744) - PsiWhiteSpace('\n')(744,745) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(745,765) - PsiElement(OpenSCADTokenType.IDENTIFIER)('p')(745,746) - PsiWhiteSpace(' ')(746,747) - PsiElement(OpenSCADTokenType.EQUALS)('=')(747,748) - PsiWhiteSpace(' ')(748,749) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(749,764) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(749,752) - PsiElement(OpenSCADTokenType.POW_KEYWORD)('pow')(749,752) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(752,764) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(752,753) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(753,756) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(753,756) - PsiElement(OpenSCADTokenType.IDENTIFIER)('var')(753,756) - PsiElement(OpenSCADTokenType.COMMA)(',')(756,757) - PsiWhiteSpace(' ')(757,758) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(758,763) - OpenSCADIndexExprImpl(INDEX_EXPR)(758,763) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(758,760) - PsiElement(OpenSCADTokenType.IDENTIFIER)('rr')(758,760) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(760,761) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(761,762) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(761,762) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(762,763) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(763,764) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(764,765) - PsiWhiteSpace('\n')(765,766) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(766,783) - PsiElement(OpenSCADTokenType.IDENTIFIER)('pp')(766,768) - PsiWhiteSpace(' ')(768,769) - PsiElement(OpenSCADTokenType.EQUALS)('=')(769,770) - PsiWhiteSpace(' ')(770,771) - OpenSCADPowerExprImpl(POWER_EXPR)(771,782) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(771,774) - PsiElement(OpenSCADTokenType.IDENTIFIER)('var')(771,774) - PsiWhiteSpace(' ')(774,775) - PsiElement(OpenSCADTokenType.EXP)('^')(775,776) - PsiWhiteSpace(' ')(776,777) - OpenSCADIndexExprImpl(INDEX_EXPR)(777,782) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(777,779) - PsiElement(OpenSCADTokenType.IDENTIFIER)('rr')(777,779) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(779,780) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(780,781) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(780,781) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(781,782) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(782,783) - PsiWhiteSpace('\n\n')(783,785) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(785,791) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(785,786) - PsiWhiteSpace(' ')(786,787) - PsiElement(OpenSCADTokenType.EQUALS)('=')(787,788) - PsiWhiteSpace(' ')(788,789) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(789,790) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(789,790) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(790,791) - PsiWhiteSpace('\n')(791,792) - OpenSCADIfObjImpl(IF_OBJ)(792,967) - PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(792,794) - PsiWhiteSpace(' ')(794,795) - OpenSCADParenExprImpl(PAREN_EXPR)(795,803) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(795,796) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(796,802) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(796,797) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(796,797) - PsiWhiteSpace(' ')(797,798) - PsiElement(OpenSCADTokenType.EQ)('==')(798,800) - PsiWhiteSpace(' ')(800,801) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(801,802) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(801,802) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(802,803) - PsiWhiteSpace('\n')(803,804) - OpenSCADBlockObjImpl(BLOCK_OBJ)(804,967) - PsiElement(OpenSCADTokenType.LBRACE)('{')(804,805) - PsiWhiteSpace('\n')(805,806) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(806,812) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(806,807) - PsiWhiteSpace(' ')(807,808) - PsiElement(OpenSCADTokenType.EQUALS)('=')(808,809) - PsiWhiteSpace(' ')(809,810) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(810,811) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(810,811) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(811,812) - PsiWhiteSpace(' ')(812,813) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// before 2015.03 this line would generate a Compile Error')(813,872) - PsiWhiteSpace('\n')(872,873) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// since 2015.03 no longer an error, but the value a=1 is confined to within the braces {}')(873,965) - PsiWhiteSpace('\n')(965,966) - PsiElement(OpenSCADTokenType.RBRACE)('}')(966,967) - PsiWhiteSpace('\n\n')(967,969) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(969,995) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(969,973) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(969,973) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(973,994) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(973,974) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(974,990) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(974,990) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Variable a is "')(974,990) - PsiElement(OpenSCADTokenType.COMMA)(',')(990,991) - PsiWhiteSpace(' ')(991,992) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(992,993) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(992,993) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(992,993) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(993,994) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(994,995) - PsiWhiteSpace(' ')(995,1011) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Variable a is undef')(1011,1033) - PsiWhiteSpace('\n')(1033,1034) - OpenSCADIfObjImpl(IF_OBJ)(1034,1127) - PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(1034,1036) - PsiWhiteSpace(' ')(1036,1037) - OpenSCADParenExprImpl(PAREN_EXPR)(1037,1049) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1037,1038) - OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(1038,1048) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1038,1039) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1038,1039) - PsiWhiteSpace(' ')(1039,1040) - PsiElement(OpenSCADTokenType.EQ)('==')(1040,1042) - PsiWhiteSpace(' ')(1042,1043) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1043,1048) - PsiElement(OpenSCADTokenType.UNDEF_KEYWORD)('undef')(1043,1048) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1048,1049) - PsiWhiteSpace(' ')(1049,1050) - OpenSCADBlockObjImpl(BLOCK_OBJ)(1050,1127) - PsiElement(OpenSCADTokenType.LBRACE)('{')(1050,1051) - PsiWhiteSpace('\n')(1051,1052) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1052,1091) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1052,1056) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1052,1056) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1056,1090) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1056,1057) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1057,1089) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1057,1089) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Variable a is tested undefined"')(1057,1089) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1089,1090) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1090,1091) - PsiWhiteSpace(' ')(1091,1092) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Variable a is tested undefined')(1092,1125) - PsiWhiteSpace('\n')(1125,1126) - PsiElement(OpenSCADTokenType.RBRACE)('}')(1126,1127) - PsiWhiteSpace('\n\n')(1127,1129) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1')(1129,1139) - PsiWhiteSpace('\n')(1139,1140) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1140,1146) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1140,1141) - PsiWhiteSpace(' ')(1141,1142) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1142,1143) - PsiWhiteSpace(' ')(1143,1144) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1144,1145) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(1144,1145) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1145,1146) - PsiWhiteSpace(' ')(1146,1162) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// create a')(1162,1173) - PsiWhiteSpace('\n')(1173,1174) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1174,1185) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1174,1178) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1174,1178) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1178,1184) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1178,1179) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1179,1180) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1179,1180) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1179,1180) - PsiElement(OpenSCADTokenType.COMMA)(',')(1180,1181) - PsiWhiteSpace(' ')(1181,1182) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1182,1183) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1182,1183) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1182,1183) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1183,1184) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1184,1185) - PsiWhiteSpace(' ')(1185,1197) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1197,1223) - PsiWhiteSpace('\n')(1223,1224) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1224,1597) - OpenSCADBuiltinOpImpl(BUILTIN_OP)(1224,1244) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1224,1233) - PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(1224,1233) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1233,1244) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1233,1234) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1234,1243) - OpenSCADVectorExprImpl(VECTOR_EXPR)(1234,1243) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(1234,1235) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1235,1236) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(1235,1236) - PsiElement(OpenSCADTokenType.COMMA)(',')(1236,1237) - PsiWhiteSpace(' ')(1237,1238) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1238,1239) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1238,1239) - PsiElement(OpenSCADTokenType.COMMA)(',')(1239,1240) - PsiWhiteSpace(' ')(1240,1241) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1241,1242) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1241,1242) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(1242,1243) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1243,1244) - PsiWhiteSpace(' ')(1244,1245) - OpenSCADBlockObjImpl(BLOCK_OBJ)(1245,1597) - PsiElement(OpenSCADTokenType.LBRACE)('{')(1245,1246) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.1')(1246,1258) - PsiWhiteSpace('\n')(1258,1259) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1259,1266) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1259,1260) - PsiWhiteSpace(' ')(1260,1261) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1261,1262) - PsiWhiteSpace(' ')(1262,1263) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1263,1265) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(1263,1265) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1265,1266) - PsiWhiteSpace('\n')(1266,1267) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1267,1274) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1267,1268) - PsiWhiteSpace(' ')(1268,1269) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1269,1270) - PsiWhiteSpace(' ')(1270,1271) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1271,1273) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('16')(1271,1273) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1273,1274) - PsiWhiteSpace(' ')(1274,1288) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// create b')(1288,1299) - PsiWhiteSpace('\n')(1299,1300) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1300,1311) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1300,1304) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1300,1304) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1304,1310) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1304,1305) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1305,1306) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1305,1306) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1305,1306) - PsiElement(OpenSCADTokenType.COMMA)(',')(1306,1307) - PsiWhiteSpace(' ')(1307,1308) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1308,1309) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1308,1309) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1308,1309) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1309,1310) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1310,1311) - PsiWhiteSpace(' ')(1311,1321) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 16 a=10; was overridden by later a=100;')(1321,1383) - PsiWhiteSpace('\n')(1383,1384) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1384,1474) - OpenSCADBuiltinOpImpl(BUILTIN_OP)(1384,1397) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1384,1389) - PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(1384,1389) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1389,1397) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1389,1390) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1390,1396) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1390,1396) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"blue"')(1390,1396) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1396,1397) - PsiWhiteSpace(' ')(1397,1398) - OpenSCADBlockObjImpl(BLOCK_OBJ)(1398,1474) - PsiElement(OpenSCADTokenType.LBRACE)('{')(1398,1399) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.1.1')(1399,1413) - PsiWhiteSpace('\n')(1413,1414) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1414,1425) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1414,1418) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1414,1418) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1418,1424) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1418,1419) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1419,1420) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1419,1420) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1419,1420) - PsiElement(OpenSCADTokenType.COMMA)(',')(1420,1421) - PsiWhiteSpace(' ')(1421,1422) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1422,1423) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1422,1423) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1422,1423) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1423,1424) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1424,1425) - PsiWhiteSpace(' ')(1425,1433) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 20')(1433,1456) - PsiWhiteSpace('\n')(1456,1457) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1457,1464) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1457,1461) - PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(1457,1461) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1461,1463) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1461,1462) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1462,1463) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1463,1464) - PsiWhiteSpace('\n')(1464,1465) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1465,1472) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1465,1466) - PsiWhiteSpace(' ')(1466,1467) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1467,1468) - PsiWhiteSpace(' ')(1468,1469) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1469,1471) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(1469,1471) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1471,1472) - PsiWhiteSpace('\n')(1472,1473) - PsiElement(OpenSCADTokenType.RBRACE)('}')(1473,1474) - PsiWhiteSpace(' ')(1474,1493) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1.1')(1493,1507) - PsiWhiteSpace('\n')(1507,1508) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1508,1519) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1508,1512) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1508,1512) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1512,1518) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1512,1513) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1513,1514) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1513,1514) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1513,1514) - PsiElement(OpenSCADTokenType.COMMA)(',')(1514,1515) - PsiWhiteSpace(' ')(1515,1516) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1516,1517) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1516,1517) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1516,1517) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1517,1518) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1518,1519) - PsiWhiteSpace(' ')(1519,1529) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 16')(1529,1552) - PsiWhiteSpace('\n')(1552,1553) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1553,1561) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1553,1554) - PsiWhiteSpace(' ')(1554,1555) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1555,1556) - PsiWhiteSpace(' ')(1556,1557) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1557,1560) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('100')(1557,1560) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1560,1561) - PsiWhiteSpace(' ')(1561,1575) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// override a in 1.1')(1575,1595) - PsiWhiteSpace('\n')(1595,1596) - PsiElement(OpenSCADTokenType.RBRACE)('}')(1596,1597) - PsiWhiteSpace(' ')(1597,1618) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1')(1618,1630) - PsiWhiteSpace('\n')(1630,1631) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1631,1642) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1631,1635) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1631,1635) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1635,1641) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1635,1636) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1636,1637) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1636,1637) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1636,1637) - PsiElement(OpenSCADTokenType.COMMA)(',')(1637,1638) - PsiWhiteSpace(' ')(1638,1639) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1639,1640) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1639,1640) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1639,1640) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1640,1641) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1641,1642) - PsiWhiteSpace(' ')(1642,1654) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1654,1680) - PsiWhiteSpace('\n')(1680,1681) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1681,1765) - OpenSCADBuiltinOpImpl(BUILTIN_OP)(1681,1693) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1681,1686) - PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(1681,1686) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1686,1693) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1686,1687) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1687,1692) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1687,1692) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"red"')(1687,1692) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1692,1693) - PsiWhiteSpace(' ')(1693,1694) - OpenSCADBlockObjImpl(BLOCK_OBJ)(1694,1765) - PsiElement(OpenSCADTokenType.LBRACE)('{')(1694,1695) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.2')(1695,1707) - PsiWhiteSpace('\n')(1707,1708) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1708,1715) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1708,1712) - PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(1708,1712) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1712,1714) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1712,1713) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1713,1714) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1714,1715) - PsiWhiteSpace('\n')(1715,1716) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1716,1727) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1716,1720) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1716,1720) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1720,1726) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1720,1721) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1721,1722) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1721,1722) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1721,1722) - PsiElement(OpenSCADTokenType.COMMA)(',')(1722,1723) - PsiWhiteSpace(' ')(1723,1724) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1724,1725) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1724,1725) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1724,1725) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1725,1726) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1726,1727) - PsiWhiteSpace(' ')(1727,1737) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1737,1763) - PsiWhiteSpace('\n')(1763,1764) - PsiElement(OpenSCADTokenType.RBRACE)('}')(1764,1765) - PsiWhiteSpace(' ')(1765,1786) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1')(1786,1798) - PsiWhiteSpace('\n')(1798,1799) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1799,1810) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1799,1803) - PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1799,1803) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1803,1809) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1803,1804) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1804,1805) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1804,1805) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1804,1805) - PsiElement(OpenSCADTokenType.COMMA)(',')(1805,1806) - PsiWhiteSpace(' ')(1806,1807) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1807,1808) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1807,1808) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1807,1808) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1808,1809) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1809,1810) - PsiWhiteSpace(' ')(1810,1822) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1822,1848) - PsiWhiteSpace('\n')(1848,1849) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//In this example, scopes 1 and 1.1 are outer scopes to 1.1.1 but 1.2 is not.')(1849,1926) - PsiWhiteSpace('\n\n')(1926,1928) - OpenSCADBlockObjImpl(BLOCK_OBJ)(1928,1943) - PsiElement(OpenSCADTokenType.LBRACE)('{')(1928,1929) - PsiWhiteSpace('\n')(1929,1930) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1930,1941) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(1930,1935) - PsiWhiteSpace(' ')(1935,1936) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1936,1937) - PsiWhiteSpace(' ')(1937,1938) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1938,1940) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('45')(1938,1940) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1940,1941) - PsiWhiteSpace('\n')(1941,1942) - PsiElement(OpenSCADTokenType.RBRACE)('}')(1942,1943) - PsiWhiteSpace('\n')(1943,1944) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1944,1969) - OpenSCADBuiltinOpImpl(BUILTIN_OP)(1944,1957) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1944,1950) - PsiElement(OpenSCADTokenType.ROTATE_KEYWORD)('rotate')(1944,1950) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1950,1957) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1950,1951) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1951,1956) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1951,1956) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(1951,1956) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1956,1957) - PsiWhiteSpace(' ')(1957,1958) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1958,1969) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1958,1964) - PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(1958,1964) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1964,1968) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(1964,1965) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1965,1967) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1965,1967) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(1965,1967) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(1967,1968) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1968,1969) - PsiWhiteSpace('\n\n')(1969,1971) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1971,1985) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1971,1972) - PsiWhiteSpace(' ')(1972,1973) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1973,1974) - PsiWhiteSpace(' ')(1974,1975) - OpenSCADVectorExprImpl(VECTOR_EXPR)(1975,1984) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(1975,1976) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1976,1977) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(1976,1977) - PsiElement(OpenSCADTokenType.COMMA)(',')(1977,1978) - PsiWhiteSpace(' ')(1978,1979) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1979,1980) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(1979,1980) - PsiElement(OpenSCADTokenType.COMMA)(',')(1980,1981) - PsiWhiteSpace(' ')(1981,1982) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1982,1983) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(1982,1983) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(1983,1984) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1984,1985) - PsiWhiteSpace('\n')(1985,1986) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1986,2000) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1986,1987) - PsiWhiteSpace(' ')(1987,1988) - PsiElement(OpenSCADTokenType.EQUALS)('=')(1988,1989) - PsiWhiteSpace(' ')(1989,1990) - OpenSCADVectorExprImpl(VECTOR_EXPR)(1990,1999) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(1990,1991) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1991,1992) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1991,1992) - PsiElement(OpenSCADTokenType.COMMA)(',')(1992,1993) - PsiWhiteSpace(' ')(1993,1994) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(1994,1995) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(1994,1995) - PsiElement(OpenSCADTokenType.COMMA)(',')(1995,1996) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(648,677) + PsiElement(OpenSCADTokenType.IDENTIFIER)('rr2')(648,651) + PsiWhiteSpace(' ')(651,652) + PsiElement(OpenSCADTokenType.EQUALS)('=')(652,653) + PsiWhiteSpace(' ')(653,654) + OpenSCADIndexExprImpl(INDEX_EXPR)(654,676) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(654,662) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a_vector')(654,662) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(662,663) + OpenSCADElvisExprImpl(ELVIS_EXPR)(663,675) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(663,668) + PsiElement(OpenSCADTokenType.IDENTIFIER)('logic')(663,668) + PsiWhiteSpace(' ')(668,669) + PsiElement(OpenSCADTokenType.QUERY)('?')(669,670) + PsiWhiteSpace(' ')(670,671) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(671,672) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(671,672) + PsiElement(OpenSCADTokenType.COLON)(':')(672,673) + PsiWhiteSpace(' ')(673,674) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(674,675) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(674,675) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(675,676) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(676,677) + PsiWhiteSpace(' ')(677,680) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// selected member of vector')(680,708) + PsiWhiteSpace('\n')(708,709) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(709,732) + PsiElement(OpenSCADTokenType.IDENTIFIER)('range1')(709,715) + PsiWhiteSpace(' ')(715,716) + PsiElement(OpenSCADTokenType.EQUALS)('=')(716,717) + PsiWhiteSpace(' ')(717,718) + OpenSCADRangeExprImpl(RANGE_EXPR)(718,731) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(718,719) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(719,724) + PsiElement(OpenSCADTokenType.MINUS)('-')(719,720) + PsiWhiteSpace(' ')(720,721) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(721,724) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1.5')(721,724) + PsiElement(OpenSCADTokenType.COLON)(':')(724,725) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(725,728) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0.5')(725,728) + PsiElement(OpenSCADTokenType.COLON)(':')(728,729) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(729,730) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(729,730) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(730,731) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(731,732) + PsiWhiteSpace(' ')(732,733) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// for() loop range')(733,752) + PsiWhiteSpace('\n')(752,753) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(753,764) + PsiElement(OpenSCADTokenType.IDENTIFIER)('xx')(753,755) + PsiWhiteSpace(' ')(755,756) + PsiElement(OpenSCADTokenType.EQUALS)('=')(756,757) + PsiWhiteSpace(' ')(757,758) + OpenSCADRangeExprImpl(RANGE_EXPR)(758,763) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(758,759) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(759,760) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(759,760) + PsiElement(OpenSCADTokenType.COLON)(':')(760,761) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(761,762) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(761,762) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(762,763) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(763,764) + PsiWhiteSpace(' ')(764,776) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// alternate for() loop range')(776,805) + PsiWhiteSpace('\n')(805,806) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(806,826) + PsiElement(OpenSCADTokenType.IDENTIFIER)('p')(806,807) + PsiWhiteSpace(' ')(807,808) + PsiElement(OpenSCADTokenType.EQUALS)('=')(808,809) + PsiWhiteSpace(' ')(809,810) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(810,825) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(810,813) + PsiElement(OpenSCADTokenType.POW_KEYWORD)('pow')(810,813) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(813,825) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(813,814) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(814,817) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(814,817) + PsiElement(OpenSCADTokenType.IDENTIFIER)('var')(814,817) + PsiElement(OpenSCADTokenType.COMMA)(',')(817,818) + PsiWhiteSpace(' ')(818,819) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(819,824) + OpenSCADIndexExprImpl(INDEX_EXPR)(819,824) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(819,821) + PsiElement(OpenSCADTokenType.IDENTIFIER)('rr')(819,821) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(821,822) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(822,823) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(822,823) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(823,824) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(824,825) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(825,826) + PsiWhiteSpace('\n')(826,827) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(827,844) + PsiElement(OpenSCADTokenType.IDENTIFIER)('pp')(827,829) + PsiWhiteSpace(' ')(829,830) + PsiElement(OpenSCADTokenType.EQUALS)('=')(830,831) + PsiWhiteSpace(' ')(831,832) + OpenSCADPowerExprImpl(POWER_EXPR)(832,843) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(832,835) + PsiElement(OpenSCADTokenType.IDENTIFIER)('var')(832,835) + PsiWhiteSpace(' ')(835,836) + PsiElement(OpenSCADTokenType.EXP)('^')(836,837) + PsiWhiteSpace(' ')(837,838) + OpenSCADIndexExprImpl(INDEX_EXPR)(838,843) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(838,840) + PsiElement(OpenSCADTokenType.IDENTIFIER)('rr')(838,840) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(840,841) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(841,842) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(841,842) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(842,843) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(843,844) + PsiWhiteSpace('\n\n')(844,846) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(846,852) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(846,847) + PsiWhiteSpace(' ')(847,848) + PsiElement(OpenSCADTokenType.EQUALS)('=')(848,849) + PsiWhiteSpace(' ')(849,850) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(850,851) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(850,851) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(851,852) + PsiWhiteSpace('\n')(852,853) + OpenSCADIfObjImpl(IF_OBJ)(853,1028) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(853,855) + PsiWhiteSpace(' ')(855,856) + OpenSCADParenExprImpl(PAREN_EXPR)(856,864) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(856,857) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(857,863) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(857,858) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(857,858) + PsiWhiteSpace(' ')(858,859) + PsiElement(OpenSCADTokenType.EQ)('==')(859,861) + PsiWhiteSpace(' ')(861,862) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(862,863) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(862,863) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(863,864) + PsiWhiteSpace('\n')(864,865) + OpenSCADBlockObjImpl(BLOCK_OBJ)(865,1028) + PsiElement(OpenSCADTokenType.LBRACE)('{')(865,866) + PsiWhiteSpace('\n')(866,867) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(867,873) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(867,868) + PsiWhiteSpace(' ')(868,869) + PsiElement(OpenSCADTokenType.EQUALS)('=')(869,870) + PsiWhiteSpace(' ')(870,871) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(871,872) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(871,872) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(872,873) + PsiWhiteSpace(' ')(873,874) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// before 2015.03 this line would generate a Compile Error')(874,933) + PsiWhiteSpace('\n')(933,934) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// since 2015.03 no longer an error, but the value a=1 is confined to within the braces {}')(934,1026) + PsiWhiteSpace('\n')(1026,1027) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1027,1028) + PsiWhiteSpace('\n\n')(1028,1030) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1030,1056) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1030,1034) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1030,1034) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1034,1055) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1034,1035) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1035,1051) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1035,1051) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Variable a is "')(1035,1051) + PsiElement(OpenSCADTokenType.COMMA)(',')(1051,1052) + PsiWhiteSpace(' ')(1052,1053) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1053,1054) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1053,1054) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1053,1054) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1054,1055) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1055,1056) + PsiWhiteSpace(' ')(1056,1072) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Variable a is undef')(1072,1094) + PsiWhiteSpace('\n')(1094,1095) + OpenSCADIfObjImpl(IF_OBJ)(1095,1188) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(1095,1097) + PsiWhiteSpace(' ')(1097,1098) + OpenSCADParenExprImpl(PAREN_EXPR)(1098,1110) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1098,1099) + OpenSCADConditionalExprImpl(CONDITIONAL_EXPR)(1099,1109) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1099,1100) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1099,1100) + PsiWhiteSpace(' ')(1100,1101) + PsiElement(OpenSCADTokenType.EQ)('==')(1101,1103) + PsiWhiteSpace(' ')(1103,1104) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1104,1109) + PsiElement(OpenSCADTokenType.UNDEF_KEYWORD)('undef')(1104,1109) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1109,1110) + PsiWhiteSpace(' ')(1110,1111) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1111,1188) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1111,1112) + PsiWhiteSpace('\n')(1112,1113) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1113,1152) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1113,1117) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1113,1117) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1117,1151) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1117,1118) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1118,1150) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1118,1150) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"Variable a is tested undefined"')(1118,1150) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1150,1151) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1151,1152) + PsiWhiteSpace(' ')(1152,1153) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Variable a is tested undefined')(1153,1186) + PsiWhiteSpace('\n')(1186,1187) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1187,1188) + PsiWhiteSpace('\n\n')(1188,1190) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1')(1190,1200) + PsiWhiteSpace('\n')(1200,1201) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1201,1207) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1201,1202) + PsiWhiteSpace(' ')(1202,1203) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1203,1204) + PsiWhiteSpace(' ')(1204,1205) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1205,1206) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(1205,1206) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1206,1207) + PsiWhiteSpace(' ')(1207,1223) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// create a')(1223,1234) + PsiWhiteSpace('\n')(1234,1235) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1235,1246) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1235,1239) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1235,1239) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1239,1245) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1239,1240) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1240,1241) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1240,1241) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1240,1241) + PsiElement(OpenSCADTokenType.COMMA)(',')(1241,1242) + PsiWhiteSpace(' ')(1242,1243) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1243,1244) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1243,1244) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1243,1244) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1244,1245) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1245,1246) + PsiWhiteSpace(' ')(1246,1258) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1258,1284) + PsiWhiteSpace('\n')(1284,1285) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1285,1658) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(1285,1305) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(1285,1294) + PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(1285,1294) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1294,1305) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1294,1295) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1295,1304) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1295,1304) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1295,1296) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1296,1297) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(1296,1297) + PsiElement(OpenSCADTokenType.COMMA)(',')(1297,1298) + PsiWhiteSpace(' ')(1298,1299) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1299,1300) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1299,1300) + PsiElement(OpenSCADTokenType.COMMA)(',')(1300,1301) + PsiWhiteSpace(' ')(1301,1302) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1302,1303) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1302,1303) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1303,1304) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1304,1305) + PsiWhiteSpace(' ')(1305,1306) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1306,1658) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1306,1307) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.1')(1307,1319) + PsiWhiteSpace('\n')(1319,1320) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1320,1327) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1320,1321) + PsiWhiteSpace(' ')(1321,1322) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1322,1323) + PsiWhiteSpace(' ')(1323,1324) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1324,1326) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(1324,1326) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1326,1327) + PsiWhiteSpace('\n')(1327,1328) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1328,1335) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1328,1329) + PsiWhiteSpace(' ')(1329,1330) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1330,1331) + PsiWhiteSpace(' ')(1331,1332) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1332,1334) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('16')(1332,1334) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1334,1335) + PsiWhiteSpace(' ')(1335,1349) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// create b')(1349,1360) + PsiWhiteSpace('\n')(1360,1361) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1361,1372) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1361,1365) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1361,1365) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1365,1371) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1365,1366) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1366,1367) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1366,1367) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1366,1367) + PsiElement(OpenSCADTokenType.COMMA)(',')(1367,1368) + PsiWhiteSpace(' ')(1368,1369) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1369,1370) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1369,1370) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1369,1370) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1370,1371) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1371,1372) + PsiWhiteSpace(' ')(1372,1382) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 16 a=10; was overridden by later a=100;')(1382,1444) + PsiWhiteSpace('\n')(1444,1445) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1445,1535) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(1445,1458) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1445,1450) + PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(1445,1450) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1450,1458) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1450,1451) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1451,1457) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1451,1457) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"blue"')(1451,1457) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1457,1458) + PsiWhiteSpace(' ')(1458,1459) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1459,1535) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1459,1460) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.1.1')(1460,1474) + PsiWhiteSpace('\n')(1474,1475) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1475,1486) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1475,1479) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1475,1479) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1479,1485) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1479,1480) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1480,1481) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1480,1481) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1480,1481) + PsiElement(OpenSCADTokenType.COMMA)(',')(1481,1482) + PsiWhiteSpace(' ')(1482,1483) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1483,1484) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1483,1484) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1483,1484) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1484,1485) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1485,1486) + PsiWhiteSpace(' ')(1486,1494) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 20')(1494,1517) + PsiWhiteSpace('\n')(1517,1518) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1518,1525) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(1518,1522) + PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(1518,1522) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1522,1524) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1522,1523) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1523,1524) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1524,1525) + PsiWhiteSpace('\n')(1525,1526) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1526,1533) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1526,1527) + PsiWhiteSpace(' ')(1527,1528) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1528,1529) + PsiWhiteSpace(' ')(1529,1530) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1530,1532) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(1530,1532) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1532,1533) + PsiWhiteSpace('\n')(1533,1534) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1534,1535) + PsiWhiteSpace(' ')(1535,1554) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1.1')(1554,1568) + PsiWhiteSpace('\n')(1568,1569) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1569,1580) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1569,1573) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1569,1573) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1573,1579) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1573,1574) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1574,1575) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1574,1575) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1574,1575) + PsiElement(OpenSCADTokenType.COMMA)(',')(1575,1576) + PsiWhiteSpace(' ')(1576,1577) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1577,1578) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1577,1578) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1577,1578) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1578,1579) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1579,1580) + PsiWhiteSpace(' ')(1580,1590) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 100, 16')(1590,1613) + PsiWhiteSpace('\n')(1613,1614) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1614,1622) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1614,1615) + PsiWhiteSpace(' ')(1615,1616) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1616,1617) + PsiWhiteSpace(' ')(1617,1618) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1618,1621) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('100')(1618,1621) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1621,1622) + PsiWhiteSpace(' ')(1622,1636) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// override a in 1.1')(1636,1656) + PsiWhiteSpace('\n')(1656,1657) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1657,1658) + PsiWhiteSpace(' ')(1658,1679) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1')(1679,1691) + PsiWhiteSpace('\n')(1691,1692) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1692,1703) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1692,1696) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1692,1696) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1696,1702) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1696,1697) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1697,1698) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1697,1698) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1697,1698) + PsiElement(OpenSCADTokenType.COMMA)(',')(1698,1699) + PsiWhiteSpace(' ')(1699,1700) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1700,1701) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1700,1701) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1700,1701) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1701,1702) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1702,1703) + PsiWhiteSpace(' ')(1703,1715) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1715,1741) + PsiWhiteSpace('\n')(1741,1742) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1742,1826) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(1742,1754) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1742,1747) + PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(1742,1747) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1747,1754) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1747,1748) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1748,1753) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1748,1753) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"red"')(1748,1753) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1753,1754) + PsiWhiteSpace(' ')(1754,1755) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1755,1826) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1755,1756) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// scope 1.2')(1756,1768) + PsiWhiteSpace('\n')(1768,1769) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1769,1776) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(1769,1773) + PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(1769,1773) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1773,1775) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1773,1774) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1774,1775) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1775,1776) + PsiWhiteSpace('\n')(1776,1777) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1777,1788) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1777,1781) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1777,1781) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1781,1787) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1781,1782) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1782,1783) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1782,1783) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1782,1783) + PsiElement(OpenSCADTokenType.COMMA)(',')(1783,1784) + PsiWhiteSpace(' ')(1784,1785) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1785,1786) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1785,1786) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1785,1786) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1786,1787) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1787,1788) + PsiWhiteSpace(' ')(1788,1798) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1798,1824) + PsiWhiteSpace('\n')(1824,1825) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1825,1826) + PsiWhiteSpace(' ')(1826,1847) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// back to 1')(1847,1859) + PsiWhiteSpace('\n')(1859,1860) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1860,1871) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(1860,1864) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(1860,1864) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1864,1870) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1864,1865) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1865,1866) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1865,1866) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(1865,1866) + PsiElement(OpenSCADTokenType.COMMA)(',')(1866,1867) + PsiWhiteSpace(' ')(1867,1868) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1868,1869) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1868,1869) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1868,1869) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1869,1870) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1870,1871) + PsiWhiteSpace(' ')(1871,1883) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// 6, undef')(1883,1909) + PsiWhiteSpace('\n')(1909,1910) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//In this example, scopes 1 and 1.1 are outer scopes to 1.1.1 but 1.2 is not.')(1910,1987) + PsiWhiteSpace('\n\n')(1987,1989) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1989,2004) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1989,1990) + PsiWhiteSpace('\n')(1990,1991) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(1991,2002) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(1991,1996) PsiWhiteSpace(' ')(1996,1997) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1997,1998) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(1997,1998) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(1998,1999) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1999,2000) - PsiWhiteSpace('\n')(2000,2001) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2001,2008) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2001,2002) - PsiWhiteSpace(' ')(2002,2003) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2003,2004) - PsiWhiteSpace(' ')(2004,2005) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2005,2007) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2005,2006) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2006,2007) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2007,2008) - PsiWhiteSpace('\n')(2008,2009) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2009,2021) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2009,2010) - PsiWhiteSpace(' ')(2010,2011) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2011,2012) - PsiWhiteSpace(' ')(2012,2013) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2013,2020) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2013,2014) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2014,2019) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5.643')(2014,2019) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2019,2020) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2020,2021) - PsiWhiteSpace('\n')(2021,2022) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2022,2047) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2022,2023) - PsiWhiteSpace(' ')(2023,2024) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2024,2025) - PsiWhiteSpace(' ')(2025,2026) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2026,2046) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2026,2027) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2027,2030) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"a"')(2027,2030) - PsiElement(OpenSCADTokenType.COMMA)(',')(2030,2031) - PsiWhiteSpace(' ')(2031,2032) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2032,2035) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"b"')(2032,2035) - PsiElement(OpenSCADTokenType.COMMA)(',')(2035,2036) - PsiWhiteSpace(' ')(2036,2037) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2037,2045) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2037,2045) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2045,2046) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2046,2047) - PsiWhiteSpace('\n')(2047,2048) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2048,2078) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2048,2049) - PsiWhiteSpace(' ')(2049,2050) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2050,2051) - PsiWhiteSpace(' ')(2051,2052) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2052,2077) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2052,2053) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2053,2059) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2053,2054) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2054,2055) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2054,2055) - PsiElement(OpenSCADTokenType.COMMA)(',')(2055,2056) - PsiWhiteSpace(' ')(2056,2057) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2057,2058) - PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(2057,2058) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2058,2059) - PsiElement(OpenSCADTokenType.COMMA)(',')(2059,2060) - PsiWhiteSpace(' ')(2060,2061) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2061,2076) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2061,2062) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2062,2063) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2062,2063) - PsiElement(OpenSCADTokenType.COMMA)(',')(2063,2064) - PsiWhiteSpace(' ')(2064,2065) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2065,2066) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2065,2066) - PsiElement(OpenSCADTokenType.COMMA)(',')(2066,2067) - PsiWhiteSpace(' ')(2067,2068) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2068,2069) - PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(2068,2069) - PsiElement(OpenSCADTokenType.COMMA)(',')(2069,2070) - PsiWhiteSpace(' ')(2070,2071) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2071,2072) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2071,2072) - PsiElement(OpenSCADTokenType.COMMA)(',')(2072,2073) - PsiWhiteSpace(' ')(2073,2074) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2074,2075) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2074,2075) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2075,2076) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2076,2077) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2077,2078) - PsiWhiteSpace('\n')(2078,2079) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2079,2141) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2079,2080) - PsiWhiteSpace(' ')(2080,2081) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2081,2082) - PsiWhiteSpace(' ')(2082,2083) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2083,2140) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2083,2084) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2084,2085) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2084,2085) - PsiElement(OpenSCADTokenType.COMMA)(',')(2085,2086) - PsiWhiteSpace(' ')(2086,2087) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2087,2088) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2087,2088) - PsiElement(OpenSCADTokenType.COMMA)(',')(2088,2089) - PsiWhiteSpace(' ')(2089,2090) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2090,2096) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2090,2091) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2091,2092) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2091,2092) - PsiElement(OpenSCADTokenType.COMMA)(',')(2092,2093) - PsiWhiteSpace(' ')(2093,2094) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2094,2095) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('7')(2094,2095) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2095,2096) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1997,1998) + PsiWhiteSpace(' ')(1998,1999) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1999,2001) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('45')(1999,2001) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2001,2002) + PsiWhiteSpace('\n')(2002,2003) + PsiElement(OpenSCADTokenType.RBRACE)('}')(2003,2004) + PsiWhiteSpace('\n')(2004,2005) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2005,2030) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(2005,2018) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(2005,2011) + PsiElement(OpenSCADTokenType.ROTATE_KEYWORD)('rotate')(2005,2011) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2011,2018) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2011,2012) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2012,2017) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2012,2017) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(2012,2017) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2017,2018) + PsiWhiteSpace(' ')(2018,2019) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2019,2030) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(2019,2025) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(2019,2025) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2025,2029) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2025,2026) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2026,2028) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2026,2028) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2026,2028) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2028,2029) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2029,2030) + PsiWhiteSpace('\n\n')(2030,2032) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2032,2046) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2032,2033) + PsiWhiteSpace(' ')(2033,2034) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2034,2035) + PsiWhiteSpace(' ')(2035,2036) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2036,2045) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2036,2037) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2037,2038) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2037,2038) + PsiElement(OpenSCADTokenType.COMMA)(',')(2038,2039) + PsiWhiteSpace(' ')(2039,2040) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2040,2041) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2040,2041) + PsiElement(OpenSCADTokenType.COMMA)(',')(2041,2042) + PsiWhiteSpace(' ')(2042,2043) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2043,2044) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2043,2044) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2044,2045) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2045,2046) + PsiWhiteSpace('\n')(2046,2047) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2047,2061) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2047,2048) + PsiWhiteSpace(' ')(2048,2049) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2049,2050) + PsiWhiteSpace(' ')(2050,2051) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2051,2060) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2051,2052) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2052,2053) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2052,2053) + PsiElement(OpenSCADTokenType.COMMA)(',')(2053,2054) + PsiWhiteSpace(' ')(2054,2055) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2055,2056) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2055,2056) + PsiElement(OpenSCADTokenType.COMMA)(',')(2056,2057) + PsiWhiteSpace(' ')(2057,2058) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2058,2059) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2058,2059) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2059,2060) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2060,2061) + PsiWhiteSpace('\n')(2061,2062) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2062,2069) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2062,2063) + PsiWhiteSpace(' ')(2063,2064) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2064,2065) + PsiWhiteSpace(' ')(2065,2066) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2066,2068) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2066,2067) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2067,2068) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2068,2069) + PsiWhiteSpace('\n')(2069,2070) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2070,2082) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2070,2071) + PsiWhiteSpace(' ')(2071,2072) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2072,2073) + PsiWhiteSpace(' ')(2073,2074) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2074,2081) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2074,2075) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2075,2080) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5.643')(2075,2080) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2080,2081) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2081,2082) + PsiWhiteSpace('\n')(2082,2083) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2083,2108) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2083,2084) + PsiWhiteSpace(' ')(2084,2085) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2085,2086) + PsiWhiteSpace(' ')(2086,2087) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2087,2107) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2087,2088) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2088,2091) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"a"')(2088,2091) + PsiElement(OpenSCADTokenType.COMMA)(',')(2091,2092) + PsiWhiteSpace(' ')(2092,2093) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2093,2096) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"b"')(2093,2096) PsiElement(OpenSCADTokenType.COMMA)(',')(2096,2097) PsiWhiteSpace(' ')(2097,2098) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2098,2139) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2098,2099) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2099,2105) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2099,2100) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2100,2101) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(2100,2101) - PsiElement(OpenSCADTokenType.COMMA)(',')(2101,2102) - PsiWhiteSpace(' ')(2102,2103) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2103,2104) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(2103,2104) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2104,2105) - PsiElement(OpenSCADTokenType.COMMA)(',')(2105,2106) - PsiWhiteSpace(' ')(2106,2107) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2107,2125) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2107,2108) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2108,2110) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2108,2110) - PsiElement(OpenSCADTokenType.COMMA)(',')(2110,2111) - PsiWhiteSpace(' ')(2111,2112) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2112,2120) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2112,2113) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2113,2115) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('11')(2113,2115) - PsiElement(OpenSCADTokenType.COMMA)(',')(2115,2116) - PsiWhiteSpace(' ')(2116,2117) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2117,2119) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('12')(2117,2119) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2119,2120) - PsiElement(OpenSCADTokenType.COMMA)(',')(2120,2121) - PsiWhiteSpace(' ')(2121,2122) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2122,2124) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('13')(2122,2124) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2124,2125) - PsiElement(OpenSCADTokenType.COMMA)(',')(2125,2126) - PsiWhiteSpace(' ')(2126,2127) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2127,2128) - PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(2127,2128) - PsiElement(OpenSCADTokenType.COMMA)(',')(2128,2129) - PsiWhiteSpace(' ')(2129,2130) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2130,2138) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2130,2138) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2138,2139) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2139,2140) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2140,2141) - PsiWhiteSpace('\n')(2141,2142) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2142,2172) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2142,2143) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2098,2106) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2098,2106) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2106,2107) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2107,2108) + PsiWhiteSpace('\n')(2108,2109) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2109,2139) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2109,2110) + PsiWhiteSpace(' ')(2110,2111) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2111,2112) + PsiWhiteSpace(' ')(2112,2113) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2113,2138) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2113,2114) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2114,2120) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2114,2115) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2115,2116) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2115,2116) + PsiElement(OpenSCADTokenType.COMMA)(',')(2116,2117) + PsiWhiteSpace(' ')(2117,2118) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2118,2119) + PsiElement(OpenSCADTokenType.IDENTIFIER)('r')(2118,2119) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2119,2120) + PsiElement(OpenSCADTokenType.COMMA)(',')(2120,2121) + PsiWhiteSpace(' ')(2121,2122) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2122,2137) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2122,2123) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2123,2124) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2123,2124) + PsiElement(OpenSCADTokenType.COMMA)(',')(2124,2125) + PsiWhiteSpace(' ')(2125,2126) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2126,2127) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2126,2127) + PsiElement(OpenSCADTokenType.COMMA)(',')(2127,2128) + PsiWhiteSpace(' ')(2128,2129) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2129,2130) + PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(2129,2130) + PsiElement(OpenSCADTokenType.COMMA)(',')(2130,2131) + PsiWhiteSpace(' ')(2131,2132) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2132,2133) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2132,2133) + PsiElement(OpenSCADTokenType.COMMA)(',')(2133,2134) + PsiWhiteSpace(' ')(2134,2135) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2135,2136) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2135,2136) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2136,2137) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2137,2138) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2138,2139) + PsiWhiteSpace('\n')(2139,2140) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2140,2202) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2140,2141) + PsiWhiteSpace(' ')(2141,2142) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2142,2143) PsiWhiteSpace(' ')(2143,2144) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2144,2145) - PsiWhiteSpace(' ')(2145,2146) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2146,2171) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2146,2147) - OpenSCADDivExprImpl(DIV_EXPR)(2147,2152) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2147,2148) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2147,2148) - PsiWhiteSpace(' ')(2148,2149) - PsiElement(OpenSCADTokenType.DIV)('/')(2149,2150) - PsiWhiteSpace(' ')(2150,2151) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2151,2152) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2151,2152) - PsiElement(OpenSCADTokenType.COMMA)(',')(2152,2153) - PsiWhiteSpace(' ')(2153,2154) - OpenSCADMulExprImpl(MUL_EXPR)(2154,2161) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2154,2155) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2154,2155) - PsiWhiteSpace(' ')(2155,2156) - PsiElement(OpenSCADTokenType.MUL)('*')(2156,2157) - PsiWhiteSpace(' ')(2157,2158) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2158,2161) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1.5')(2158,2161) - PsiElement(OpenSCADTokenType.COMMA)(',')(2161,2162) - PsiWhiteSpace(' ')(2162,2163) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(2163,2170) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(2163,2166) - PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(2163,2166) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2166,2170) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2166,2167) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2167,2169) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2167,2169) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('60')(2167,2169) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2169,2170) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2170,2171) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2171,2172) - PsiWhiteSpace('\n\n')(2172,2174) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2174,2203) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(2174,2178) - PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(2174,2178) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2178,2202) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2178,2179) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2179,2201) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2179,2201) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2179,2180) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2180,2185) - PsiElement(OpenSCADTokenType.IDENTIFIER)('width')(2180,2185) - PsiElement(OpenSCADTokenType.COMMA)(',')(2185,2186) - PsiWhiteSpace(' ')(2186,2187) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2187,2192) - PsiElement(OpenSCADTokenType.IDENTIFIER)('depth')(2187,2192) - PsiElement(OpenSCADTokenType.COMMA)(',')(2192,2193) - PsiWhiteSpace(' ')(2193,2194) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2194,2200) - PsiElement(OpenSCADTokenType.IDENTIFIER)('height')(2194,2200) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2200,2201) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2201,2202) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2202,2203) - PsiWhiteSpace(' ')(2203,2214) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// optional spaces shown for clarity')(2214,2250) - PsiWhiteSpace('\n')(2250,2251) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2251,2312) - OpenSCADBuiltinOpImpl(BUILTIN_OP)(2251,2271) - OpenSCADCommonOpRefImpl(COMMON_OP_REF)(2251,2260) - PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(2251,2260) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2260,2271) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2260,2261) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2261,2270) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2261,2270) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2261,2262) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2262,2263) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2262,2263) - PsiElement(OpenSCADTokenType.COMMA)(',')(2263,2264) - PsiWhiteSpace(' ')(2264,2265) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2265,2266) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2265,2266) - PsiElement(OpenSCADTokenType.COMMA)(',')(2266,2267) - PsiWhiteSpace(' ')(2267,2268) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2268,2269) - PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(2268,2269) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2269,2270) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2270,2271) - PsiWhiteSpace('\n')(2271,2272) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2272,2312) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(2272,2279) - PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(2272,2279) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2279,2311) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2279,2280) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2280,2310) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2280,2310) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2280,2281) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2281,2289) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2281,2282) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2282,2284) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x0')(2282,2284) - PsiElement(OpenSCADTokenType.COMMA)(',')(2284,2285) - PsiWhiteSpace(' ')(2285,2286) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2286,2288) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y0')(2286,2288) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2288,2289) - PsiElement(OpenSCADTokenType.COMMA)(',')(2289,2290) - PsiWhiteSpace(' ')(2290,2291) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2291,2299) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2291,2292) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2292,2294) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x1')(2292,2294) - PsiElement(OpenSCADTokenType.COMMA)(',')(2294,2295) - PsiWhiteSpace(' ')(2295,2296) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2296,2298) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y1')(2296,2298) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2298,2299) - PsiElement(OpenSCADTokenType.COMMA)(',')(2299,2300) - PsiWhiteSpace(' ')(2300,2301) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2301,2309) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2301,2302) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2302,2304) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x2')(2302,2304) - PsiElement(OpenSCADTokenType.COMMA)(',')(2304,2305) - PsiWhiteSpace(' ')(2305,2306) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2306,2308) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y2')(2306,2308) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2308,2309) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2309,2310) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2310,2311) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2311,2312) - PsiWhiteSpace('\n\n')(2312,2314) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2314,2333) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(2314,2318) - PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(2314,2318) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2318,2332) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2318,2319) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2319,2331) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2319,2331) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2319,2320) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2320,2322) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2320,2322) - PsiElement(OpenSCADTokenType.COMMA)(',')(2322,2323) - PsiWhiteSpace(' ')(2323,2324) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2324,2326) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('15')(2324,2326) - PsiElement(OpenSCADTokenType.COMMA)(',')(2326,2327) - PsiWhiteSpace(' ')(2327,2328) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2328,2330) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(2328,2330) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2330,2331) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2331,2332) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2332,2333) - PsiWhiteSpace('\n')(2333,2334) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2334,2349) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a1')(2334,2336) - PsiWhiteSpace(' ')(2336,2337) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2337,2338) - PsiWhiteSpace(' ')(2338,2339) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2339,2348) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2339,2340) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2340,2341) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2340,2341) - PsiElement(OpenSCADTokenType.COMMA)(',')(2341,2342) - PsiWhiteSpace(' ')(2342,2343) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2343,2344) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2343,2344) - PsiElement(OpenSCADTokenType.COMMA)(',')(2344,2345) - PsiWhiteSpace(' ')(2345,2346) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2346,2347) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2346,2347) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2347,2348) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2348,2349) - PsiWhiteSpace('\n')(2349,2350) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2350,2362) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a2')(2350,2352) - PsiWhiteSpace(' ')(2352,2353) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2353,2354) - PsiWhiteSpace(' ')(2354,2355) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2355,2361) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2355,2356) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2356,2357) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2356,2357) - PsiElement(OpenSCADTokenType.COMMA)(',')(2357,2358) - PsiWhiteSpace(' ')(2358,2359) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2359,2360) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2359,2360) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2360,2361) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2361,2362) - PsiWhiteSpace('\n')(2362,2363) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2363,2381) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a3')(2363,2365) - PsiWhiteSpace(' ')(2365,2366) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2366,2367) - PsiWhiteSpace(' ')(2367,2368) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2368,2380) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2368,2369) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2369,2370) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2369,2370) - PsiElement(OpenSCADTokenType.COMMA)(',')(2370,2371) - PsiWhiteSpace(' ')(2371,2372) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2372,2373) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('7')(2372,2373) - PsiElement(OpenSCADTokenType.COMMA)(',')(2373,2374) - PsiWhiteSpace(' ')(2374,2375) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2375,2376) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(2375,2376) - PsiElement(OpenSCADTokenType.COMMA)(',')(2376,2377) - PsiWhiteSpace(' ')(2377,2378) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2378,2379) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(2378,2379) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2379,2380) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2380,2381) - PsiWhiteSpace('\n')(2381,2382) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2382,2399) - PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2382,2383) - PsiWhiteSpace(' ')(2383,2384) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2384,2385) - PsiWhiteSpace(' ')(2385,2386) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2386,2398) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2386,2387) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2387,2389) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a1')(2387,2389) - PsiElement(OpenSCADTokenType.COMMA)(',')(2389,2390) - PsiWhiteSpace(' ')(2390,2391) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2391,2393) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a2')(2391,2393) - PsiElement(OpenSCADTokenType.COMMA)(',')(2393,2394) - PsiWhiteSpace(' ')(2394,2395) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2395,2397) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a3')(2395,2397) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2397,2398) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2398,2399) - PsiWhiteSpace(' ')(2399,2403) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// [ [1,2,3], [4,5], [6,7,8,9] ] note increased nesting depth')(2403,2465) - PsiWhiteSpace('\n\n')(2465,2467) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2467,2476) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2467,2468) - PsiWhiteSpace(' ')(2468,2469) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2469,2470) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2144,2201) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2144,2145) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2145,2146) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2145,2146) + PsiElement(OpenSCADTokenType.COMMA)(',')(2146,2147) + PsiWhiteSpace(' ')(2147,2148) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2148,2149) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2148,2149) + PsiElement(OpenSCADTokenType.COMMA)(',')(2149,2150) + PsiWhiteSpace(' ')(2150,2151) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2151,2157) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2151,2152) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2152,2153) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2152,2153) + PsiElement(OpenSCADTokenType.COMMA)(',')(2153,2154) + PsiWhiteSpace(' ')(2154,2155) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2155,2156) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('7')(2155,2156) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2156,2157) + PsiElement(OpenSCADTokenType.COMMA)(',')(2157,2158) + PsiWhiteSpace(' ')(2158,2159) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2159,2200) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2159,2160) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2160,2166) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2160,2161) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2161,2162) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(2161,2162) + PsiElement(OpenSCADTokenType.COMMA)(',')(2162,2163) + PsiWhiteSpace(' ')(2163,2164) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2164,2165) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(2164,2165) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2165,2166) + PsiElement(OpenSCADTokenType.COMMA)(',')(2166,2167) + PsiWhiteSpace(' ')(2167,2168) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2168,2186) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2168,2169) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2169,2171) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2169,2171) + PsiElement(OpenSCADTokenType.COMMA)(',')(2171,2172) + PsiWhiteSpace(' ')(2172,2173) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2173,2181) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2173,2174) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2174,2176) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('11')(2174,2176) + PsiElement(OpenSCADTokenType.COMMA)(',')(2176,2177) + PsiWhiteSpace(' ')(2177,2178) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2178,2180) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('12')(2178,2180) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2180,2181) + PsiElement(OpenSCADTokenType.COMMA)(',')(2181,2182) + PsiWhiteSpace(' ')(2182,2183) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2183,2185) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('13')(2183,2185) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2185,2186) + PsiElement(OpenSCADTokenType.COMMA)(',')(2186,2187) + PsiWhiteSpace(' ')(2187,2188) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2188,2189) + PsiElement(OpenSCADTokenType.IDENTIFIER)('c')(2188,2189) + PsiElement(OpenSCADTokenType.COMMA)(',')(2189,2190) + PsiWhiteSpace(' ')(2190,2191) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2191,2199) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2191,2199) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2199,2200) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2200,2201) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2201,2202) + PsiWhiteSpace('\n')(2202,2203) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2203,2233) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2203,2204) + PsiWhiteSpace(' ')(2204,2205) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2205,2206) + PsiWhiteSpace(' ')(2206,2207) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2207,2232) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2207,2208) + OpenSCADDivExprImpl(DIV_EXPR)(2208,2213) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2208,2209) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2208,2209) + PsiWhiteSpace(' ')(2209,2210) + PsiElement(OpenSCADTokenType.DIV)('/')(2210,2211) + PsiWhiteSpace(' ')(2211,2212) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2212,2213) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2212,2213) + PsiElement(OpenSCADTokenType.COMMA)(',')(2213,2214) + PsiWhiteSpace(' ')(2214,2215) + OpenSCADMulExprImpl(MUL_EXPR)(2215,2222) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2215,2216) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2215,2216) + PsiWhiteSpace(' ')(2216,2217) + PsiElement(OpenSCADTokenType.MUL)('*')(2217,2218) + PsiWhiteSpace(' ')(2218,2219) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2219,2222) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1.5')(2219,2222) + PsiElement(OpenSCADTokenType.COMMA)(',')(2222,2223) + PsiWhiteSpace(' ')(2223,2224) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(2224,2231) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(2224,2227) + PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(2224,2227) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2227,2231) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2227,2228) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2228,2230) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2228,2230) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('60')(2228,2230) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2230,2231) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2231,2232) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2232,2233) + PsiWhiteSpace('\n')(2233,2234) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2234,2259) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2234,2235) + PsiWhiteSpace(' ')(2235,2236) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2236,2237) + PsiWhiteSpace(' ')(2237,2238) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2238,2258) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2238,2239) + OpenSCADMulExprImpl(MUL_EXPR)(2239,2248) + OpenSCADParenExprImpl(PAREN_EXPR)(2239,2246) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2239,2240) + OpenSCADPlusExprImpl(PLUS_EXPR)(2240,2245) + OpenSCADMulExprImpl(MUL_EXPR)(2240,2243) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2240,2241) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2240,2241) + PsiElement(OpenSCADTokenType.MUL)('*')(2241,2242) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2242,2243) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2242,2243) + PsiElement(OpenSCADTokenType.PLUS)('+')(2243,2244) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2244,2245) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2244,2245) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2245,2246) + PsiElement(OpenSCADTokenType.MUL)('*')(2246,2247) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2247,2248) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2247,2248) + PsiElement(OpenSCADTokenType.COMMA)(',')(2248,2249) + PsiWhiteSpace(' ')(2249,2250) + OpenSCADMulExprImpl(MUL_EXPR)(2250,2257) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2250,2251) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2250,2251) + PsiElement(OpenSCADTokenType.MUL)('*')(2251,2252) + OpenSCADParenExprImpl(PAREN_EXPR)(2252,2257) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2252,2253) + OpenSCADMulExprImpl(MUL_EXPR)(2253,2256) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2253,2254) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2253,2254) + PsiElement(OpenSCADTokenType.MUL)('*')(2254,2255) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2255,2256) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2255,2256) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2256,2257) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2257,2258) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2258,2259) + PsiWhiteSpace('\n\n')(2259,2261) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2261,2290) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(2261,2265) + PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(2261,2265) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2265,2289) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2265,2266) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2266,2288) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2266,2288) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2266,2267) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2267,2272) + PsiElement(OpenSCADTokenType.IDENTIFIER)('width')(2267,2272) + PsiElement(OpenSCADTokenType.COMMA)(',')(2272,2273) + PsiWhiteSpace(' ')(2273,2274) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2274,2279) + PsiElement(OpenSCADTokenType.IDENTIFIER)('depth')(2274,2279) + PsiElement(OpenSCADTokenType.COMMA)(',')(2279,2280) + PsiWhiteSpace(' ')(2280,2281) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2281,2287) + PsiElement(OpenSCADTokenType.IDENTIFIER)('height')(2281,2287) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2287,2288) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2288,2289) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2289,2290) + PsiWhiteSpace(' ')(2290,2301) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// optional spaces shown for clarity')(2301,2337) + PsiWhiteSpace('\n')(2337,2338) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2338,2399) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(2338,2358) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(2338,2347) + PsiElement(OpenSCADTokenType.TRANSLATE_KEYWORD)('translate')(2338,2347) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2347,2358) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2347,2348) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2348,2357) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2348,2357) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2348,2349) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2349,2350) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2349,2350) + PsiElement(OpenSCADTokenType.COMMA)(',')(2350,2351) + PsiWhiteSpace(' ')(2351,2352) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2352,2353) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2352,2353) + PsiElement(OpenSCADTokenType.COMMA)(',')(2353,2354) + PsiWhiteSpace(' ')(2354,2355) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2355,2356) + PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(2355,2356) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2356,2357) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2357,2358) + PsiWhiteSpace('\n')(2358,2359) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2359,2399) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(2359,2366) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(2359,2366) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2366,2398) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2366,2367) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2367,2397) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2367,2397) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2367,2368) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2368,2376) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2368,2369) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2369,2371) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x0')(2369,2371) + PsiElement(OpenSCADTokenType.COMMA)(',')(2371,2372) + PsiWhiteSpace(' ')(2372,2373) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2373,2375) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y0')(2373,2375) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2375,2376) + PsiElement(OpenSCADTokenType.COMMA)(',')(2376,2377) + PsiWhiteSpace(' ')(2377,2378) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2378,2386) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2378,2379) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2379,2381) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x1')(2379,2381) + PsiElement(OpenSCADTokenType.COMMA)(',')(2381,2382) + PsiWhiteSpace(' ')(2382,2383) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2383,2385) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y1')(2383,2385) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2385,2386) + PsiElement(OpenSCADTokenType.COMMA)(',')(2386,2387) + PsiWhiteSpace(' ')(2387,2388) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2388,2396) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2388,2389) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2389,2391) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x2')(2389,2391) + PsiElement(OpenSCADTokenType.COMMA)(',')(2391,2392) + PsiWhiteSpace(' ')(2392,2393) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2393,2395) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y2')(2393,2395) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2395,2396) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2396,2397) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2397,2398) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2398,2399) + PsiWhiteSpace('\n\n')(2399,2401) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(2401,2420) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(2401,2405) + PsiElement(OpenSCADTokenType.CUBE_KEYWORD)('cube')(2401,2405) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2405,2419) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(2405,2406) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2406,2418) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2406,2418) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2406,2407) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2407,2409) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2407,2409) + PsiElement(OpenSCADTokenType.COMMA)(',')(2409,2410) + PsiWhiteSpace(' ')(2410,2411) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2411,2413) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('15')(2411,2413) + PsiElement(OpenSCADTokenType.COMMA)(',')(2413,2414) + PsiWhiteSpace(' ')(2414,2415) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2415,2417) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(2415,2417) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2417,2418) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(2418,2419) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2419,2420) + PsiWhiteSpace('\n')(2420,2421) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2421,2436) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a1')(2421,2423) + PsiWhiteSpace(' ')(2423,2424) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2424,2425) + PsiWhiteSpace(' ')(2425,2426) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2426,2435) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2426,2427) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2427,2428) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2427,2428) + PsiElement(OpenSCADTokenType.COMMA)(',')(2428,2429) + PsiWhiteSpace(' ')(2429,2430) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2430,2431) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2430,2431) + PsiElement(OpenSCADTokenType.COMMA)(',')(2431,2432) + PsiWhiteSpace(' ')(2432,2433) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2433,2434) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2433,2434) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2434,2435) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2435,2436) + PsiWhiteSpace('\n')(2436,2437) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2437,2449) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a2')(2437,2439) + PsiWhiteSpace(' ')(2439,2440) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2440,2441) + PsiWhiteSpace(' ')(2441,2442) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2442,2448) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2442,2443) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2443,2444) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2443,2444) + PsiElement(OpenSCADTokenType.COMMA)(',')(2444,2445) + PsiWhiteSpace(' ')(2445,2446) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2446,2447) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2446,2447) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2447,2448) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2448,2449) + PsiWhiteSpace('\n')(2449,2450) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2450,2468) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a3')(2450,2452) + PsiWhiteSpace(' ')(2452,2453) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2453,2454) + PsiWhiteSpace(' ')(2454,2455) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2455,2467) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2455,2456) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2456,2457) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('6')(2456,2457) + PsiElement(OpenSCADTokenType.COMMA)(',')(2457,2458) + PsiWhiteSpace(' ')(2458,2459) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2459,2460) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('7')(2459,2460) + PsiElement(OpenSCADTokenType.COMMA)(',')(2460,2461) + PsiWhiteSpace(' ')(2461,2462) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2462,2463) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(2462,2463) + PsiElement(OpenSCADTokenType.COMMA)(',')(2463,2464) + PsiWhiteSpace(' ')(2464,2465) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2465,2466) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(2465,2466) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2466,2467) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2467,2468) + PsiWhiteSpace('\n')(2468,2469) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2469,2486) + PsiElement(OpenSCADTokenType.IDENTIFIER)('b')(2469,2470) PsiWhiteSpace(' ')(2470,2471) - OpenSCADIndexExprImpl(INDEX_EXPR)(2471,2475) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2471,2472) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2471,2472) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2472,2473) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2473,2474) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2473,2474) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2474,2475) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2475,2476) - PsiWhiteSpace(' ')(2476,2487) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element no 5 (sixth) at 1st nesting level')(2487,2533) - PsiWhiteSpace('\n')(2533,2534) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2534,2546) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2534,2535) - PsiWhiteSpace(' ')(2535,2536) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2536,2537) - PsiWhiteSpace(' ')(2537,2538) - OpenSCADIndexExprImpl(INDEX_EXPR)(2538,2545) - OpenSCADIndexExprImpl(INDEX_EXPR)(2538,2542) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2538,2539) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2538,2539) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2539,2540) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2540,2541) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2540,2541) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2541,2542) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2542,2543) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2543,2544) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2543,2544) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2544,2545) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2545,2546) - PsiWhiteSpace(' ')(2546,2554) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 2 of element 5 2nd nesting level')(2554,2600) - PsiWhiteSpace('\n')(2600,2601) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2601,2616) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2601,2602) - PsiWhiteSpace(' ')(2602,2603) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2603,2604) - PsiWhiteSpace(' ')(2604,2605) - OpenSCADIndexExprImpl(INDEX_EXPR)(2605,2615) - OpenSCADIndexExprImpl(INDEX_EXPR)(2605,2612) - OpenSCADIndexExprImpl(INDEX_EXPR)(2605,2609) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2605,2606) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2605,2606) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2606,2607) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2607,2608) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2607,2608) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2608,2609) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2609,2610) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2610,2611) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2610,2611) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2611,2612) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2612,2613) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2613,2614) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(2613,2614) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2614,2615) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2615,2616) - PsiWhiteSpace(' ')(2616,2621) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 0 of 2 of 5 3rd nesting level')(2621,2667) - PsiWhiteSpace('\n')(2667,2668) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2668,2686) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2668,2669) - PsiWhiteSpace(' ')(2669,2670) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2670,2671) - PsiWhiteSpace(' ')(2671,2672) - OpenSCADIndexExprImpl(INDEX_EXPR)(2672,2685) - OpenSCADIndexExprImpl(INDEX_EXPR)(2672,2682) - OpenSCADIndexExprImpl(INDEX_EXPR)(2672,2679) - OpenSCADIndexExprImpl(INDEX_EXPR)(2672,2676) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2672,2673) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2672,2673) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2673,2674) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2674,2675) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2674,2675) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2675,2676) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2676,2677) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2677,2678) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2677,2678) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2678,2679) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2679,2680) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2680,2681) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(2680,2681) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2681,2682) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2682,2683) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2683,2684) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2683,2684) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2684,2685) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2685,2686) - PsiWhiteSpace(' ')(2686,2688) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 1 of 0 of 2 of 5 4th nesting level')(2688,2734) - PsiWhiteSpace('\n\n')(2734,2736) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2736,2820) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2736,2737) - PsiWhiteSpace(' ')(2737,2738) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2738,2739) - PsiWhiteSpace(' ')(2739,2740) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2740,2819) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2740,2741) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2741,2744) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2741,2742) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2742,2743) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2742,2743) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2743,2744) - PsiElement(OpenSCADTokenType.COMMA)(',')(2744,2745) - PsiWhiteSpace(' ')(2745,2746) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2746,2748) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2746,2747) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2747,2748) - PsiElement(OpenSCADTokenType.COMMA)(',')(2748,2749) - PsiWhiteSpace(' ')(2749,2750) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2750,2759) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2750,2751) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2751,2752) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2751,2752) - PsiElement(OpenSCADTokenType.COMMA)(',')(2752,2753) - PsiWhiteSpace(' ')(2753,2754) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2754,2755) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2754,2755) - PsiElement(OpenSCADTokenType.COMMA)(',')(2755,2756) - PsiWhiteSpace(' ')(2756,2757) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2757,2758) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2757,2758) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2758,2759) - PsiElement(OpenSCADTokenType.COMMA)(',')(2759,2760) - PsiWhiteSpace(' ')(2760,2761) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2761,2769) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2761,2769) - PsiElement(OpenSCADTokenType.COMMA)(',')(2769,2770) - PsiWhiteSpace(' ')(2770,2771) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2771,2774) - PsiElement(OpenSCADTokenType.STRING_LITERAL)('"x"')(2771,2774) - PsiElement(OpenSCADTokenType.COMMA)(',')(2774,2775) - PsiWhiteSpace(' ')(2775,2776) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2776,2818) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2776,2777) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2777,2785) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2777,2778) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2778,2780) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2778,2780) - PsiElement(OpenSCADTokenType.COMMA)(',')(2780,2781) - PsiWhiteSpace(' ')(2781,2782) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2782,2784) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('11')(2782,2784) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2784,2785) - PsiElement(OpenSCADTokenType.COMMA)(',')(2785,2786) - PsiWhiteSpace(' ')(2786,2787) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2787,2799) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2787,2788) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2788,2790) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('12')(2788,2790) - PsiElement(OpenSCADTokenType.COMMA)(',')(2790,2791) - PsiWhiteSpace(' ')(2791,2792) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2792,2794) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('13')(2792,2794) - PsiElement(OpenSCADTokenType.COMMA)(',')(2794,2795) - PsiWhiteSpace(' ')(2795,2796) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2796,2798) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('14')(2796,2798) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2798,2799) - PsiElement(OpenSCADTokenType.COMMA)(',')(2799,2800) - PsiWhiteSpace(' ')(2800,2801) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2801,2817) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2801,2802) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2802,2810) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2802,2803) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2803,2805) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('15')(2803,2805) - PsiElement(OpenSCADTokenType.COMMA)(',')(2805,2806) - PsiWhiteSpace(' ')(2806,2807) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2807,2809) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('16')(2807,2809) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2809,2810) - PsiElement(OpenSCADTokenType.COMMA)(',')(2810,2811) - PsiWhiteSpace(' ')(2811,2812) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2812,2816) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2812,2813) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(2813,2815) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('17')(2813,2815) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2815,2816) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2816,2817) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2817,2818) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(2818,2819) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2819,2820) - PsiWhiteSpace(' ')(2820,2822) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// length 6')(2822,2833) - PsiWhiteSpace('\n\n')(2833,2835) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2835,2843) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2835,2836) - PsiWhiteSpace(' ')(2836,2837) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2837,2838) - PsiWhiteSpace(' ')(2838,2839) - OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(2839,2842) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2839,2840) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2839,2840) - PsiElement(OpenSCADTokenType.DOT)('.')(2840,2841) - PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2841,2842) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2842,2843) - PsiWhiteSpace(' ')(2843,2847) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[0]')(2847,2867) - PsiWhiteSpace('\n')(2867,2868) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2868,2876) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2868,2869) - PsiWhiteSpace(' ')(2869,2870) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2870,2871) - PsiWhiteSpace(' ')(2871,2872) - OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(2872,2875) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2872,2873) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2872,2873) - PsiElement(OpenSCADTokenType.DOT)('.')(2873,2874) - PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2874,2875) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2875,2876) - PsiWhiteSpace(' ')(2876,2880) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[1]')(2880,2900) - PsiWhiteSpace('\n')(2900,2901) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2901,2909) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(2901,2902) - PsiWhiteSpace(' ')(2902,2903) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2903,2904) - PsiWhiteSpace(' ')(2904,2905) - OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(2905,2908) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2905,2906) - PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2905,2906) - PsiElement(OpenSCADTokenType.DOT)('.')(2906,2907) - PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(2907,2908) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2908,2909) - PsiWhiteSpace(' ')(2909,2913) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[2]')(2913,2933) - PsiWhiteSpace('\n\n')(2933,2935) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//Example which defines a 2D rotation matrix')(2935,2979) - PsiWhiteSpace('\n')(2979,2980) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2980,3042) - PsiElement(OpenSCADTokenType.IDENTIFIER)('mr')(2980,2982) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2471,2472) + PsiWhiteSpace(' ')(2472,2473) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2473,2485) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2473,2474) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2474,2476) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a1')(2474,2476) + PsiElement(OpenSCADTokenType.COMMA)(',')(2476,2477) + PsiWhiteSpace(' ')(2477,2478) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2478,2480) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a2')(2478,2480) + PsiElement(OpenSCADTokenType.COMMA)(',')(2480,2481) + PsiWhiteSpace(' ')(2481,2482) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2482,2484) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a3')(2482,2484) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2484,2485) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2485,2486) + PsiWhiteSpace(' ')(2486,2490) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// [ [1,2,3], [4,5], [6,7,8,9] ] note increased nesting depth')(2490,2552) + PsiWhiteSpace('\n\n')(2552,2554) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2554,2638) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2554,2555) + PsiWhiteSpace(' ')(2555,2556) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2556,2557) + PsiWhiteSpace(' ')(2557,2558) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2558,2637) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2558,2559) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2559,2562) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2559,2560) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2560,2561) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2560,2561) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2561,2562) + PsiElement(OpenSCADTokenType.COMMA)(',')(2562,2563) + PsiWhiteSpace(' ')(2563,2564) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2564,2566) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2564,2565) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2565,2566) + PsiElement(OpenSCADTokenType.COMMA)(',')(2566,2567) + PsiWhiteSpace(' ')(2567,2568) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2568,2577) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2568,2569) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2569,2570) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(2569,2570) + PsiElement(OpenSCADTokenType.COMMA)(',')(2570,2571) + PsiWhiteSpace(' ')(2571,2572) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2572,2573) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(2572,2573) + PsiElement(OpenSCADTokenType.COMMA)(',')(2573,2574) + PsiWhiteSpace(' ')(2574,2575) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2575,2576) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2575,2576) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2576,2577) + PsiElement(OpenSCADTokenType.COMMA)(',')(2577,2578) + PsiWhiteSpace(' ')(2578,2579) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2579,2587) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"string"')(2579,2587) + PsiElement(OpenSCADTokenType.COMMA)(',')(2587,2588) + PsiWhiteSpace(' ')(2588,2589) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2589,2592) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"x"')(2589,2592) + PsiElement(OpenSCADTokenType.COMMA)(',')(2592,2593) + PsiWhiteSpace(' ')(2593,2594) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2594,2636) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2594,2595) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2595,2603) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2595,2596) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2596,2598) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(2596,2598) + PsiElement(OpenSCADTokenType.COMMA)(',')(2598,2599) + PsiWhiteSpace(' ')(2599,2600) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2600,2602) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('11')(2600,2602) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2602,2603) + PsiElement(OpenSCADTokenType.COMMA)(',')(2603,2604) + PsiWhiteSpace(' ')(2604,2605) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2605,2617) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2605,2606) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2606,2608) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('12')(2606,2608) + PsiElement(OpenSCADTokenType.COMMA)(',')(2608,2609) + PsiWhiteSpace(' ')(2609,2610) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2610,2612) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('13')(2610,2612) + PsiElement(OpenSCADTokenType.COMMA)(',')(2612,2613) + PsiWhiteSpace(' ')(2613,2614) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2614,2616) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('14')(2614,2616) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2616,2617) + PsiElement(OpenSCADTokenType.COMMA)(',')(2617,2618) + PsiWhiteSpace(' ')(2618,2619) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2619,2635) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2619,2620) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2620,2628) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2620,2621) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2621,2623) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('15')(2621,2623) + PsiElement(OpenSCADTokenType.COMMA)(',')(2623,2624) + PsiWhiteSpace(' ')(2624,2625) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2625,2627) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('16')(2625,2627) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2627,2628) + PsiElement(OpenSCADTokenType.COMMA)(',')(2628,2629) + PsiWhiteSpace(' ')(2629,2630) + OpenSCADVectorExprImpl(VECTOR_EXPR)(2630,2634) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2630,2631) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2631,2633) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('17')(2631,2633) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2633,2634) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2634,2635) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2635,2636) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2636,2637) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2637,2638) + PsiWhiteSpace(' ')(2638,2640) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// length 6')(2640,2651) + PsiWhiteSpace('\n\n')(2651,2653) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2653,2664) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_5')(2653,2656) + PsiWhiteSpace(' ')(2656,2657) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2657,2658) + PsiWhiteSpace(' ')(2658,2659) + OpenSCADIndexExprImpl(INDEX_EXPR)(2659,2663) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2659,2660) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2659,2660) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2660,2661) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2661,2662) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2661,2662) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2662,2663) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2663,2664) + PsiWhiteSpace(' ')(2664,2675) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element no 5 (sixth) at 1st nesting level')(2675,2721) + PsiWhiteSpace('\n')(2721,2722) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2722,2738) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_5_2')(2722,2727) + PsiWhiteSpace(' ')(2727,2728) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2728,2729) + PsiWhiteSpace(' ')(2729,2730) + OpenSCADIndexExprImpl(INDEX_EXPR)(2730,2737) + OpenSCADIndexExprImpl(INDEX_EXPR)(2730,2734) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2730,2731) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2730,2731) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2731,2732) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2732,2733) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2732,2733) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2733,2734) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2734,2735) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2735,2736) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2735,2736) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2736,2737) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2737,2738) + PsiWhiteSpace(' ')(2738,2746) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 2 of element 5 2nd nesting level')(2746,2792) + PsiWhiteSpace('\n')(2792,2793) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2793,2814) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_5_2_0')(2793,2800) + PsiWhiteSpace(' ')(2800,2801) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2801,2802) + PsiWhiteSpace(' ')(2802,2803) + OpenSCADIndexExprImpl(INDEX_EXPR)(2803,2813) + OpenSCADIndexExprImpl(INDEX_EXPR)(2803,2810) + OpenSCADIndexExprImpl(INDEX_EXPR)(2803,2807) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2803,2804) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2803,2804) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2804,2805) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2805,2806) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2805,2806) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2806,2807) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2807,2808) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2808,2809) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2808,2809) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2809,2810) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2810,2811) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2811,2812) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(2811,2812) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2812,2813) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2813,2814) + PsiWhiteSpace(' ')(2814,2819) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 0 of 2 of 5 3rd nesting level')(2819,2865) + PsiWhiteSpace('\n')(2865,2866) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2866,2892) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_5_2_0_1')(2866,2875) + PsiWhiteSpace(' ')(2875,2876) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2876,2877) + PsiWhiteSpace(' ')(2877,2878) + OpenSCADIndexExprImpl(INDEX_EXPR)(2878,2891) + OpenSCADIndexExprImpl(INDEX_EXPR)(2878,2888) + OpenSCADIndexExprImpl(INDEX_EXPR)(2878,2885) + OpenSCADIndexExprImpl(INDEX_EXPR)(2878,2882) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2878,2879) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2878,2879) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2879,2880) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2880,2881) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(2880,2881) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2881,2882) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2882,2883) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2883,2884) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(2883,2884) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2884,2885) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2885,2886) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2886,2887) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(2886,2887) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2887,2888) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(2888,2889) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(2889,2890) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(2889,2890) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(2890,2891) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2891,2892) + PsiWhiteSpace(' ')(2892,2894) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// element 1 of 0 of 2 of 5 4th nesting level')(2894,2940) + PsiWhiteSpace('\n\n')(2940,2942) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2942,2952) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_0')(2942,2945) + PsiWhiteSpace(' ')(2945,2946) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2946,2947) + PsiWhiteSpace(' ')(2947,2948) + OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(2948,2951) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2948,2949) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2948,2949) + PsiElement(OpenSCADTokenType.DOT)('.')(2949,2950) + PsiElement(OpenSCADTokenType.IDENTIFIER)('x')(2950,2951) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2951,2952) + PsiWhiteSpace(' ')(2952,2956) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[0]')(2956,2976) + PsiWhiteSpace('\n')(2976,2977) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(2977,2987) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_1')(2977,2980) + PsiWhiteSpace(' ')(2980,2981) + PsiElement(OpenSCADTokenType.EQUALS)('=')(2981,2982) PsiWhiteSpace(' ')(2982,2983) - PsiElement(OpenSCADTokenType.EQUALS)('=')(2983,2984) - PsiWhiteSpace(' ')(2984,2985) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2985,3041) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2985,2986) - PsiWhiteSpace('\n')(2986,2987) - OpenSCADVectorExprImpl(VECTOR_EXPR)(2987,3013) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(2987,2988) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(2988,2998) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(2988,2991) - PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(2988,2991) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(2991,2998) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(2991,2992) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(2992,2997) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2992,2997) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(2992,2997) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(2997,2998) - PsiElement(OpenSCADTokenType.COMMA)(',')(2998,2999) - PsiWhiteSpace(' ')(2999,3000) - OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3000,3012) - PsiElement(OpenSCADTokenType.MINUS)('-')(3000,3001) - PsiWhiteSpace(' ')(3001,3002) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3002,3012) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3002,3005) - PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3002,3005) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3005,3012) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3005,3006) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3006,3011) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3006,3011) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3006,3011) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3011,3012) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3012,3013) - PsiElement(OpenSCADTokenType.COMMA)(',')(3013,3014) - PsiWhiteSpace('\n')(3014,3015) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3015,3039) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3015,3016) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3016,3026) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3016,3019) - PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3016,3019) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3019,3026) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3019,3020) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3020,3025) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3020,3025) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3020,3025) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3025,3026) - PsiElement(OpenSCADTokenType.COMMA)(',')(3026,3027) - PsiWhiteSpace(' ')(3027,3028) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3028,3038) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3028,3031) - PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3028,3031) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3031,3038) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3031,3032) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3032,3037) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3032,3037) - PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3032,3037) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3037,3038) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3038,3039) - PsiWhiteSpace('\n')(3039,3040) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3040,3041) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3041,3042) - PsiWhiteSpace('\n\n')(3042,3044) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3044,3055) - PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3044,3049) - PsiWhiteSpace(' ')(3049,3050) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3050,3051) - PsiWhiteSpace(' ')(3051,3052) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3052,3054) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('50')(3052,3054) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3054,3055) - PsiWhiteSpace('\n')(3055,3056) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3056,3394) - PsiElement(OpenSCADTokenType.IDENTIFIER)('points')(3056,3062) - PsiWhiteSpace(' ')(3062,3063) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3063,3064) - PsiWhiteSpace(' ')(3064,3065) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3065,3393) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3065,3066) - PsiWhiteSpace('\n')(3066,3067) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// first expression generating the points in the positive Y quadrant')(3067,3135) - PsiWhiteSpace('\n')(3135,3136) - OpenSCADForElementImpl(FOR_ELEMENT)(3136,3157) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3136,3139) - PsiWhiteSpace(' ')(3139,3140) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3140,3157) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3140,3141) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(3141,3156) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3141,3142) - PsiWhiteSpace(' ')(3142,3143) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3143,3144) - PsiWhiteSpace(' ')(3144,3145) - OpenSCADRangeExprImpl(RANGE_EXPR)(3145,3156) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3145,3146) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3146,3147) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3146,3147) - PsiWhiteSpace(' ')(3147,3148) - PsiElement(OpenSCADTokenType.COLON)(':')(3148,3149) - PsiWhiteSpace(' ')(3149,3150) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3150,3155) - PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3150,3155) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3155,3156) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3156,3157) - PsiWhiteSpace(' ')(3157,3158) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3158,3193) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3158,3159) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3159,3160) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3159,3160) - PsiElement(OpenSCADTokenType.COMMA)(',')(3160,3161) - PsiWhiteSpace(' ')(3161,3162) - OpenSCADPlusExprImpl(PLUS_EXPR)(3162,3192) - OpenSCADMulExprImpl(MUL_EXPR)(3162,3187) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3162,3164) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3162,3164) - PsiWhiteSpace(' ')(3164,3165) - PsiElement(OpenSCADTokenType.MUL)('*')(3165,3166) - PsiWhiteSpace(' ')(3166,3167) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3167,3187) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3167,3170) - PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3167,3170) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3170,3187) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3170,3171) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3171,3186) - OpenSCADDivExprImpl(DIV_EXPR)(3171,3186) - OpenSCADMulExprImpl(MUL_EXPR)(3171,3178) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3171,3172) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3171,3172) - PsiWhiteSpace(' ')(3172,3173) - PsiElement(OpenSCADTokenType.MUL)('*')(3173,3174) - PsiWhiteSpace(' ')(3174,3175) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3175,3178) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('360')(3175,3178) - PsiWhiteSpace(' ')(3178,3179) - PsiElement(OpenSCADTokenType.DIV)('/')(3179,3180) - PsiWhiteSpace(' ')(3180,3181) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3181,3186) - PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3181,3186) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3186,3187) - PsiWhiteSpace(' ')(3187,3188) - PsiElement(OpenSCADTokenType.PLUS)('+')(3188,3189) - PsiWhiteSpace(' ')(3189,3190) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3190,3192) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3190,3192) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3192,3193) - PsiElement(OpenSCADTokenType.COMMA)(',')(3193,3194) - PsiWhiteSpace('\n')(3194,3195) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// second expression generating the points in the negative Y quadrant')(3195,3264) - PsiWhiteSpace('\n')(3264,3265) - OpenSCADForElementImpl(FOR_ELEMENT)(3265,3292) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3265,3268) - PsiWhiteSpace(' ')(3268,3269) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3269,3292) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3269,3270) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(3270,3291) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3270,3271) - PsiWhiteSpace(' ')(3271,3272) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3272,3273) - PsiWhiteSpace(' ')(3273,3274) - OpenSCADRangeExprImpl(RANGE_EXPR)(3274,3291) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3274,3275) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3275,3280) - PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3275,3280) - PsiWhiteSpace(' ')(3280,3281) - PsiElement(OpenSCADTokenType.COLON)(':')(3281,3282) - PsiWhiteSpace(' ')(3282,3283) - OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3283,3286) - PsiElement(OpenSCADTokenType.MINUS)('-')(3283,3284) - PsiWhiteSpace(' ')(3284,3285) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3285,3286) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3285,3286) - PsiWhiteSpace(' ')(3286,3287) - PsiElement(OpenSCADTokenType.COLON)(':')(3287,3288) - PsiWhiteSpace(' ')(3288,3289) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3289,3290) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3289,3290) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3290,3291) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3291,3292) - PsiWhiteSpace(' ')(3292,3293) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3293,3328) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3293,3294) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3294,3295) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3294,3295) - PsiElement(OpenSCADTokenType.COMMA)(',')(3295,3296) - PsiWhiteSpace(' ')(3296,3297) - OpenSCADMinusExprImpl(MINUS_EXPR)(3297,3327) - OpenSCADMulExprImpl(MUL_EXPR)(3297,3322) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3297,3299) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3297,3299) - PsiWhiteSpace(' ')(3299,3300) - PsiElement(OpenSCADTokenType.MUL)('*')(3300,3301) - PsiWhiteSpace(' ')(3301,3302) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3302,3322) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3302,3305) - PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3302,3305) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3305,3322) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3305,3306) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3306,3321) - OpenSCADDivExprImpl(DIV_EXPR)(3306,3321) - OpenSCADMulExprImpl(MUL_EXPR)(3306,3313) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3306,3307) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3306,3307) - PsiWhiteSpace(' ')(3307,3308) - PsiElement(OpenSCADTokenType.MUL)('*')(3308,3309) - PsiWhiteSpace(' ')(3309,3310) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3310,3313) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('360')(3310,3313) - PsiWhiteSpace(' ')(3313,3314) - PsiElement(OpenSCADTokenType.DIV)('/')(3314,3315) - PsiWhiteSpace(' ')(3315,3316) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3316,3321) - PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3316,3321) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3321,3322) - PsiWhiteSpace(' ')(3322,3323) - PsiElement(OpenSCADTokenType.MINUS)('-')(3323,3324) - PsiWhiteSpace(' ')(3324,3325) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3325,3327) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(3325,3327) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3327,3328) - PsiElement(OpenSCADTokenType.COMMA)(',')(3328,3329) - PsiWhiteSpace('\n')(3329,3330) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// additional list of fixed points')(3330,3364) - PsiWhiteSpace('\n')(3364,3365) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3365,3374) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3365,3366) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3366,3368) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3366,3368) - PsiElement(OpenSCADTokenType.COMMA)(',')(3368,3369) - PsiWhiteSpace(' ')(3369,3370) - OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3370,3373) - PsiElement(OpenSCADTokenType.MINUS)('-')(3370,3371) - PsiWhiteSpace(' ')(3371,3372) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3372,3373) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3372,3373) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3373,3374) - PsiElement(OpenSCADTokenType.COMMA)(',')(3374,3375) - PsiWhiteSpace(' ')(3375,3376) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3376,3382) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3376,3377) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3377,3378) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3377,3378) - PsiElement(OpenSCADTokenType.COMMA)(',')(3378,3379) - PsiWhiteSpace(' ')(3379,3380) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3380,3381) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3380,3381) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3381,3382) - PsiElement(OpenSCADTokenType.COMMA)(',')(3382,3383) - PsiWhiteSpace(' ')(3383,3384) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3384,3391) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3384,3385) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3385,3387) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3385,3387) - PsiElement(OpenSCADTokenType.COMMA)(',')(3387,3388) - PsiWhiteSpace(' ')(3388,3389) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3389,3390) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3389,3390) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3390,3391) - PsiWhiteSpace('\n')(3391,3392) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3392,3393) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3393,3394) - PsiWhiteSpace('\n')(3394,3395) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(3395,3411) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(3395,3402) - PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(3395,3402) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3402,3410) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3402,3403) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3403,3409) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3403,3409) - PsiElement(OpenSCADTokenType.IDENTIFIER)('points')(3403,3409) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3409,3410) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3410,3411) - PsiWhiteSpace('\n\n')(3411,3413) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3413,3422) - PsiElement(OpenSCADTokenType.IDENTIFIER)('sma')(3413,3416) - PsiWhiteSpace(' ')(3416,3417) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3417,3418) - PsiWhiteSpace(' ')(3418,3419) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3419,3421) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(3419,3421) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3421,3422) - PsiWhiteSpace(' ')(3422,3424) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// semi-minor axis')(3424,3442) - PsiWhiteSpace('\n')(3442,3443) - OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3443,3452) - PsiElement(OpenSCADTokenType.IDENTIFIER)('smb')(3443,3446) - PsiWhiteSpace(' ')(3446,3447) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3447,3448) - PsiWhiteSpace(' ')(3448,3449) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3449,3451) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(3449,3451) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3451,3452) - PsiWhiteSpace(' ')(3452,3454) - PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// semi-major axis')(3454,3472) - PsiWhiteSpace('\n')(3472,3473) - OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(3473,3539) - OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(3473,3480) - PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(3473,3480) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3480,3538) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3480,3481) - PsiWhiteSpace('\n')(3481,3482) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3482,3536) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3482,3536) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3482,3483) - OpenSCADForElementImpl(FOR_ELEMENT)(3483,3506) - PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3483,3486) - PsiWhiteSpace(' ')(3486,3487) - OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3487,3506) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3487,3488) - OpenSCADForDeclarationImpl(FOR_DECLARATION)(3488,3505) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3488,3489) - PsiWhiteSpace(' ')(3489,3490) - PsiElement(OpenSCADTokenType.EQUALS)('=')(3490,3491) - PsiWhiteSpace(' ')(3491,3492) - OpenSCADRangeExprImpl(RANGE_EXPR)(3492,3505) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3492,3493) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3493,3494) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3493,3494) - PsiWhiteSpace(' ')(3494,3495) - PsiElement(OpenSCADTokenType.COLON)(':')(3495,3496) - PsiWhiteSpace(' ')(3496,3497) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3497,3498) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(3497,3498) - PsiWhiteSpace(' ')(3498,3499) - PsiElement(OpenSCADTokenType.COLON)(':')(3499,3500) - PsiWhiteSpace(' ')(3500,3501) - OpenSCADLiteralExprImpl(LITERAL_EXPR)(3501,3504) - PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('359')(3501,3504) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3504,3505) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3505,3506) - PsiWhiteSpace(' ')(3506,3507) - OpenSCADVectorExprImpl(VECTOR_EXPR)(3507,3535) - PsiElement(OpenSCADTokenType.LBRACKET)('[')(3507,3508) - OpenSCADMulExprImpl(MUL_EXPR)(3508,3520) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3508,3511) - PsiElement(OpenSCADTokenType.IDENTIFIER)('sma')(3508,3511) - PsiWhiteSpace(' ')(3511,3512) - PsiElement(OpenSCADTokenType.MUL)('*')(3512,3513) - PsiWhiteSpace(' ')(3513,3514) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3514,3520) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3514,3517) - PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3514,3517) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3517,3520) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3517,3518) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3518,3519) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3518,3519) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3518,3519) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3519,3520) - PsiElement(OpenSCADTokenType.COMMA)(',')(3520,3521) - PsiWhiteSpace(' ')(3521,3522) - OpenSCADMulExprImpl(MUL_EXPR)(3522,3534) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3522,3525) - PsiElement(OpenSCADTokenType.IDENTIFIER)('smb')(3522,3525) - PsiWhiteSpace(' ')(3525,3526) - PsiElement(OpenSCADTokenType.MUL)('*')(3526,3527) - PsiWhiteSpace(' ')(3527,3528) - OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3528,3534) - OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3528,3531) - PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3528,3531) - OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3531,3534) - PsiElement(OpenSCADTokenType.LPARENTH)('(')(3531,3532) - OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3532,3533) - OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3532,3533) - PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3532,3533) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3533,3534) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3534,3535) - PsiElement(OpenSCADTokenType.RBRACKET)(']')(3535,3536) - PsiWhiteSpace('\n')(3536,3537) - PsiElement(OpenSCADTokenType.RPARENTH)(')')(3537,3538) - PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3538,3539) \ No newline at end of file + OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(2983,2986) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(2983,2984) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(2983,2984) + PsiElement(OpenSCADTokenType.DOT)('.')(2984,2985) + PsiElement(OpenSCADTokenType.IDENTIFIER)('y')(2985,2986) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(2986,2987) + PsiWhiteSpace(' ')(2987,2991) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[1]')(2991,3011) + PsiWhiteSpace('\n')(3011,3012) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3012,3022) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_2')(3012,3015) + PsiWhiteSpace(' ')(3015,3016) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3016,3017) + PsiWhiteSpace(' ')(3017,3018) + OpenSCADQualificationExprImpl(QUALIFICATION_EXPR)(3018,3021) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3018,3019) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e')(3018,3019) + PsiElement(OpenSCADTokenType.DOT)('.')(3019,3020) + PsiElement(OpenSCADTokenType.IDENTIFIER)('z')(3020,3021) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3021,3022) + PsiWhiteSpace(' ')(3022,3026) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//equivalent to e[2]')(3026,3046) + PsiWhiteSpace('\n')(3046,3047) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(3047,3099) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(3047,3051) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(3047,3051) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3051,3098) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3051,3052) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3052,3060) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3052,3060) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"e_0 = "')(3052,3060) + PsiElement(OpenSCADTokenType.COMMA)(',')(3060,3061) + PsiWhiteSpace(' ')(3061,3062) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3062,3065) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3062,3065) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_0')(3062,3065) + PsiElement(OpenSCADTokenType.COMMA)(',')(3065,3066) + PsiWhiteSpace(' ')(3066,3067) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3067,3076) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3067,3076) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('" e_1 = "')(3067,3076) + PsiElement(OpenSCADTokenType.COMMA)(',')(3076,3077) + PsiWhiteSpace(' ')(3077,3078) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3078,3081) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3078,3081) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_1')(3078,3081) + PsiElement(OpenSCADTokenType.COMMA)(',')(3081,3082) + PsiWhiteSpace(' ')(3082,3083) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3083,3092) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3083,3092) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('" e_2 = "')(3083,3092) + PsiElement(OpenSCADTokenType.COMMA)(',')(3092,3093) + PsiWhiteSpace(' ')(3093,3094) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3094,3097) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3094,3097) + PsiElement(OpenSCADTokenType.IDENTIFIER)('e_2')(3094,3097) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3097,3098) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3098,3099) + PsiWhiteSpace('\n\n')(3099,3101) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//Example which defines a 2D rotation matrix')(3101,3145) + PsiWhiteSpace('\n')(3145,3146) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3146,3208) + PsiElement(OpenSCADTokenType.IDENTIFIER)('mr')(3146,3148) + PsiWhiteSpace(' ')(3148,3149) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3149,3150) + PsiWhiteSpace(' ')(3150,3151) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3151,3207) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3151,3152) + PsiWhiteSpace('\n')(3152,3153) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3153,3179) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3153,3154) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3154,3164) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3154,3157) + PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3154,3157) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3157,3164) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3157,3158) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3158,3163) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3158,3163) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3158,3163) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3163,3164) + PsiElement(OpenSCADTokenType.COMMA)(',')(3164,3165) + PsiWhiteSpace(' ')(3165,3166) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3166,3178) + PsiElement(OpenSCADTokenType.MINUS)('-')(3166,3167) + PsiWhiteSpace(' ')(3167,3168) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3168,3178) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3168,3171) + PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3168,3171) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3171,3178) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3171,3172) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3172,3177) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3172,3177) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3172,3177) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3177,3178) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3178,3179) + PsiElement(OpenSCADTokenType.COMMA)(',')(3179,3180) + PsiWhiteSpace('\n')(3180,3181) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3181,3205) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3181,3182) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3182,3192) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3182,3185) + PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3182,3185) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3185,3192) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3185,3186) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3186,3191) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3186,3191) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3186,3191) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3191,3192) + PsiElement(OpenSCADTokenType.COMMA)(',')(3192,3193) + PsiWhiteSpace(' ')(3193,3194) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3194,3204) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3194,3197) + PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3194,3197) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3197,3204) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3197,3198) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3198,3203) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3198,3203) + PsiElement(OpenSCADTokenType.IDENTIFIER)('angle')(3198,3203) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3203,3204) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3204,3205) + PsiWhiteSpace('\n')(3205,3206) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3206,3207) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3207,3208) + PsiWhiteSpace('\n\n')(3208,3210) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3210,3221) + PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3210,3215) + PsiWhiteSpace(' ')(3215,3216) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3216,3217) + PsiWhiteSpace(' ')(3217,3218) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3218,3220) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('50')(3218,3220) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3220,3221) + PsiWhiteSpace('\n')(3221,3222) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3222,3560) + PsiElement(OpenSCADTokenType.IDENTIFIER)('points')(3222,3228) + PsiWhiteSpace(' ')(3228,3229) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3229,3230) + PsiWhiteSpace(' ')(3230,3231) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3231,3559) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3231,3232) + PsiWhiteSpace('\n')(3232,3233) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// first expression generating the points in the positive Y quadrant')(3233,3301) + PsiWhiteSpace('\n')(3301,3302) + OpenSCADForElementImpl(FOR_ELEMENT)(3302,3323) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3302,3305) + PsiWhiteSpace(' ')(3305,3306) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3306,3323) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3306,3307) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3307,3322) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3307,3308) + PsiWhiteSpace(' ')(3308,3309) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3309,3310) + PsiWhiteSpace(' ')(3310,3311) + OpenSCADRangeExprImpl(RANGE_EXPR)(3311,3322) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3311,3312) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3312,3313) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3312,3313) + PsiWhiteSpace(' ')(3313,3314) + PsiElement(OpenSCADTokenType.COLON)(':')(3314,3315) + PsiWhiteSpace(' ')(3315,3316) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3316,3321) + PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3316,3321) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3321,3322) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3322,3323) + PsiWhiteSpace(' ')(3323,3324) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3324,3359) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3324,3325) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3325,3326) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3325,3326) + PsiElement(OpenSCADTokenType.COMMA)(',')(3326,3327) + PsiWhiteSpace(' ')(3327,3328) + OpenSCADPlusExprImpl(PLUS_EXPR)(3328,3358) + OpenSCADMulExprImpl(MUL_EXPR)(3328,3353) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3328,3330) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3328,3330) + PsiWhiteSpace(' ')(3330,3331) + PsiElement(OpenSCADTokenType.MUL)('*')(3331,3332) + PsiWhiteSpace(' ')(3332,3333) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3333,3353) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3333,3336) + PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3333,3336) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3336,3353) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3336,3337) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3337,3352) + OpenSCADDivExprImpl(DIV_EXPR)(3337,3352) + OpenSCADMulExprImpl(MUL_EXPR)(3337,3344) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3337,3338) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3337,3338) + PsiWhiteSpace(' ')(3338,3339) + PsiElement(OpenSCADTokenType.MUL)('*')(3339,3340) + PsiWhiteSpace(' ')(3340,3341) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3341,3344) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('360')(3341,3344) + PsiWhiteSpace(' ')(3344,3345) + PsiElement(OpenSCADTokenType.DIV)('/')(3345,3346) + PsiWhiteSpace(' ')(3346,3347) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3347,3352) + PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3347,3352) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3352,3353) + PsiWhiteSpace(' ')(3353,3354) + PsiElement(OpenSCADTokenType.PLUS)('+')(3354,3355) + PsiWhiteSpace(' ')(3355,3356) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3356,3358) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3356,3358) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3358,3359) + PsiElement(OpenSCADTokenType.COMMA)(',')(3359,3360) + PsiWhiteSpace('\n')(3360,3361) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// second expression generating the points in the negative Y quadrant')(3361,3430) + PsiWhiteSpace('\n')(3430,3431) + OpenSCADForElementImpl(FOR_ELEMENT)(3431,3458) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3431,3434) + PsiWhiteSpace(' ')(3434,3435) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3435,3458) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3435,3436) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3436,3457) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3436,3437) + PsiWhiteSpace(' ')(3437,3438) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3438,3439) + PsiWhiteSpace(' ')(3439,3440) + OpenSCADRangeExprImpl(RANGE_EXPR)(3440,3457) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3440,3441) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3441,3446) + PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3441,3446) + PsiWhiteSpace(' ')(3446,3447) + PsiElement(OpenSCADTokenType.COLON)(':')(3447,3448) + PsiWhiteSpace(' ')(3448,3449) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3449,3452) + PsiElement(OpenSCADTokenType.MINUS)('-')(3449,3450) + PsiWhiteSpace(' ')(3450,3451) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3451,3452) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3451,3452) + PsiWhiteSpace(' ')(3452,3453) + PsiElement(OpenSCADTokenType.COLON)(':')(3453,3454) + PsiWhiteSpace(' ')(3454,3455) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3455,3456) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3455,3456) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3456,3457) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3457,3458) + PsiWhiteSpace(' ')(3458,3459) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3459,3494) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3459,3460) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3460,3461) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3460,3461) + PsiElement(OpenSCADTokenType.COMMA)(',')(3461,3462) + PsiWhiteSpace(' ')(3462,3463) + OpenSCADMinusExprImpl(MINUS_EXPR)(3463,3493) + OpenSCADMulExprImpl(MUL_EXPR)(3463,3488) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3463,3465) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3463,3465) + PsiWhiteSpace(' ')(3465,3466) + PsiElement(OpenSCADTokenType.MUL)('*')(3466,3467) + PsiWhiteSpace(' ')(3467,3468) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3468,3488) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3468,3471) + PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3468,3471) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3471,3488) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3471,3472) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3472,3487) + OpenSCADDivExprImpl(DIV_EXPR)(3472,3487) + OpenSCADMulExprImpl(MUL_EXPR)(3472,3479) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3472,3473) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3472,3473) + PsiWhiteSpace(' ')(3473,3474) + PsiElement(OpenSCADTokenType.MUL)('*')(3474,3475) + PsiWhiteSpace(' ')(3475,3476) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3476,3479) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('360')(3476,3479) + PsiWhiteSpace(' ')(3479,3480) + PsiElement(OpenSCADTokenType.DIV)('/')(3480,3481) + PsiWhiteSpace(' ')(3481,3482) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3482,3487) + PsiElement(OpenSCADTokenType.IDENTIFIER)('steps')(3482,3487) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3487,3488) + PsiWhiteSpace(' ')(3488,3489) + PsiElement(OpenSCADTokenType.MINUS)('-')(3489,3490) + PsiWhiteSpace(' ')(3490,3491) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3491,3493) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(3491,3493) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3493,3494) + PsiElement(OpenSCADTokenType.COMMA)(',')(3494,3495) + PsiWhiteSpace('\n')(3495,3496) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// additional list of fixed points')(3496,3530) + PsiWhiteSpace('\n')(3530,3531) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3531,3540) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3531,3532) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3532,3534) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3532,3534) + PsiElement(OpenSCADTokenType.COMMA)(',')(3534,3535) + PsiWhiteSpace(' ')(3535,3536) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(3536,3539) + PsiElement(OpenSCADTokenType.MINUS)('-')(3536,3537) + PsiWhiteSpace(' ')(3537,3538) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3538,3539) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3538,3539) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3539,3540) + PsiElement(OpenSCADTokenType.COMMA)(',')(3540,3541) + PsiWhiteSpace(' ')(3541,3542) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3542,3548) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3542,3543) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3543,3544) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3543,3544) + PsiElement(OpenSCADTokenType.COMMA)(',')(3544,3545) + PsiWhiteSpace(' ')(3545,3546) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3546,3547) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3546,3547) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3547,3548) + PsiElement(OpenSCADTokenType.COMMA)(',')(3548,3549) + PsiWhiteSpace(' ')(3549,3550) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3550,3557) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3550,3551) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3551,3553) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(3551,3553) + PsiElement(OpenSCADTokenType.COMMA)(',')(3553,3554) + PsiWhiteSpace(' ')(3554,3555) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3555,3556) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(3555,3556) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3556,3557) + PsiWhiteSpace('\n')(3557,3558) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3558,3559) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3559,3560) + PsiWhiteSpace('\n')(3560,3561) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(3561,3577) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(3561,3568) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(3561,3568) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3568,3576) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3568,3569) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3569,3575) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3569,3575) + PsiElement(OpenSCADTokenType.IDENTIFIER)('points')(3569,3575) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3575,3576) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3576,3577) + PsiWhiteSpace('\n\n')(3577,3579) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3579,3588) + PsiElement(OpenSCADTokenType.IDENTIFIER)('sma')(3579,3582) + PsiWhiteSpace(' ')(3582,3583) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3583,3584) + PsiWhiteSpace(' ')(3584,3585) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3585,3587) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('20')(3585,3587) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3587,3588) + PsiWhiteSpace(' ')(3588,3590) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// semi-minor axis')(3590,3608) + PsiWhiteSpace('\n')(3608,3609) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3609,3618) + PsiElement(OpenSCADTokenType.IDENTIFIER)('smb')(3609,3612) + PsiWhiteSpace(' ')(3612,3613) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3613,3614) + PsiWhiteSpace(' ')(3614,3615) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3615,3617) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(3615,3617) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3617,3618) + PsiWhiteSpace(' ')(3618,3620) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// semi-major axis')(3620,3638) + PsiWhiteSpace('\n')(3638,3639) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(3639,3705) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(3639,3646) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(3639,3646) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3646,3704) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3646,3647) + PsiWhiteSpace('\n')(3647,3648) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3648,3702) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3648,3702) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3648,3649) + OpenSCADForElementImpl(FOR_ELEMENT)(3649,3672) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3649,3652) + PsiWhiteSpace(' ')(3652,3653) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3653,3672) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3653,3654) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3654,3671) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3654,3655) + PsiWhiteSpace(' ')(3655,3656) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3656,3657) + PsiWhiteSpace(' ')(3657,3658) + OpenSCADRangeExprImpl(RANGE_EXPR)(3658,3671) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3658,3659) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3659,3660) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3659,3660) + PsiWhiteSpace(' ')(3660,3661) + PsiElement(OpenSCADTokenType.COLON)(':')(3661,3662) + PsiWhiteSpace(' ')(3662,3663) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3663,3664) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(3663,3664) + PsiWhiteSpace(' ')(3664,3665) + PsiElement(OpenSCADTokenType.COLON)(':')(3665,3666) + PsiWhiteSpace(' ')(3666,3667) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3667,3670) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('359')(3667,3670) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3670,3671) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3671,3672) + PsiWhiteSpace(' ')(3672,3673) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3673,3701) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3673,3674) + OpenSCADMulExprImpl(MUL_EXPR)(3674,3686) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3674,3677) + PsiElement(OpenSCADTokenType.IDENTIFIER)('sma')(3674,3677) + PsiWhiteSpace(' ')(3677,3678) + PsiElement(OpenSCADTokenType.MUL)('*')(3678,3679) + PsiWhiteSpace(' ')(3679,3680) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3680,3686) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3680,3683) + PsiElement(OpenSCADTokenType.SIN_KEYWORD)('sin')(3680,3683) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3683,3686) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3683,3684) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3684,3685) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3684,3685) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3684,3685) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3685,3686) + PsiElement(OpenSCADTokenType.COMMA)(',')(3686,3687) + PsiWhiteSpace(' ')(3687,3688) + OpenSCADMulExprImpl(MUL_EXPR)(3688,3700) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3688,3691) + PsiElement(OpenSCADTokenType.IDENTIFIER)('smb')(3688,3691) + PsiWhiteSpace(' ')(3691,3692) + PsiElement(OpenSCADTokenType.MUL)('*')(3692,3693) + PsiWhiteSpace(' ')(3693,3694) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(3694,3700) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(3694,3697) + PsiElement(OpenSCADTokenType.COS_KEYWORD)('cos')(3694,3697) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(3697,3700) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3697,3698) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(3698,3699) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3698,3699) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(3698,3699) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3699,3700) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3700,3701) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3701,3702) + PsiWhiteSpace('\n')(3702,3703) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3703,3704) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3704,3705) + PsiWhiteSpace('\n\n')(3705,3707) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// Optional parentheses around the body of the for loop in the vector item, or around the vector item')(3707,3808) + PsiWhiteSpace('\n')(3808,3809) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3809,3864) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(3809,3819) + PsiWhiteSpace(' ')(3819,3820) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3820,3821) + PsiWhiteSpace(' ')(3821,3822) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3822,3863) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3822,3823) + PsiWhiteSpace(' ')(3823,3824) + OpenSCADForElementImpl(FOR_ELEMENT)(3824,3838) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3824,3827) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3827,3838) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3827,3828) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3828,3837) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3828,3829) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3829,3830) + OpenSCADRangeExprImpl(RANGE_EXPR)(3830,3837) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3830,3831) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3831,3832) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3831,3832) + PsiElement(OpenSCADTokenType.COLON)(':')(3832,3833) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3833,3834) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3833,3834) + PsiElement(OpenSCADTokenType.COLON)(':')(3834,3835) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3835,3836) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(3835,3836) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3836,3837) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3837,3838) + PsiWhiteSpace(' ')(3838,3839) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(3839,3854) + PsiWhiteSpace(' ')(3854,3855) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(3855,3862) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(3855,3862) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(3855,3859) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(3859,3862) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3859,3860) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3860,3861) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3860,3861) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3861,3862) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3862,3863) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3863,3864) + PsiWhiteSpace('\n')(3864,3865) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3865,3924) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(3865,3875) + PsiWhiteSpace(' ')(3875,3876) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3876,3877) + PsiWhiteSpace(' ')(3877,3878) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3878,3923) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3878,3879) + PsiWhiteSpace(' ')(3879,3880) + OpenSCADForElementImpl(FOR_ELEMENT)(3880,3894) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3880,3883) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3883,3894) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3883,3884) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3884,3893) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3884,3885) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3885,3886) + OpenSCADRangeExprImpl(RANGE_EXPR)(3886,3893) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3886,3887) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3887,3888) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3887,3888) + PsiElement(OpenSCADTokenType.COLON)(':')(3888,3889) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3889,3890) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3889,3890) + PsiElement(OpenSCADTokenType.COLON)(':')(3890,3891) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3891,3892) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(3891,3892) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3892,3893) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3893,3894) + PsiWhiteSpace(' ')(3894,3895) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(3895,3910) + PsiWhiteSpace(' ')(3910,3911) + OpenSCADIfElementImpl(IF_ELEMENT)(3911,3920) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(3911,3913) + PsiWhiteSpace(' ')(3913,3914) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3914,3915) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3915,3919) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(3915,3919) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3919,3920) + PsiWhiteSpace(' ')(3920,3921) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3921,3922) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3921,3922) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3922,3923) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3923,3924) + PsiWhiteSpace('\n')(3924,3925) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3925,3968) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(3925,3935) + PsiWhiteSpace(' ')(3935,3936) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3936,3937) + PsiWhiteSpace(' ')(3937,3938) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3938,3967) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3938,3939) + PsiWhiteSpace(' ')(3939,3940) + OpenSCADForElementImpl(FOR_ELEMENT)(3940,3954) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3940,3943) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3943,3954) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3943,3944) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3944,3953) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3944,3945) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3945,3946) + OpenSCADRangeExprImpl(RANGE_EXPR)(3946,3953) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3946,3947) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3947,3948) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3947,3948) + PsiElement(OpenSCADTokenType.COLON)(':')(3948,3949) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3949,3950) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3949,3950) + PsiElement(OpenSCADTokenType.COLON)(':')(3950,3951) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3951,3952) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(3951,3952) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3952,3953) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3953,3954) + PsiWhiteSpace(' ')(3954,3955) + OpenSCADIfElementImpl(IF_ELEMENT)(3955,3964) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(3955,3957) + PsiWhiteSpace(' ')(3957,3958) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3958,3959) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3959,3963) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(3959,3963) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3963,3964) + PsiWhiteSpace(' ')(3964,3965) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(3965,3966) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3965,3966) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3966,3967) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(3967,3968) + PsiWhiteSpace('\n')(3968,3969) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(3969,4014) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(3969,3979) + PsiWhiteSpace(' ')(3979,3980) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3980,3981) + PsiWhiteSpace(' ')(3981,3982) + OpenSCADVectorExprImpl(VECTOR_EXPR)(3982,4013) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3982,3983) + PsiWhiteSpace(' ')(3983,3984) + OpenSCADForElementImpl(FOR_ELEMENT)(3984,3998) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(3984,3987) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(3987,3998) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(3987,3988) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(3988,3997) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(3988,3989) + PsiElement(OpenSCADTokenType.EQUALS)('=')(3989,3990) + OpenSCADRangeExprImpl(RANGE_EXPR)(3990,3997) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(3990,3991) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3991,3992) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(3991,3992) + PsiElement(OpenSCADTokenType.COLON)(':')(3992,3993) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3993,3994) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(3993,3994) + PsiElement(OpenSCADTokenType.COLON)(':')(3994,3995) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(3995,3996) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(3995,3996) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(3996,3997) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(3997,3998) + PsiWhiteSpace(' ')(3998,3999) + OpenSCADIfElementImpl(IF_ELEMENT)(3999,4008) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(3999,4001) + PsiWhiteSpace(' ')(4001,4002) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4002,4003) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4003,4007) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4003,4007) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4007,4008) + PsiWhiteSpace(' ')(4008,4009) + OpenSCADParenExprImpl(PAREN_EXPR)(4009,4012) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4009,4010) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4010,4011) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4010,4011) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4011,4012) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4012,4013) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4013,4014) + PsiWhiteSpace('\n')(4014,4015) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4015,4133) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(4015,4025) + PsiWhiteSpace(' ')(4025,4026) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4026,4027) + PsiWhiteSpace(' ')(4027,4028) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4028,4132) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4028,4029) + PsiWhiteSpace(' ')(4029,4030) + OpenSCADForElementImpl(FOR_ELEMENT)(4030,4044) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4030,4033) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4033,4044) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4033,4034) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4034,4043) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4034,4035) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4035,4036) + OpenSCADRangeExprImpl(RANGE_EXPR)(4036,4043) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4036,4037) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4037,4038) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4037,4038) + PsiElement(OpenSCADTokenType.COLON)(':')(4038,4039) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4039,4040) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4039,4040) + PsiElement(OpenSCADTokenType.COLON)(':')(4040,4041) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4041,4042) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4041,4042) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4042,4043) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4043,4044) + PsiWhiteSpace(' ')(4044,4045) + OpenSCADIfElementImpl(IF_ELEMENT)(4045,4054) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4045,4047) + PsiWhiteSpace(' ')(4047,4048) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4048,4049) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4049,4053) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4049,4053) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4053,4054) + PsiWhiteSpace(' ')(4054,4055) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4055,4070) + PsiWhiteSpace('\n ')(4070,4075) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('//')(4075,4077) + PsiWhiteSpace('\n ')(4077,4082) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4082,4089) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4082,4089) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4082,4086) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4086,4089) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4086,4087) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4087,4088) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4087,4088) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4088,4089) + PsiWhiteSpace(' ')(4089,4090) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4090,4097) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4090,4097) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4090,4094) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4094,4097) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4094,4095) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4095,4096) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4095,4096) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4096,4097) + PsiWhiteSpace(' ')(4097,4098) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4098,4127) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(4098,4127) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(4098,4104) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(4104,4127) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4104,4105) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4105,4109) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4105,4109) + PsiElement(OpenSCADTokenType.COMMA)(',')(4109,4110) + PsiWhiteSpace(' ')(4110,4111) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4111,4126) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"assert string"')(4111,4126) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4126,4127) + PsiWhiteSpace(' ')(4127,4128) + OpenSCADParenExprImpl(PAREN_EXPR)(4128,4131) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4128,4129) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4129,4130) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4129,4130) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4130,4131) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4131,4132) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4132,4133) + PsiWhiteSpace('\n')(4133,4134) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4134,4225) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(4134,4144) + PsiWhiteSpace(' ')(4144,4145) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4145,4146) + PsiWhiteSpace(' ')(4146,4147) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4147,4224) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4147,4148) + PsiWhiteSpace(' ')(4148,4149) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4149,4164) + PsiWhiteSpace(' ')(4164,4165) + OpenSCADForElementImpl(FOR_ELEMENT)(4165,4179) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4165,4168) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4168,4179) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4168,4169) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4169,4178) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4169,4170) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4170,4171) + OpenSCADRangeExprImpl(RANGE_EXPR)(4171,4178) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4171,4172) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4172,4173) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4172,4173) + PsiElement(OpenSCADTokenType.COLON)(':')(4173,4174) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4174,4175) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4174,4175) + PsiElement(OpenSCADTokenType.COLON)(':')(4175,4176) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4176,4177) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4176,4177) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4177,4178) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4178,4179) + PsiWhiteSpace(' ')(4179,4180) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4180,4195) + PsiWhiteSpace(' ')(4195,4196) + OpenSCADIfElementImpl(IF_ELEMENT)(4196,4205) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4196,4198) + PsiWhiteSpace(' ')(4198,4199) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4199,4200) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4200,4204) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4200,4204) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4204,4205) + PsiWhiteSpace(' ')(4205,4206) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4206,4221) + PsiWhiteSpace(' ')(4221,4222) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4222,4223) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4222,4223) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4223,4224) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4224,4225) + PsiWhiteSpace('\n')(4225,4226) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4226,4341) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(4226,4236) + PsiWhiteSpace(' ')(4236,4237) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4237,4238) + PsiWhiteSpace(' ')(4238,4239) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4239,4340) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4239,4240) + PsiWhiteSpace(' ')(4240,4241) + OpenSCADForElementImpl(FOR_ELEMENT)(4241,4255) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4241,4244) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4244,4255) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4244,4245) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4245,4254) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4245,4246) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4246,4247) + OpenSCADRangeExprImpl(RANGE_EXPR)(4247,4254) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4247,4248) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4248,4249) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4248,4249) + PsiElement(OpenSCADTokenType.COLON)(':')(4249,4250) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4250,4251) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4250,4251) + PsiElement(OpenSCADTokenType.COLON)(':')(4251,4252) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4252,4253) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4252,4253) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4253,4254) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4254,4255) + PsiWhiteSpace(' ')(4255,4256) + OpenSCADIfElementImpl(IF_ELEMENT)(4256,4265) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4256,4258) + PsiWhiteSpace(' ')(4258,4259) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4259,4260) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4260,4264) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4260,4264) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4264,4265) + PsiWhiteSpace(' ')(4265,4266) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4266,4281) + PsiWhiteSpace(' ')(4281,4282) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4282,4289) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4282,4289) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4282,4286) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4286,4289) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4286,4287) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4287,4288) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4287,4288) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4288,4289) + PsiWhiteSpace(' ')(4289,4290) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4290,4297) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4290,4297) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4290,4294) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4294,4297) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4294,4295) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4295,4296) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4295,4296) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4296,4297) + PsiWhiteSpace(' ')(4297,4298) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4298,4335) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(4298,4335) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(4298,4304) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(4304,4335) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4304,4305) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4305,4309) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4305,4309) + PsiElement(OpenSCADTokenType.COMMA)(',')(4309,4310) + PsiWhiteSpace(' ')(4310,4311) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4311,4334) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"was true, returning i"')(4311,4334) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4334,4335) + PsiWhiteSpace(' ')(4335,4336) + OpenSCADParenExprImpl(PAREN_EXPR)(4336,4339) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4336,4337) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4337,4338) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4337,4338) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4338,4339) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4339,4340) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4340,4341) + PsiWhiteSpace('\n')(4341,4342) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4342,4453) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(4342,4352) + PsiWhiteSpace(' ')(4352,4353) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4353,4354) + PsiWhiteSpace(' ')(4354,4355) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4355,4452) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4355,4356) + PsiWhiteSpace(' ')(4356,4357) + OpenSCADForElementImpl(FOR_ELEMENT)(4357,4371) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4357,4360) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4360,4371) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4360,4361) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4361,4370) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4361,4362) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4362,4363) + OpenSCADRangeExprImpl(RANGE_EXPR)(4363,4370) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4363,4364) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4364,4365) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4364,4365) + PsiElement(OpenSCADTokenType.COLON)(':')(4365,4366) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4366,4367) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4366,4367) + PsiElement(OpenSCADTokenType.COLON)(':')(4367,4368) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4368,4369) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4368,4369) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4369,4370) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4370,4371) + PsiWhiteSpace(' ')(4371,4372) + OpenSCADIfElementImpl(IF_ELEMENT)(4372,4381) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4372,4374) + PsiWhiteSpace(' ')(4374,4375) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4375,4376) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4376,4380) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4376,4380) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4380,4381) + PsiWhiteSpace(' ')(4381,4382) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* a comment */')(4382,4397) + PsiWhiteSpace(' ')(4397,4398) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4398,4405) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4398,4405) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4398,4402) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4402,4405) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4402,4403) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4403,4404) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4403,4404) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4404,4405) + PsiWhiteSpace(' ')(4405,4406) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4406,4413) + OpenSCADEchoElementImpl(ECHO_ELEMENT)(4406,4413) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4406,4410) + OpenSCADEchoArgListImpl(ECHO_ARG_LIST)(4410,4413) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4410,4411) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4411,4412) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4411,4412) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4412,4413) + PsiWhiteSpace(' ')(4413,4414) + OpenSCADReportingElementImpl(REPORTING_ELEMENT)(4414,4451) + OpenSCADAssertElementImpl(ASSERT_ELEMENT)(4414,4451) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(4414,4420) + OpenSCADAssertArgListImpl(ASSERT_ARG_LIST)(4420,4451) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4420,4421) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4421,4425) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4421,4425) + PsiElement(OpenSCADTokenType.COMMA)(',')(4425,4426) + PsiWhiteSpace(' ')(4426,4427) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4427,4450) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"was true, just report"')(4427,4450) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4450,4451) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4451,4452) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4452,4453) + PsiWhiteSpace('\n')(4453,4454) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(4454,4471) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(4454,4458) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4454,4458) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(4458,4470) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4458,4459) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(4459,4469) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4459,4469) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items')(4459,4469) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4469,4470) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4470,4471) + PsiWhiteSpace('\n\n')(4471,4473) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0, 1, 2]')(4473,4491) + PsiWhiteSpace('\n')(4491,4492) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4492,4550) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items_with_paren')(4492,4513) + PsiWhiteSpace(' ')(4513,4514) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4514,4515) + PsiWhiteSpace(' ')(4515,4516) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4516,4549) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4516,4517) + PsiWhiteSpace(' ')(4517,4518) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4518,4519) + PsiWhiteSpace(' ')(4519,4520) + OpenSCADForElementImpl(FOR_ELEMENT)(4520,4534) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4520,4523) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4523,4534) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4523,4524) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4524,4533) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4524,4525) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4525,4526) + OpenSCADRangeExprImpl(RANGE_EXPR)(4526,4533) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4526,4527) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4527,4528) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4527,4528) + PsiElement(OpenSCADTokenType.COLON)(':')(4528,4529) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4529,4530) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4529,4530) + PsiElement(OpenSCADTokenType.COLON)(':')(4530,4531) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4531,4532) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4531,4532) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4532,4533) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4533,4534) + PsiWhiteSpace(' ')(4534,4535) + OpenSCADIfElementImpl(IF_ELEMENT)(4535,4544) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4535,4537) + PsiWhiteSpace(' ')(4537,4538) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4538,4539) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4539,4543) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4539,4543) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4543,4544) + PsiWhiteSpace(' ')(4544,4545) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4545,4546) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4545,4546) + PsiWhiteSpace(' ')(4546,4547) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4547,4548) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4548,4549) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4549,4550) + PsiWhiteSpace('\n')(4550,4551) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(4551,4579) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(4551,4555) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4551,4555) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(4555,4578) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4555,4556) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(4556,4577) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4556,4577) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items_with_paren')(4556,4577) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4577,4578) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4578,4579) + PsiWhiteSpace('\n')(4579,4580) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0, 1, 2]')(4580,4598) + PsiWhiteSpace('\n')(4598,4599) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4599,4666) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items_with_paren_for_body')(4599,4629) + PsiWhiteSpace(' ')(4629,4630) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4630,4631) + PsiWhiteSpace(' ')(4631,4632) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4632,4665) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4632,4633) + PsiWhiteSpace(' ')(4633,4634) + OpenSCADForElementImpl(FOR_ELEMENT)(4634,4648) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4634,4637) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4637,4648) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4637,4638) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4638,4647) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4638,4639) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4639,4640) + OpenSCADRangeExprImpl(RANGE_EXPR)(4640,4647) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4640,4641) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4641,4642) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4641,4642) + PsiElement(OpenSCADTokenType.COLON)(':')(4642,4643) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4643,4644) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4643,4644) + PsiElement(OpenSCADTokenType.COLON)(':')(4644,4645) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4645,4646) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4645,4646) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4646,4647) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4647,4648) + PsiWhiteSpace(' ')(4648,4649) + OpenSCADBindElseElementImpl(BIND_ELSE_ELEMENT)(4649,4664) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4649,4650) + PsiWhiteSpace(' ')(4650,4651) + OpenSCADIfElementImpl(IF_ELEMENT)(4651,4660) + PsiElement(OpenSCADTokenType.IF_KEYWORD)('if')(4651,4653) + PsiWhiteSpace(' ')(4653,4654) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4654,4655) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4655,4659) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(4655,4659) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4659,4660) + PsiWhiteSpace(' ')(4660,4661) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4661,4662) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4661,4662) + PsiWhiteSpace(' ')(4662,4663) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4663,4664) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4664,4665) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4665,4666) + PsiWhiteSpace('\n')(4666,4667) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(4667,4704) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(4667,4671) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(4667,4671) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(4671,4703) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4671,4672) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(4672,4702) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4672,4702) + PsiElement(OpenSCADTokenType.IDENTIFIER)('list_items_with_paren_for_body')(4672,4702) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4702,4703) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4703,4704) + PsiWhiteSpace('\n')(4704,4705) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [0, 1, 2]')(4705,4723) + PsiWhiteSpace('\n')(4723,4724) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4724,4778) + PsiElement(OpenSCADTokenType.IDENTIFIER)('q')(4724,4725) + PsiWhiteSpace(' ')(4725,4726) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4726,4727) + PsiWhiteSpace(' ')(4727,4728) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4728,4777) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4728,4729) + OpenSCADForElementImpl(FOR_ELEMENT)(4729,4751) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(4729,4732) + OpenSCADForDeclarationListImpl(FOR_DECLARATION_LIST)(4732,4751) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4732,4733) + OpenSCADForDeclarationImpl(FOR_DECLARATION)(4733,4750) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4733,4734) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4734,4735) + OpenSCADRangeExprImpl(RANGE_EXPR)(4735,4750) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4735,4736) + OpenSCADMinusExprImpl(MINUS_EXPR)(4736,4744) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(4736,4742) + OpenSCADBuiltinExprRefImpl(BUILTIN_EXPR_REF)(4736,4739) + PsiElement(OpenSCADTokenType.LEN_KEYWORD)('len')(4736,4739) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(4739,4742) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4739,4740) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(4740,4741) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4740,4741) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(4740,4741) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4741,4742) + PsiElement(OpenSCADTokenType.MINUS)('-')(4742,4743) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4743,4744) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4743,4744) + PsiElement(OpenSCADTokenType.COLON)(':')(4744,4745) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(4745,4747) + PsiElement(OpenSCADTokenType.MINUS)('-')(4745,4746) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4746,4747) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4746,4747) + PsiElement(OpenSCADTokenType.COLON)(':')(4747,4748) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4748,4749) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4748,4749) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4749,4750) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4750,4751) + PsiWhiteSpace(' ')(4751,4752) + OpenSCADMulExprImpl(MUL_EXPR)(4752,4758) + OpenSCADIndexExprImpl(INDEX_EXPR)(4752,4756) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4752,4753) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(4752,4753) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4753,4754) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4754,4755) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(4754,4755) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4755,4756) + PsiElement(OpenSCADTokenType.MUL)('*')(4756,4757) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4757,4758) + PsiElement(OpenSCADTokenType.IDENTIFIER)('n')(4757,4758) + PsiElement(OpenSCADTokenType.COMMA)(',')(4758,4759) + PsiWhiteSpace(' ')(4759,4760) + OpenSCADMulExprImpl(MUL_EXPR)(4760,4776) + OpenSCADParenExprImpl(PAREN_EXPR)(4760,4774) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(4760,4761) + OpenSCADMinusExprImpl(MINUS_EXPR)(4761,4773) + OpenSCADIndexExprImpl(INDEX_EXPR)(4761,4765) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4761,4762) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(4761,4762) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4762,4763) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4763,4764) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4763,4764) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4764,4765) + PsiElement(OpenSCADTokenType.MINUS)('-')(4765,4766) + OpenSCADIndexExprImpl(INDEX_EXPR)(4766,4773) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4766,4770) + PsiElement(OpenSCADTokenType.IDENTIFIER)('line')(4766,4770) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4770,4771) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4771,4772) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(4771,4772) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4772,4773) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(4773,4774) + PsiElement(OpenSCADTokenType.MUL)('*')(4774,4775) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(4775,4776) + PsiElement(OpenSCADTokenType.IDENTIFIER)('n')(4775,4776) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4776,4777) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4777,4778) + PsiWhiteSpace('\n\n')(4778,4780) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4780,4803) + PsiElement(OpenSCADTokenType.IDENTIFIER)('a')(4780,4781) + PsiWhiteSpace(' ')(4781,4782) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4782,4783) + PsiWhiteSpace(' ')(4783,4784) + OpenSCADPlusExprImpl(PLUS_EXPR)(4784,4802) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4784,4785) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4784,4785) + PsiWhiteSpace(' ')(4785,4786) + PsiElement(OpenSCADTokenType.PLUS)('+')(4786,4787) + PsiWhiteSpace(' ')(4787,4788) + PsiComment(OpenSCADTokenType.COMMENT_C_STYLE)('/* adfadf */')(4788,4800) + PsiWhiteSpace(' ')(4800,4801) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4801,4802) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(4801,4802) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4802,4803) + PsiWhiteSpace('\n\n')(4803,4805) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// This next line will give an error')(4805,4841) + PsiWhiteSpace('\n')(4841,4842) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(4842,4867) + PsiElement(OpenSCADTokenType.IDENTIFIER)('too_many_commas')(4842,4857) + PsiWhiteSpace(' ')(4857,4858) + PsiElement(OpenSCADTokenType.EQUALS)('=')(4858,4859) + PsiWhiteSpace(' ')(4859,4860) + OpenSCADVectorExprImpl(VECTOR_EXPR)(4860,4866) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(4860,4861) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4861,4862) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(4861,4862) + PsiElement(OpenSCADTokenType.COMMA)(',')(4862,4863) + PsiErrorElement:, , OpenSCADTokenType.COMMENT_CUSTOMIZER_TABS, OpenSCADTokenType.COMMENT_CUSTOMIZER_VALUE, OpenSCADTokenType.COMMENT_C_STYLE, OpenSCADTokenType.COMMENT_DOC, OpenSCADTokenType.COMMENT_SINGLELINE, OpenSCADTokenType.COMMENT_SINGLELINE_BLOCK, OpenSCADTokenType.EACH_KEYWORD, OpenSCADTokenType.ELSE_KEYWORD, OpenSCADTokenType.FOR_KEYWORD, OpenSCADTokenType.IF_KEYWORD, OpenSCADTokenType.LET_KEYWORD or OpenSCADTokenType.LPARENTH expected, got ','(4863,4863) + + PsiElement(OpenSCADTokenType.COMMA)(',')(4863,4864) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(4864,4865) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('2')(4864,4865) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(4865,4866) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(4866,4867) \ No newline at end of file diff --git a/src/test/testData/openscad/parser/bosl2/FunctionsAndModules.scad b/src/test/testData/openscad/parser/bosl2/FunctionsAndModules.scad new file mode 100644 index 0000000..b08eb08 --- /dev/null +++ b/src/test/testData/openscad/parser/bosl2/FunctionsAndModules.scad @@ -0,0 +1,53 @@ +include + +// square as a function +linear_extrude(height = 5) + polygon(square([3, 4], center = true)); + +R1 = [square(10,center=true), square(9,center=true)]; +echo(R1[1]); +// ECHO: [[4.5, -4.5], [-4.5, -4.5], [-4.5, 4.5], [4.5, 4.5]] + +R2 = [square(9,center=true)]; + +// union as a function +assert(are_regions_equal(union(R1,R2), [square(10,center=true)])); + +// union and square as modules +union() +{ + square(10,center=true); + square(9,center=false); +} + +// intersection as function +R6 = [square(9.5,center=true), square(9,center=true)]; +assert(are_regions_equal(intersection(R6,R1), R6)); +assert(are_regions_equal(intersection(R1,R6), R6)); + +// intersection as module +right(15) +color("green") + intersection() + { + for (i = [0:1]) + { + polygon(R1[i]); + polygon(R6[i]); + } + } + +// move, difference, and circle as functions +shape1 = move([-8,-8,0], p=circle(d=30)); +shape2 = move([ 8, 8,0], p=circle(d=30)); +color("blue") left(60) region(difference(shape1,shape2)); + +// move, difference, and circle as modules +color("orange") + left(30) + difference() + { + move([-8,-8,0]) circle(d=30); + move([ 8, 8,0]) circle(d=30); + } + diff --git a/src/test/testData/openscad/parser/bosl2/FunctionsAndModules_psidump.txt b/src/test/testData/openscad/parser/bosl2/FunctionsAndModules_psidump.txt new file mode 100644 index 0000000..3f7e17a --- /dev/null +++ b/src/test/testData/openscad/parser/bosl2/FunctionsAndModules_psidump.txt @@ -0,0 +1,724 @@ +OpenSCAD File(0,1209) + OpenSCADImportImpl(IMPORT)(0,24) + OpenSCADIncludeImportImpl(INCLUDE_IMPORT)(0,24) + PsiElement(OpenSCADTokenType.INCLUDE_KEYWORD)('include')(0,7) + PsiWhiteSpace(' ')(7,8) + PsiElement(OpenSCADTokenType.IMPORT_START)('<')(8,9) + OpenSCADImportPathRefImpl(IMPORT_PATH_REF)(9,23) + PsiElement(OpenSCADTokenType.IMPORT_PATH)('BOSL2/std.scad')(9,23) + PsiElement(OpenSCADTokenType.IMPORT_END)('>')(23,24) + PsiWhiteSpace('\n\n')(24,26) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// square as a function')(26,49) + PsiWhiteSpace('\n')(49,50) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(50,120) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(50,76) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(50,64) + PsiElement(OpenSCADTokenType.LINEAR_EXTRUDE_KEYWORD)('linear_extrude')(50,64) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(64,76) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(64,65) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(65,75) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(65,71) + PsiElement(OpenSCADTokenType.IDENTIFIER)('height')(65,71) + PsiWhiteSpace(' ')(71,72) + PsiElement(OpenSCADTokenType.EQUALS)('=')(72,73) + PsiWhiteSpace(' ')(73,74) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(74,75) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('5')(74,75) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(75,76) + PsiWhiteSpace('\n ')(76,81) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(81,120) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(81,88) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(81,88) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(88,119) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(88,89) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(89,118) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(89,118) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(89,118) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(89,95) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(89,95) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(95,118) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(95,96) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(96,102) + OpenSCADVectorExprImpl(VECTOR_EXPR)(96,102) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(96,97) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(97,98) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('3')(97,98) + PsiElement(OpenSCADTokenType.COMMA)(',')(98,99) + PsiWhiteSpace(' ')(99,100) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(100,101) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('4')(100,101) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(101,102) + PsiElement(OpenSCADTokenType.COMMA)(',')(102,103) + PsiWhiteSpace(' ')(103,104) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(104,117) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(104,110) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(104,110) + PsiWhiteSpace(' ')(110,111) + PsiElement(OpenSCADTokenType.EQUALS)('=')(111,112) + PsiWhiteSpace(' ')(112,113) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(113,117) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(113,117) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(117,118) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(118,119) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(119,120) + PsiWhiteSpace('\n\n')(120,122) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(122,175) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(122,124) + PsiWhiteSpace(' ')(124,125) + PsiElement(OpenSCADTokenType.EQUALS)('=')(125,126) + PsiWhiteSpace(' ')(126,127) + OpenSCADVectorExprImpl(VECTOR_EXPR)(127,174) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(127,128) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(128,150) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(128,150) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(128,134) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(128,134) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(134,150) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(134,135) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(135,137) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(135,137) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(135,137) + PsiElement(OpenSCADTokenType.COMMA)(',')(137,138) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(138,149) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(138,144) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(138,144) + PsiElement(OpenSCADTokenType.EQUALS)('=')(144,145) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(145,149) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(145,149) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(149,150) + PsiElement(OpenSCADTokenType.COMMA)(',')(150,151) + PsiWhiteSpace(' ')(151,152) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(152,173) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(152,173) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(152,158) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(152,158) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(158,173) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(158,159) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(159,160) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(159,160) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(159,160) + PsiElement(OpenSCADTokenType.COMMA)(',')(160,161) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(161,172) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(161,167) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(161,167) + PsiElement(OpenSCADTokenType.EQUALS)('=')(167,168) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(168,172) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(168,172) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(172,173) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(173,174) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(174,175) + PsiWhiteSpace('\n')(175,176) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(176,188) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(176,180) + PsiElement(OpenSCADTokenType.ECHO_KEYWORD)('echo')(176,180) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(180,187) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(180,181) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(181,186) + OpenSCADIndexExprImpl(INDEX_EXPR)(181,186) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(181,183) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(181,183) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(183,184) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(184,185) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(184,185) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(185,186) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(186,187) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(187,188) + PsiWhiteSpace('\n')(188,189) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// ECHO: [[4.5, -4.5], [-4.5, -4.5], [-4.5, 4.5], [4.5, 4.5]]')(189,250) + PsiWhiteSpace('\n\n')(250,252) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(252,281) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R2')(252,254) + PsiWhiteSpace(' ')(254,255) + PsiElement(OpenSCADTokenType.EQUALS)('=')(255,256) + PsiWhiteSpace(' ')(256,257) + OpenSCADVectorExprImpl(VECTOR_EXPR)(257,280) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(257,258) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(258,279) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(258,279) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(258,264) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(258,264) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(264,279) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(264,265) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(265,266) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(265,266) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(265,266) + PsiElement(OpenSCADTokenType.COMMA)(',')(266,267) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(267,278) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(267,273) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(267,273) + PsiElement(OpenSCADTokenType.EQUALS)('=')(273,274) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(274,278) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(274,278) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(278,279) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(279,280) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(280,281) + PsiWhiteSpace('\n\n')(281,283) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// union as a function')(283,305) + PsiWhiteSpace('\n')(305,306) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(306,372) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(306,312) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(306,312) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(312,371) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(312,313) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(313,370) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(313,370) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(313,330) + PsiElement(OpenSCADTokenType.IDENTIFIER)('are_regions_equal')(313,330) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(330,370) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(330,331) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(331,343) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(331,343) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(331,343) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(331,336) + PsiElement(OpenSCADTokenType.UNION_KEYWORD)('union')(331,336) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(336,343) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(336,337) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(337,339) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(337,339) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(337,339) + PsiElement(OpenSCADTokenType.COMMA)(',')(339,340) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(340,342) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(340,342) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R2')(340,342) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(342,343) + PsiElement(OpenSCADTokenType.COMMA)(',')(343,344) + PsiWhiteSpace(' ')(344,345) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(345,369) + OpenSCADVectorExprImpl(VECTOR_EXPR)(345,369) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(345,346) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(346,368) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(346,368) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(346,352) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(346,352) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(352,368) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(352,353) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(353,355) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(353,355) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(353,355) + PsiElement(OpenSCADTokenType.COMMA)(',')(355,356) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(356,367) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(356,362) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(356,362) + PsiElement(OpenSCADTokenType.EQUALS)('=')(362,363) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(363,367) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(363,367) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(367,368) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(368,369) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(369,370) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(370,371) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(371,372) + PsiWhiteSpace('\n\n')(372,374) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// union and square as modules')(374,404) + PsiWhiteSpace('\n')(404,405) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(405,472) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(405,412) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(405,410) + PsiElement(OpenSCADTokenType.UNION_KEYWORD)('union')(405,410) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(410,412) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(410,411) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(411,412) + PsiWhiteSpace('\n')(412,413) + OpenSCADBlockObjImpl(BLOCK_OBJ)(413,472) + PsiElement(OpenSCADTokenType.LBRACE)('{')(413,414) + PsiWhiteSpace('\n ')(414,419) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(419,442) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(419,425) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(419,425) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(425,441) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(425,426) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(426,428) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(426,428) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('10')(426,428) + PsiElement(OpenSCADTokenType.COMMA)(',')(428,429) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(429,440) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(429,435) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(429,435) + PsiElement(OpenSCADTokenType.EQUALS)('=')(435,436) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(436,440) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(436,440) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(440,441) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(441,442) + PsiWhiteSpace('\n ')(442,447) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(447,470) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(447,453) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(447,453) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(453,469) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(453,454) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(454,455) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(454,455) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(454,455) + PsiElement(OpenSCADTokenType.COMMA)(',')(455,456) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(456,468) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(456,462) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(456,462) + PsiElement(OpenSCADTokenType.EQUALS)('=')(462,463) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(463,468) + PsiElement(OpenSCADTokenType.FALSE_KEYWORD)('false')(463,468) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(468,469) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(469,470) + PsiWhiteSpace('\n')(470,471) + PsiElement(OpenSCADTokenType.RBRACE)('}')(471,472) + PsiWhiteSpace('\n\n')(472,474) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// intersection as function')(474,501) + PsiWhiteSpace('\n')(501,502) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(502,556) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(502,504) + PsiWhiteSpace(' ')(504,505) + PsiElement(OpenSCADTokenType.EQUALS)('=')(505,506) + PsiWhiteSpace(' ')(506,507) + OpenSCADVectorExprImpl(VECTOR_EXPR)(507,555) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(507,508) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(508,531) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(508,531) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(508,514) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(508,514) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(514,531) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(514,515) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(515,518) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(515,518) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9.5')(515,518) + PsiElement(OpenSCADTokenType.COMMA)(',')(518,519) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(519,530) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(519,525) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(519,525) + PsiElement(OpenSCADTokenType.EQUALS)('=')(525,526) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(526,530) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(526,530) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(530,531) + PsiElement(OpenSCADTokenType.COMMA)(',')(531,532) + PsiWhiteSpace(' ')(532,533) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(533,554) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(533,554) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(533,539) + PsiElement(OpenSCADTokenType.SQUARE_KEYWORD)('square')(533,539) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(539,554) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(539,540) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(540,541) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(540,541) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('9')(540,541) + PsiElement(OpenSCADTokenType.COMMA)(',')(541,542) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(542,553) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(542,548) + PsiElement(OpenSCADTokenType.IDENTIFIER)('center')(542,548) + PsiElement(OpenSCADTokenType.EQUALS)('=')(548,549) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(549,553) + PsiElement(OpenSCADTokenType.TRUE_KEYWORD)('true')(549,553) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(553,554) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(554,555) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(555,556) + PsiWhiteSpace('\n')(556,557) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(557,608) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(557,563) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(557,563) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(563,607) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(563,564) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(564,606) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(564,606) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(564,581) + PsiElement(OpenSCADTokenType.IDENTIFIER)('are_regions_equal')(564,581) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(581,606) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(581,582) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(582,601) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(582,601) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(582,601) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(582,594) + PsiElement(OpenSCADTokenType.INTERSECTION_KEYWORD)('intersection')(582,594) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(594,601) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(594,595) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(595,597) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(595,597) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(595,597) + PsiElement(OpenSCADTokenType.COMMA)(',')(597,598) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(598,600) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(598,600) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(598,600) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(600,601) + PsiElement(OpenSCADTokenType.COMMA)(',')(601,602) + PsiWhiteSpace(' ')(602,603) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(603,605) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(603,605) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(603,605) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(605,606) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(606,607) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(607,608) + PsiWhiteSpace('\n')(608,609) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(609,660) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(609,615) + PsiElement(OpenSCADTokenType.ASSERT_KEYWORD)('assert')(609,615) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(615,659) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(615,616) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(616,658) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(616,658) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(616,633) + PsiElement(OpenSCADTokenType.IDENTIFIER)('are_regions_equal')(616,633) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(633,658) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(633,634) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(634,653) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(634,653) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(634,653) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(634,646) + PsiElement(OpenSCADTokenType.INTERSECTION_KEYWORD)('intersection')(634,646) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(646,653) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(646,647) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(647,649) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(647,649) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(647,649) + PsiElement(OpenSCADTokenType.COMMA)(',')(649,650) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(650,652) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(650,652) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(650,652) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(652,653) + PsiElement(OpenSCADTokenType.COMMA)(',')(653,654) + PsiWhiteSpace(' ')(654,655) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(655,657) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(655,657) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(655,657) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(657,658) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(658,659) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(659,660) + PsiWhiteSpace('\n\n')(660,662) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// intersection as module')(662,687) + PsiWhiteSpace('\n')(687,688) + OpenSCADObjectImpl(OBJECT)(688,843) + OpenSCADModuleCallOpImpl(MODULE_CALL_OP)(688,697) + OpenSCADModuleOpNameRefImpl(MODULE_OP_NAME_REF)(688,693) + PsiElement(OpenSCADTokenType.IDENTIFIER)('right')(688,693) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(693,697) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(693,694) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(694,696) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(694,696) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('15')(694,696) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(696,697) + PsiWhiteSpace('\n')(697,698) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(698,843) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(698,712) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(698,703) + PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(698,703) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(703,712) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(703,704) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(704,711) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(704,711) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"green"')(704,711) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(711,712) + PsiWhiteSpace('\n ')(712,717) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(717,843) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(717,731) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(717,729) + PsiElement(OpenSCADTokenType.INTERSECTION_KEYWORD)('intersection')(717,729) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(729,731) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(729,730) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(730,731) + PsiWhiteSpace('\n ')(731,736) + OpenSCADBlockObjImpl(BLOCK_OBJ)(736,843) + PsiElement(OpenSCADTokenType.LBRACE)('{')(736,737) + PsiWhiteSpace('\n ')(737,746) + OpenSCADForObjImpl(FOR_OBJ)(746,837) + PsiElement(OpenSCADTokenType.FOR_KEYWORD)('for')(746,749) + PsiWhiteSpace(' ')(749,750) + OpenSCADFullArgDeclarationListImpl(FULL_ARG_DECLARATION_LIST)(750,761) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(750,751) + OpenSCADFullArgDeclarationImpl(FULL_ARG_DECLARATION)(751,760) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(751,752) + PsiWhiteSpace(' ')(752,753) + PsiElement(OpenSCADTokenType.EQUALS)('=')(753,754) + PsiWhiteSpace(' ')(754,755) + OpenSCADRangeExprImpl(RANGE_EXPR)(755,760) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(755,756) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(756,757) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(756,757) + PsiElement(OpenSCADTokenType.COLON)(':')(757,758) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(758,759) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('1')(758,759) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(759,760) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(760,761) + PsiWhiteSpace('\n ')(761,770) + OpenSCADBlockObjImpl(BLOCK_OBJ)(770,837) + PsiElement(OpenSCADTokenType.LBRACE)('{')(770,771) + PsiWhiteSpace('\n ')(771,784) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(784,799) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(784,791) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(784,791) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(791,798) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(791,792) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(792,797) + OpenSCADIndexExprImpl(INDEX_EXPR)(792,797) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(792,794) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R1')(792,794) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(794,795) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(795,796) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(795,796) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(796,797) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(797,798) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(798,799) + PsiWhiteSpace('\n ')(799,812) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(812,827) + OpenSCADBuiltinObjRefImpl(BUILTIN_OBJ_REF)(812,819) + PsiElement(OpenSCADTokenType.POLYGON_KEYWORD)('polygon')(812,819) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(819,826) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(819,820) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(820,825) + OpenSCADIndexExprImpl(INDEX_EXPR)(820,825) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(820,822) + PsiElement(OpenSCADTokenType.IDENTIFIER)('R6')(820,822) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(822,823) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(823,824) + PsiElement(OpenSCADTokenType.IDENTIFIER)('i')(823,824) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(824,825) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(825,826) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(826,827) + PsiWhiteSpace('\n ')(827,836) + PsiElement(OpenSCADTokenType.RBRACE)('}')(836,837) + PsiWhiteSpace('\n ')(837,842) + PsiElement(OpenSCADTokenType.RBRACE)('}')(842,843) + PsiWhiteSpace('\n\n')(843,845) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// move, difference, and circle as functions')(845,889) + PsiWhiteSpace('\n')(889,890) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(890,931) + PsiElement(OpenSCADTokenType.IDENTIFIER)('shape1')(890,896) + PsiWhiteSpace(' ')(896,897) + PsiElement(OpenSCADTokenType.EQUALS)('=')(897,898) + PsiWhiteSpace(' ')(898,899) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(899,930) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(899,903) + PsiElement(OpenSCADTokenType.IDENTIFIER)('move')(899,903) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(903,930) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(903,904) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(904,913) + OpenSCADVectorExprImpl(VECTOR_EXPR)(904,913) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(904,905) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(905,907) + PsiElement(OpenSCADTokenType.MINUS)('-')(905,906) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(906,907) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(906,907) + PsiElement(OpenSCADTokenType.COMMA)(',')(907,908) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(908,910) + PsiElement(OpenSCADTokenType.MINUS)('-')(908,909) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(909,910) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(909,910) + PsiElement(OpenSCADTokenType.COMMA)(',')(910,911) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(911,912) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(911,912) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(912,913) + PsiElement(OpenSCADTokenType.COMMA)(',')(913,914) + PsiWhiteSpace(' ')(914,915) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(915,929) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(915,916) + PsiElement(OpenSCADTokenType.IDENTIFIER)('p')(915,916) + PsiElement(OpenSCADTokenType.EQUALS)('=')(916,917) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(917,929) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(917,929) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(917,923) + PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(917,923) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(923,929) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(923,924) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(924,928) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(924,925) + PsiElement(OpenSCADTokenType.IDENTIFIER)('d')(924,925) + PsiElement(OpenSCADTokenType.EQUALS)('=')(925,926) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(926,928) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(926,928) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(928,929) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(929,930) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(930,931) + PsiWhiteSpace('\n')(931,932) + OpenSCADVariableDeclarationImpl(OPEN_SCAD_VARIABLE)(932,973) + PsiElement(OpenSCADTokenType.IDENTIFIER)('shape2')(932,938) + PsiWhiteSpace(' ')(938,939) + PsiElement(OpenSCADTokenType.EQUALS)('=')(939,940) + PsiWhiteSpace(' ')(940,941) + OpenSCADFunctionCallExprImpl(FUNCTION_CALL_EXPR)(941,972) + OpenSCADFunctionNameRefImpl(FUNCTION_NAME_REF)(941,945) + PsiElement(OpenSCADTokenType.IDENTIFIER)('move')(941,945) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(945,972) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(945,946) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(946,955) + OpenSCADVectorExprImpl(VECTOR_EXPR)(946,955) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(946,947) + PsiWhiteSpace(' ')(947,948) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(948,949) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(948,949) + PsiElement(OpenSCADTokenType.COMMA)(',')(949,950) + PsiWhiteSpace(' ')(950,951) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(951,952) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(951,952) + PsiElement(OpenSCADTokenType.COMMA)(',')(952,953) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(953,954) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(953,954) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(954,955) + PsiElement(OpenSCADTokenType.COMMA)(',')(955,956) + PsiWhiteSpace(' ')(956,957) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(957,971) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(957,958) + PsiElement(OpenSCADTokenType.IDENTIFIER)('p')(957,958) + PsiElement(OpenSCADTokenType.EQUALS)('=')(958,959) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(959,971) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(959,971) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(959,965) + PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(959,965) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(965,971) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(965,966) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(966,970) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(966,967) + PsiElement(OpenSCADTokenType.IDENTIFIER)('d')(966,967) + PsiElement(OpenSCADTokenType.EQUALS)('=')(967,968) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(968,970) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(968,970) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(970,971) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(971,972) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(972,973) + PsiWhiteSpace('\n')(973,974) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(974,1031) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(974,987) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(974,979) + PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(974,979) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(979,987) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(979,980) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(980,986) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(980,986) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"blue"')(980,986) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(986,987) + PsiWhiteSpace(' ')(987,988) + OpenSCADObjectImpl(OBJECT)(988,1031) + OpenSCADModuleCallOpImpl(MODULE_CALL_OP)(988,996) + OpenSCADModuleOpNameRefImpl(MODULE_OP_NAME_REF)(988,992) + PsiElement(OpenSCADTokenType.IDENTIFIER)('left')(988,992) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(992,996) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(992,993) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(993,995) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(993,995) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('60')(993,995) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(995,996) + PsiWhiteSpace(' ')(996,997) + OpenSCADModuleCallObjImpl(MODULE_CALL_OBJ)(997,1031) + OpenSCADModuleObjNameRefImpl(MODULE_OBJ_NAME_REF)(997,1003) + PsiElement(OpenSCADTokenType.IDENTIFIER)('region')(997,1003) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1003,1030) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1003,1004) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1004,1029) + OpenSCADBuiltinExprImpl(BUILTIN_EXPR)(1004,1029) + OpenSCADBuiltinOverridableExprRefImpl(BUILTIN_OVERRIDABLE_EXPR_REF)(1004,1029) + OpenSCADBuiltinOverridableOpAsFunctionRefImpl(BUILTIN_OVERRIDABLE_OP_AS_FUNCTION_REF)(1004,1014) + PsiElement(OpenSCADTokenType.DIFFERENCE_KEYWORD)('difference')(1004,1014) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1014,1029) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1014,1015) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1015,1021) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1015,1021) + PsiElement(OpenSCADTokenType.IDENTIFIER)('shape1')(1015,1021) + PsiElement(OpenSCADTokenType.COMMA)(',')(1021,1022) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1022,1028) + OpenSCADVariableRefExprImpl(VARIABLE_REF_EXPR)(1022,1028) + PsiElement(OpenSCADTokenType.IDENTIFIER)('shape2')(1022,1028) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1028,1029) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1029,1030) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1030,1031) + PsiWhiteSpace('\n\n')(1031,1033) + PsiComment(OpenSCADTokenType.COMMENT_SINGLELINE)('// move, difference, and circle as modules')(1033,1075) + PsiWhiteSpace('\n')(1075,1076) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1076,1209) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(1076,1091) + OpenSCADCommonOpRefImpl(COMMON_OP_REF)(1076,1081) + PsiElement(OpenSCADTokenType.COLOR_KEYWORD)('color')(1076,1081) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1081,1091) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1081,1082) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1082,1090) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1082,1090) + PsiElement(OpenSCADTokenType.STRING_LITERAL)('"orange"')(1082,1090) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1090,1091) + PsiWhiteSpace('\n ')(1091,1096) + OpenSCADObjectImpl(OBJECT)(1096,1209) + OpenSCADModuleCallOpImpl(MODULE_CALL_OP)(1096,1104) + OpenSCADModuleOpNameRefImpl(MODULE_OP_NAME_REF)(1096,1100) + PsiElement(OpenSCADTokenType.IDENTIFIER)('left')(1096,1100) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1100,1104) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1100,1101) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1101,1103) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1101,1103) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(1101,1103) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1103,1104) + PsiWhiteSpace('\n ')(1104,1109) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1109,1209) + OpenSCADBuiltinOpImpl(BUILTIN_OP)(1109,1121) + OpenSCADBuiltinOverridableOpRefImpl(BUILTIN_OVERRIDABLE_OP_REF)(1109,1119) + PsiElement(OpenSCADTokenType.DIFFERENCE_KEYWORD)('difference')(1109,1119) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1119,1121) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1119,1120) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1120,1121) + PsiWhiteSpace('\n ')(1121,1126) + OpenSCADBlockObjImpl(BLOCK_OBJ)(1126,1209) + PsiElement(OpenSCADTokenType.LBRACE)('{')(1126,1127) + PsiWhiteSpace('\n ')(1127,1136) + OpenSCADObjectImpl(OBJECT)(1136,1165) + OpenSCADModuleCallOpImpl(MODULE_CALL_OP)(1136,1151) + OpenSCADModuleOpNameRefImpl(MODULE_OP_NAME_REF)(1136,1140) + PsiElement(OpenSCADTokenType.IDENTIFIER)('move')(1136,1140) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1140,1151) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1140,1141) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1141,1150) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1141,1150) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1141,1142) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(1142,1144) + PsiElement(OpenSCADTokenType.MINUS)('-')(1142,1143) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1143,1144) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(1143,1144) + PsiElement(OpenSCADTokenType.COMMA)(',')(1144,1145) + OpenSCADUnaryMinExprImpl(UNARY_MIN_EXPR)(1145,1147) + PsiElement(OpenSCADTokenType.MINUS)('-')(1145,1146) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1146,1147) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(1146,1147) + PsiElement(OpenSCADTokenType.COMMA)(',')(1147,1148) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1148,1149) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1148,1149) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1149,1150) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1150,1151) + PsiWhiteSpace(' ')(1151,1152) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1152,1165) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(1152,1158) + PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(1152,1158) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1158,1164) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1158,1159) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1159,1163) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(1159,1160) + PsiElement(OpenSCADTokenType.IDENTIFIER)('d')(1159,1160) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1160,1161) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1161,1163) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(1161,1163) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1163,1164) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1164,1165) + PsiWhiteSpace('\n ')(1165,1174) + OpenSCADObjectImpl(OBJECT)(1174,1203) + OpenSCADModuleCallOpImpl(MODULE_CALL_OP)(1174,1189) + OpenSCADModuleOpNameRefImpl(MODULE_OP_NAME_REF)(1174,1178) + PsiElement(OpenSCADTokenType.IDENTIFIER)('move')(1174,1178) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1178,1189) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1178,1179) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1179,1188) + OpenSCADVectorExprImpl(VECTOR_EXPR)(1179,1188) + PsiElement(OpenSCADTokenType.LBRACKET)('[')(1179,1180) + PsiWhiteSpace(' ')(1180,1181) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1181,1182) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(1181,1182) + PsiElement(OpenSCADTokenType.COMMA)(',')(1182,1183) + PsiWhiteSpace(' ')(1183,1184) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1184,1185) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('8')(1184,1185) + PsiElement(OpenSCADTokenType.COMMA)(',')(1185,1186) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1186,1187) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('0')(1186,1187) + PsiElement(OpenSCADTokenType.RBRACKET)(']')(1187,1188) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1188,1189) + PsiWhiteSpace(' ')(1189,1190) + OpenSCADBuiltinObjImpl(BUILTIN_OBJ)(1190,1203) + OpenSCADBuiltinOverridableObjRefImpl(BUILTIN_OVERRIDABLE_OBJ_REF)(1190,1196) + PsiElement(OpenSCADTokenType.CIRCLE_KEYWORD)('circle')(1190,1196) + OpenSCADArgAssignmentListImpl(ARG_ASSIGNMENT_LIST)(1196,1202) + PsiElement(OpenSCADTokenType.LPARENTH)('(')(1196,1197) + OpenSCADArgAssignmentImpl(ARG_ASSIGNMENT)(1197,1201) + OpenSCADParameterReferenceImpl(PARAMETER_REFERENCE)(1197,1198) + PsiElement(OpenSCADTokenType.IDENTIFIER)('d')(1197,1198) + PsiElement(OpenSCADTokenType.EQUALS)('=')(1198,1199) + OpenSCADLiteralExprImpl(LITERAL_EXPR)(1199,1201) + PsiElement(OpenSCADTokenType.NUMBER_LITERAL)('30')(1199,1201) + PsiElement(OpenSCADTokenType.RPARENTH)(')')(1201,1202) + PsiElement(OpenSCADTokenType.SEMICOLON)(';')(1202,1203) + PsiWhiteSpace('\n ')(1203,1208) + PsiElement(OpenSCADTokenType.RBRACE)('}')(1208,1209) \ No newline at end of file