MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

regen parsers

Browse Source 
GitOrigin-RevId: d700d17b9077c085c9c4e2865a217fd11e29e5ea
This commit is contained in:
Gregory.Shrago
2020-05-13 14:41:03 +00:00
committed by intellij-monorepo-bot
parent cc946b54f3
commit ea0888e433
10 changed files with 216 additions and 467 deletions
Download Patch File Download Diff File Expand all files Collapse all files
json/gen/com/intellij/json/JsonElementTypes.java
+1 -1
View File
@@ -38,7 +38,7 @@ public interface JsonElementTypes {
class Factory {
public static PsiElement createElement(ASTNode node) {
IElementType type = node.getElementType();
if (type == ARRAY) {
if (type == ARRAY) {
return new JsonArrayImpl(node);
}
else if (type == BOOLEAN_LITERAL) {
json/gen/com/intellij/json/JsonParser.java
+8 -40
View File
@@ -23,43 +23,15 @@ public class JsonParser implements PsiParser, LightPsiParser {
boolean r;
b = adapt_builder_(t, b, this, EXTENDS_SETS_);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
if (t == ARRAY) {
r = array(b, 0);
}
else if (t == BOOLEAN_LITERAL) {
r = boolean_literal(b, 0);
}
else if (t == LITERAL) {
r = literal(b, 0);
}
else if (t == NULL_LITERAL) {
r = null_literal(b, 0);
}
else if (t == NUMBER_LITERAL) {
r = number_literal(b, 0);
}
else if (t == OBJECT) {
r = object(b, 0);
}
else if (t == PROPERTY) {
r = property(b, 0);
}
else if (t == REFERENCE_EXPRESSION) {
r = reference_expression(b, 0);
}
else if (t == STRING_LITERAL) {
r = string_literal(b, 0);
}
else if (t == VALUE) {
r = value(b, 0);
}
else {
r = parse_root_(t, b, 0);
}
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
protected boolean parse_root_(IElementType t, PsiBuilder b) {
return parse_root_(t, b, 0);
}
static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return json(b, l + 1);
}
@@ -187,10 +159,8 @@ public class JsonParser implements PsiParser, LightPsiParser {
private static boolean not_brace_or_next_value_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "not_brace_or_next_value_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, R_CURLY);
if (!r) r = value(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@@ -209,10 +179,8 @@ public class JsonParser implements PsiParser, LightPsiParser {
private static boolean not_bracket_or_next_value_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "not_bracket_or_next_value_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, R_BRACKET);
if (!r) r = value(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@@ -374,12 +342,12 @@ public class JsonParser implements PsiParser, LightPsiParser {
return r;
}
final static Parser not_brace_or_next_value_parser_ = new Parser() {
static final Parser not_brace_or_next_value_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return not_brace_or_next_value(b, l + 1);
}
};
final static Parser not_bracket_or_next_value_parser_ = new Parser() {
static final Parser not_bracket_or_next_value_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return not_bracket_or_next_value(b, l + 1);
}
platform/vcs-impl/gen/com/intellij/openapi/vcs/changes/ignore/parser/IgnoreParser.java
+188 -215
View File
@@ -1,342 +1,315 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
// This is a generated file. Not intended for manual editing.
package com.intellij.openapi.vcs.changes.ignore.parser;
import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static com.intellij.lang.parser.GeneratedParserUtilBase.*;
import static com.intellij.openapi.vcs.changes.ignore.psi.IgnoreTypes.*;
import static com.intellij.lang.parser.GeneratedParserUtilBase.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.lang.ASTNode;
import com.intellij.psi.tree.TokenSet;
import com.intellij.lang.PsiParser;
import com.intellij.lang.LightPsiParser;
@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class IgnoreParser implements PsiParser {
public class IgnoreParser implements PsiParser, LightPsiParser {
public ASTNode parse(IElementType root_, PsiBuilder builder_) {
parseLight(root_, builder_);
return builder_.getTreeBuilt();
public ASTNode parse(IElementType t, PsiBuilder b) {
parseLight(t, b);
return b.getTreeBuilt();
}
public void parseLight(IElementType root_, PsiBuilder builder_) {
boolean result_;
builder_ = adapt_builder_(root_, builder_, this, EXTENDS_SETS_);
Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
if (root_ == ENTRY) {
result_ = ENTRY(builder_, 0);
}
else if (root_ == ENTRY_DIRECTORY) {
result_ = ENTRY_DIRECTORY(builder_, 0);
}
else if (root_ == ENTRY_FILE) {
result_ = ENTRY_FILE(builder_, 0);
}
else if (root_ == NEGATION) {
result_ = NEGATION(builder_, 0);
}
else if (root_ == SYNTAX) {
result_ = SYNTAX(builder_, 0);
}
else {
result_ = parse_root_(root_, builder_, 0);
}
exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
public void parseLight(IElementType t, PsiBuilder b) {
boolean r;
b = adapt_builder_(t, b, this, EXTENDS_SETS_);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
return ignoreFile(builder_, level_ + 1);
protected boolean parse_root_(IElementType t, PsiBuilder b) {
return parse_root_(t, b, 0);
}
static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return ignoreFile(b, l + 1);
}
public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
create_token_set_(ENTRY_DIRECTORY, ENTRY_FILE),
create_token_set_(ENTRY, ENTRY_DIRECTORY, ENTRY_FILE),
};
/* ********************************************************** */
// NEGATION ? SLASH ? <<list_macro value_>>
public static boolean ENTRY(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<entry>");
result_ = ENTRY_0(builder_, level_ + 1);
result_ = result_ && ENTRY_1(builder_, level_ + 1);
result_ = result_ && list_macro(builder_, level_ + 1, value__parser_);
exit_section_(builder_, level_, marker_, ENTRY, result_, false, null);
return result_;
public static boolean ENTRY(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, ENTRY, "<entry>");
r = ENTRY_0(b, l + 1);
r = r && ENTRY_1(b, l + 1);
r = r && list_macro(b, l + 1, value__parser_);
exit_section_(b, l, m, r, false, null);
return r;
}
// NEGATION ?
private static boolean ENTRY_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_0")) return false;
NEGATION(builder_, level_ + 1);
private static boolean ENTRY_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_0")) return false;
NEGATION(b, l + 1);
return true;
}
// SLASH ?
private static boolean ENTRY_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_1")) return false;
consumeToken(builder_, SLASH);
private static boolean ENTRY_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_1")) return false;
consumeToken(b, SLASH);
return true;
}
/* ********************************************************** */
// NEGATION ? SLASH ? <<list_macro value_>> SLASH
public static boolean ENTRY_DIRECTORY(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_DIRECTORY")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<entry>");
result_ = ENTRY_DIRECTORY_0(builder_, level_ + 1);
result_ = result_ && ENTRY_DIRECTORY_1(builder_, level_ + 1);
result_ = result_ && list_macro(builder_, level_ + 1, value__parser_);
result_ = result_ && consumeToken(builder_, SLASH);
exit_section_(builder_, level_, marker_, ENTRY_DIRECTORY, result_, false, null);
return result_;
public static boolean ENTRY_DIRECTORY(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_DIRECTORY")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, ENTRY_DIRECTORY, "<entry>");
r = ENTRY_DIRECTORY_0(b, l + 1);
r = r && ENTRY_DIRECTORY_1(b, l + 1);
r = r && list_macro(b, l + 1, value__parser_);
r = r && consumeToken(b, SLASH);
exit_section_(b, l, m, r, false, null);
return r;
}
// NEGATION ?
private static boolean ENTRY_DIRECTORY_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_DIRECTORY_0")) return false;
NEGATION(builder_, level_ + 1);
private static boolean ENTRY_DIRECTORY_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_DIRECTORY_0")) return false;
NEGATION(b, l + 1);
return true;
}
// SLASH ?
private static boolean ENTRY_DIRECTORY_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_DIRECTORY_1")) return false;
consumeToken(builder_, SLASH);
private static boolean ENTRY_DIRECTORY_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_DIRECTORY_1")) return false;
consumeToken(b, SLASH);
return true;
}
/* ********************************************************** */
// NEGATION ? SLASH ? <<list_macro value_>>
public static boolean ENTRY_FILE(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_FILE")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<entry>");
result_ = ENTRY_FILE_0(builder_, level_ + 1);
result_ = result_ && ENTRY_FILE_1(builder_, level_ + 1);
result_ = result_ && list_macro(builder_, level_ + 1, value__parser_);
exit_section_(builder_, level_, marker_, ENTRY_FILE, result_, false, null);
return result_;
public static boolean ENTRY_FILE(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_FILE")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, ENTRY_FILE, "<entry>");
r = ENTRY_FILE_0(b, l + 1);
r = r && ENTRY_FILE_1(b, l + 1);
r = r && list_macro(b, l + 1, value__parser_);
exit_section_(b, l, m, r, false, null);
return r;
}
// NEGATION ?
private static boolean ENTRY_FILE_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_FILE_0")) return false;
NEGATION(builder_, level_ + 1);
private static boolean ENTRY_FILE_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_FILE_0")) return false;
NEGATION(b, l + 1);
return true;
}
// SLASH ?
private static boolean ENTRY_FILE_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ENTRY_FILE_1")) return false;
consumeToken(builder_, SLASH);
private static boolean ENTRY_FILE_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ENTRY_FILE_1")) return false;
consumeToken(b, SLASH);
return true;
}
/* ********************************************************** */
// "!"
public static boolean NEGATION(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "NEGATION")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<negation>");
result_ = consumeToken(builder_, "!");
exit_section_(builder_, level_, marker_, NEGATION, result_, false, null);
return result_;
public static boolean NEGATION(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NEGATION")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, NEGATION, "<negation>");
r = consumeToken(b, "!");
exit_section_(b, l, m, r, false, null);
return r;
}
/* ********************************************************** */
// SYNTAX_KEY CRLF * VALUE
public static boolean SYNTAX(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "SYNTAX")) return false;
if (!nextTokenIs(builder_, SYNTAX_KEY)) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, SYNTAX_KEY);
result_ = result_ && SYNTAX_1(builder_, level_ + 1);
result_ = result_ && consumeToken(builder_, VALUE);
exit_section_(builder_, marker_, SYNTAX, result_);
return result_;
public static boolean SYNTAX(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SYNTAX")) return false;
if (!nextTokenIs(b, SYNTAX_KEY)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SYNTAX_KEY);
r = r && SYNTAX_1(b, l + 1);
r = r && consumeToken(b, VALUE);
exit_section_(b, m, SYNTAX, r);
return r;
}
// CRLF *
private static boolean SYNTAX_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "SYNTAX_1")) return false;
int pos_ = current_position_(builder_);
private static boolean SYNTAX_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SYNTAX_1")) return false;
while (true) {
if (!consumeToken(builder_, CRLF)) break;
if (!empty_element_parsed_guard_(builder_, "SYNTAX_1", pos_)) break;
pos_ = current_position_(builder_);
int c = current_position_(b);
if (!consumeToken(b, CRLF)) break;
if (!empty_element_parsed_guard_(b, "SYNTAX_1", c)) break;
}
return true;
}
/* ********************************************************** */
// BRACKET_LEFT ( VALUE SLASH ? ) + BRACKET_RIGHT
static boolean bvalue_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "bvalue_")) return false;
if (!nextTokenIs(builder_, BRACKET_LEFT)) return false;
boolean result_, pinned_;
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
result_ = consumeToken(builder_, BRACKET_LEFT);
pinned_ = result_; // pin = BRACKET_LEFT
result_ = result_ && report_error_(builder_, bvalue__1(builder_, level_ + 1));
result_ = pinned_ && consumeToken(builder_, BRACKET_RIGHT) && result_;
exit_section_(builder_, level_, marker_, null, result_, pinned_, null);
return result_ || pinned_;
static boolean bvalue_(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "bvalue_")) return false;
if (!nextTokenIs(b, BRACKET_LEFT)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
r = consumeToken(b, BRACKET_LEFT);
p = r; // pin = BRACKET_LEFT
r = r && report_error_(b, bvalue__1(b, l + 1));
r = p && consumeToken(b, BRACKET_RIGHT) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
// ( VALUE SLASH ? ) +
private static boolean bvalue__1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "bvalue__1")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = bvalue__1_0(builder_, level_ + 1);
int pos_ = current_position_(builder_);
while (result_) {
if (!bvalue__1_0(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "bvalue__1", pos_)) break;
pos_ = current_position_(builder_);
private static boolean bvalue__1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "bvalue__1")) return false;
boolean r;
Marker m = enter_section_(b);
r = bvalue__1_0(b, l + 1);
while (r) {
int c = current_position_(b);
if (!bvalue__1_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "bvalue__1", c)) break;
}
exit_section_(builder_, marker_, null, result_);
return result_;
exit_section_(b, m, null, r);
return r;
}
// VALUE SLASH ?
private static boolean bvalue__1_0(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "bvalue__1_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, VALUE);
result_ = result_ && bvalue__1_0_1(builder_, level_ + 1);
exit_section_(builder_, marker_, null, result_);
return result_;
private static boolean bvalue__1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "bvalue__1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, VALUE);
r = r && bvalue__1_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SLASH ?
private static boolean bvalue__1_0_1(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "bvalue__1_0_1")) return false;
consumeToken(builder_, SLASH);
private static boolean bvalue__1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "bvalue__1_0_1")) return false;
consumeToken(b, SLASH);
return true;
}
/* ********************************************************** */
// item_ *
static boolean ignoreFile(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "ignoreFile")) return false;
int pos_ = current_position_(builder_);
static boolean ignoreFile(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ignoreFile")) return false;
while (true) {
if (!item_(builder_, level_ + 1)) break;
if (!empty_element_parsed_guard_(builder_, "ignoreFile", pos_)) break;
pos_ = current_position_(builder_);
int c = current_position_(b);
if (!item_(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "ignoreFile", c)) break;
}
return true;
}
/* ********************************************************** */
// HEADER | SECTION | COMMENT | SYNTAX | ENTRY_DIRECTORY | ENTRY_FILE | CRLF
static boolean item_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "item_")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, HEADER);
if (!result_) result_ = consumeToken(builder_, SECTION);
if (!result_) result_ = consumeToken(builder_, COMMENT);
if (!result_) result_ = SYNTAX(builder_, level_ + 1);
if (!result_) result_ = ENTRY_DIRECTORY(builder_, level_ + 1);
if (!result_) result_ = ENTRY_FILE(builder_, level_ + 1);
if (!result_) result_ = consumeToken(builder_, CRLF);
exit_section_(builder_, marker_, null, result_);
return result_;
static boolean item_(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "item_")) return false;
boolean r;
r = consumeToken(b, HEADER);
if (!r) r = consumeToken(b, SECTION);
if (!r) r = consumeToken(b, COMMENT);
if (!r) r = SYNTAX(b, l + 1);
if (!r) r = ENTRY_DIRECTORY(b, l + 1);
if (!r) r = ENTRY_FILE(b, l + 1);
if (!r) r = consumeToken(b, CRLF);
return r;
}
/* ********************************************************** */
// <<p>> + (SLASH <<p>> +) *
static boolean list_macro(PsiBuilder builder_, int level_, final Parser p) {
if (!recursion_guard_(builder_, level_, "list_macro")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = list_macro_0(builder_, level_ + 1, p);
result_ = result_ && list_macro_1(builder_, level_ + 1, p);
exit_section_(builder_, marker_, null, result_);
return result_;
static boolean list_macro(PsiBuilder b, int l, Parser _p) {
if (!recursion_guard_(b, l, "list_macro")) return false;
boolean r;
Marker m = enter_section_(b);
r = list_macro_0(b, l + 1, _p);
r = r && list_macro_1(b, l + 1, _p);
exit_section_(b, m, null, r);
return r;
}
// <<p>> +
private static boolean list_macro_0(PsiBuilder builder_, int level_, final Parser p) {
if (!recursion_guard_(builder_, level_, "list_macro_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = p.parse(builder_, level_);
int pos_ = current_position_(builder_);
while (result_) {
if (!p.parse(builder_, level_)) break;
if (!empty_element_parsed_guard_(builder_, "list_macro_0", pos_)) break;
pos_ = current_position_(builder_);
private static boolean list_macro_0(PsiBuilder b, int l, Parser _p) {
if (!recursion_guard_(b, l, "list_macro_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = _p.parse(b, l);
while (r) {
int c = current_position_(b);
if (!_p.parse(b, l)) break;
if (!empty_element_parsed_guard_(b, "list_macro_0", c)) break;
}
exit_section_(builder_, marker_, null, result_);
return result_;
exit_section_(b, m, null, r);
return r;
}
// (SLASH <<p>> +) *
private static boolean list_macro_1(PsiBuilder builder_, int level_, final Parser p) {
if (!recursion_guard_(builder_, level_, "list_macro_1")) return false;
int pos_ = current_position_(builder_);
private static boolean list_macro_1(PsiBuilder b, int l, Parser _p) {
if (!recursion_guard_(b, l, "list_macro_1")) return false;
while (true) {
if (!list_macro_1_0(builder_, level_ + 1, p)) break;
if (!empty_element_parsed_guard_(builder_, "list_macro_1", pos_)) break;
pos_ = current_position_(builder_);
int c = current_position_(b);
if (!list_macro_1_0(b, l + 1, _p)) break;
if (!empty_element_parsed_guard_(b, "list_macro_1", c)) break;
}
return true;
}
// SLASH <<p>> +
private static boolean list_macro_1_0(PsiBuilder builder_, int level_, final Parser p) {
if (!recursion_guard_(builder_, level_, "list_macro_1_0")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = consumeToken(builder_, SLASH);
result_ = result_ && list_macro_1_0_1(builder_, level_ + 1, p);
exit_section_(builder_, marker_, null, result_);
return result_;
private static boolean list_macro_1_0(PsiBuilder b, int l, Parser _p) {
if (!recursion_guard_(b, l, "list_macro_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SLASH);
r = r && list_macro_1_0_1(b, l + 1, _p);
exit_section_(b, m, null, r);
return r;
}
// <<p>> +
private static boolean list_macro_1_0_1(PsiBuilder builder_, int level_, final Parser p) {
if (!recursion_guard_(builder_, level_, "list_macro_1_0_1")) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = p.parse(builder_, level_);
int pos_ = current_position_(builder_);
while (result_) {
if (!p.parse(builder_, level_)) break;
if (!empty_element_parsed_guard_(builder_, "list_macro_1_0_1", pos_)) break;
pos_ = current_position_(builder_);
private static boolean list_macro_1_0_1(PsiBuilder b, int l, Parser _p) {
if (!recursion_guard_(b, l, "list_macro_1_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = _p.parse(b, l);
while (r) {
int c = current_position_(b);
if (!_p.parse(b, l)) break;
if (!empty_element_parsed_guard_(b, "list_macro_1_0_1", c)) break;
}
exit_section_(builder_, marker_, null, result_);
return result_;
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// bvalue_ | VALUE
static boolean value_(PsiBuilder builder_, int level_) {
if (!recursion_guard_(builder_, level_, "value_")) return false;
if (!nextTokenIs(builder_, "", BRACKET_LEFT, VALUE)) return false;
boolean result_;
Marker marker_ = enter_section_(builder_);
result_ = bvalue_(builder_, level_ + 1);
if (!result_) result_ = consumeToken(builder_, VALUE);
exit_section_(builder_, marker_, null, result_);
return result_;
static boolean value_(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "value_")) return false;
if (!nextTokenIs(b, "", BRACKET_LEFT, VALUE)) return false;
boolean r;
r = bvalue_(b, l + 1);
if (!r) r = consumeToken(b, VALUE);
return r;
}
final static Parser value__parser_ = new Parser() {
public boolean parse(PsiBuilder builder_, int level_) {
return value_(builder_, level_ + 1);
static final Parser value__parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return value_(b, l + 1);
}
};
}
platform/vcs-impl/gen/com/intellij/openapi/vcs/changes/ignore/psi/IgnoreTypes.java
+1 -3
View File
@@ -1,5 +1,3 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
// This is a generated file. Not intended for manual editing.
package com.intellij.openapi.vcs.changes.ignore.psi;
@@ -29,7 +27,7 @@ public interface IgnoreTypes {
class Factory {
public static PsiElement createElement(ASTNode node) {
IElementType type = node.getElementType();
if (type == ENTRY) {
if (type == ENTRY) {
return new IgnoreEntryImpl(node);
}
else if (type == ENTRY_DIRECTORY) {
plugins/editorconfig/gen/org/editorconfig/language/parser/EditorConfigParser.java
+8 -75
View File
@@ -1,5 +1,3 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
// This is a generated file. Not intended for manual editing.
package org.editorconfig.language.parser;
@@ -16,87 +14,24 @@ import static org.editorconfig.language.psi.EditorConfigElementTypes.*;
@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class EditorConfigParser implements PsiParser, LightPsiParser {
@Override
public ASTNode parse(IElementType t, PsiBuilder b) {
parseLight(t, b);
return b.getTreeBuilt();
}
@Override
public void parseLight(IElementType t, PsiBuilder b) {
boolean r;
b = adapt_builder_(t, b, this, null);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
if (t == ASTERISK_PATTERN) {
r = asterisk_pattern(b, 0);
}
else if (t == CHAR_CLASS) {
r = char_class(b, 0);
}
else if (t == CHAR_CLASS_EXCLAMATION) {
r = char_class_exclamation(b, 0);
}
else if (t == CHAR_CLASS_LETTER) {
r = char_class_letter(b, 0);
}
else if (t == DOUBLE_ASTERISK_PATTERN) {
r = double_asterisk_pattern(b, 0);
}
else if (t == FLAT_OPTION_KEY) {
r = flat_option_key(b, 0);
}
else if (t == FLAT_PATTERN) {
r = flat_pattern(b, 0);
}
else if (t == HEADER) {
r = header(b, 0);
}
else if (t == OPTION) {
r = option(b, 0);
}
else if (t == OPTION_VALUE_IDENTIFIER) {
r = option_value_identifier(b, 0);
}
else if (t == OPTION_VALUE_LIST) {
r = option_value_list(b, 0);
}
else if (t == OPTION_VALUE_PAIR) {
r = option_value_pair(b, 0);
}
else if (t == PATTERN) {
r = pattern(b, 0);
}
else if (t == PATTERN_ENUMERATION) {
r = pattern_enumeration(b, 0);
}
else if (t == QUALIFIED_KEY_PART) {
r = qualified_key_part(b, 0);
}
else if (t == QUALIFIED_OPTION_KEY) {
r = qualified_option_key(b, 0);
}
else if (t == QUESTION_PATTERN) {
r = question_pattern(b, 0);
}
else if (t == ROOT_DECLARATION) {
r = root_declaration(b, 0);
}
else if (t == ROOT_DECLARATION_KEY) {
r = root_declaration_key(b, 0);
}
else if (t == ROOT_DECLARATION_VALUE) {
r = root_declaration_value(b, 0);
}
else if (t == SECTION) {
r = section(b, 0);
}
else {
r = parse_root_(t, b, 0);
}
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
protected boolean parse_root_(IElementType t, PsiBuilder b) {
return parse_root_(t, b, 0);
}
static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return editorConfigFile(b, l + 1);
}
@@ -844,14 +779,12 @@ public class EditorConfigParser implements PsiParser, LightPsiParser {
return r;
}
final static Parser not_header_parser_ = new Parser() {
@Override
static final Parser not_header_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return not_header(b, l + 1);
}
};
final static Parser not_next_entry_parser_ = new Parser() {
@Override
static final Parser not_next_entry_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return not_next_entry(b, l + 1);
}
plugins/editorconfig/gen/org/editorconfig/language/psi/EditorConfigElementTypes.java
-2
View File
@@ -1,5 +1,3 @@
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
// This is a generated file. Not intended for manual editing.
package org.editorconfig.language.psi;
plugins/groovy/groovy-psi/gen/org/jetbrains/plugins/groovy/lang/parser/GroovyGeneratedParser.java
-54
View File
@@ -1,5 +1,3 @@
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
// This is a generated file. Not intended for manual editing.
package org.jetbrains.plugins.groovy.lang.parser;
@@ -336,10 +334,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean annotation_array_item_start(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "annotation_array_item_start")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_AT);
if (!r) r = expression_start(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@@ -396,12 +392,10 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean annotation_key(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "annotation_key")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, IDENTIFIER);
if (!r) r = consumeToken(b, KW_AS);
if (!r) r = consumeToken(b, KW_DEF);
if (!r) r = consumeToken(b, KW_IN);
exit_section_(b, m, null, r);
return r;
}
@@ -1193,10 +1187,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
if (!recursion_guard_(b, l, "assert_message_separator")) return false;
if (!nextTokenIs(b, "", T_COLON, T_COMMA)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_COLON);
if (!r) r = consumeToken(b, T_COMMA);
exit_section_(b, m, null, r);
return r;
}
@@ -1739,10 +1731,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean case_level_end_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "case_level_end_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, KW_CASE);
if (!r) r = consumeTokenFast(b, KW_DEFAULT);
exit_section_(b, m, null, r);
return r;
}
@@ -1775,12 +1765,10 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean case_level_start(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "case_level_start")) return false;
boolean r;
Marker m = enter_section_(b);
r = statement_start(b, l + 1);
if (!r) r = class_level_start(b, l + 1);
if (!r) r = consumeToken(b, KW_CASE);
if (!r) r = consumeToken(b, KW_DEFAULT);
exit_section_(b, m, null, r);
return r;
}
@@ -1858,11 +1846,9 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean case_section_recovery_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "case_section_recovery_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_RBRACE);
if (!r) r = consumeToken(b, KW_CASE);
if (!r) r = consumeToken(b, KW_DEFAULT);
exit_section_(b, m, null, r);
return r;
}
@@ -2549,12 +2535,10 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean code_reference_identifiers_soft(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "code_reference_identifiers_soft")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, KW_DEF);
if (!r) r = consumeTokenFast(b, KW_AS);
if (!r) r = consumeTokenFast(b, KW_IN);
if (!r) r = consumeTokenFast(b, KW_TRAIT);
exit_section_(b, m, null, r);
return r;
}
@@ -2747,10 +2731,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean constructor_call_expression_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constructor_call_expression_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, KW_THIS);
if (!r) r = consumeTokenFast(b, KW_SUPER);
exit_section_(b, m, null, r);
return r;
}
@@ -3715,11 +3697,9 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean extends_recovery_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "extends_recovery_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_COMMA);
if (!r) r = consumeToken(b, KW_IMPLEMENTS);
if (!r) r = consumeToken(b, T_LBRACE);
exit_section_(b, m, null, r);
return r;
}
@@ -3934,10 +3914,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean for_in_clause_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "for_in_clause_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, T_COLON);
if (!r) r = consumeTokenFast(b, KW_IN);
exit_section_(b, m, null, r);
return r;
}
@@ -4155,10 +4133,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean implements_recovery_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "implements_recovery_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_COMMA);
if (!r) r = consumeToken(b, T_LBRACE);
exit_section_(b, m, null, r);
return r;
}
@@ -4801,10 +4777,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
if (!recursion_guard_(b, l, "method_reference_dot")) return false;
if (!nextTokenIsFast(b, T_METHOD_CLOSURE, T_METHOD_REFERENCE)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, T_METHOD_CLOSURE);
if (!r) r = consumeTokenFast(b, T_METHOD_REFERENCE);
exit_section_(b, m, null, r);
return r;
}
@@ -5104,10 +5078,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean nl_throws_0_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "nl_throws_0_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, KW_THROWS);
if (!r) r = consumeToken(b, T_LBRACE);
exit_section_(b, m, null, r);
return r;
}
@@ -5643,11 +5615,9 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean paren_list_item_recovery_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "paren_list_item_recovery_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, T_COMMA);
if (!r) r = consumeToken(b, T_RPAREN);
if (!r) r = consumeToken(b, T_RBRACE);
exit_section_(b, m, null, r);
return r;
}
@@ -5819,11 +5789,9 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean reference_dot(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "reference_dot")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, T_DOT);
if (!r) r = consumeTokenFast(b, T_SAFE_DOT);
if (!r) r = consumeTokenFast(b, T_SPREAD_DOT);
exit_section_(b, m, null, r);
return r;
}
@@ -6098,7 +6066,6 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean simple_literal_tokens(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_literal_tokens")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, NUM_INT);
if (!r) r = consumeTokenFast(b, NUM_LONG);
if (!r) r = consumeTokenFast(b, NUM_BIG_INT);
@@ -6109,7 +6076,6 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
if (!r) r = consumeTokenFast(b, KW_TRUE);
if (!r) r = consumeTokenFast(b, KW_FALSE);
if (!r) r = consumeTokenFast(b, KW_NULL);
exit_section_(b, m, null, r);
return r;
}
@@ -6410,7 +6376,6 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean statement_keywords(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "statement_keywords")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenFast(b, KW_ASSERT);
if (!r) r = consumeTokenFast(b, KW_BREAK);
if (!r) r = consumeTokenFast(b, KW_CONTINUE);
@@ -6421,7 +6386,6 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
if (!r) r = consumeTokenFast(b, KW_THROW);
if (!r) r = consumeTokenFast(b, KW_TRY);
if (!r) r = consumeTokenFast(b, KW_WHILE);
exit_section_(b, m, null, r);
return r;
}
@@ -6738,10 +6702,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
static boolean top_level_start(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "top_level_start")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, KW_IMPORT);
if (!r) r = block_level_start(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@@ -7532,10 +7494,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean wildcard_bound_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "wildcard_bound_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, KW_EXTENDS);
if (!r) r = consumeToken(b, KW_SUPER);
exit_section_(b, m, null, r);
return r;
}
@@ -8104,10 +8064,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean range_expression_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "range_expression_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_RANGE);
if (!r) r = consumeTokenSmart(b, T_RANGE_EX);
exit_section_(b, m, null, r);
return r;
}
@@ -8127,10 +8085,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean additive_expression_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "additive_expression_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_PLUS);
if (!r) r = consumeTokenSmart(b, T_MINUS);
exit_section_(b, m, null, r);
return r;
}
@@ -8151,11 +8107,9 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean multiplicative_expression_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "multiplicative_expression_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_STAR);
if (!r) r = consumeTokenSmart(b, T_DIV);
if (!r) r = consumeTokenSmart(b, T_REM);
exit_section_(b, m, null, r);
return r;
}
@@ -8198,12 +8152,10 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean prefix_unary_expression_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "prefix_unary_expression_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_INC);
if (!r) r = consumeTokenSmart(b, T_DEC);
if (!r) r = consumeTokenSmart(b, T_MINUS);
if (!r) r = consumeTokenSmart(b, T_PLUS);
exit_section_(b, m, null, r);
return r;
}
@@ -8235,10 +8187,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean not_expression_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "not_expression_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_BNOT);
if (!r) r = consumeTokenSmart(b, T_NOT);
exit_section_(b, m, null, r);
return r;
}
@@ -8283,10 +8233,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean postfix_unary_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "postfix_unary_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, T_INC);
if (!r) r = consumeTokenSmart(b, T_DEC);
exit_section_(b, m, null, r);
return r;
}
@@ -8618,10 +8566,8 @@ public class GroovyGeneratedParser implements PsiParser, LightPsiParser {
private static boolean unqualified_reference_expression_3_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "unqualified_reference_expression_3_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = reference_dot(b, l + 1);
if (!r) r = consumeTokenSmart(b, T_METHOD_CLOSURE);
exit_section_(b, m, null, r);
return r;
}
plugins/sh/gen/com/intellij/sh/parser/ShParser.java
+3 -63
View File
@@ -104,10 +104,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean argument_list_recover_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "argument_list_recover_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, LINEFEED);
if (!r) r = consumeToken(b, LEFT_CURLY);
exit_section_(b, m, null, r);
return r;
}
@@ -253,10 +251,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean assignment_command_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "assignment_command_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ASSIGN);
if (!r) r = consumeToken(b, PLUS_ASSIGN);
exit_section_(b, m, null, r);
return r;
}
@@ -413,13 +409,11 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean block_compound_list_recover_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "block_compound_list_recover_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, LEFT_CURLY);
if (!r) r = consumeToken(b, LINEFEED);
if (!r) r = consumeToken(b, RIGHT_CURLY);
if (!r) r = consumeToken(b, DO);
if (!r) r = consumeToken(b, DONE);
exit_section_(b, m, null, r);
return r;
}
@@ -583,11 +577,9 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean case_pattern_recover_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "case_pattern_recover_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, RIGHT_PAREN);
if (!r) r = consumeToken(b, CASE_END);
if (!r) r = consumeToken(b, ESAC);
exit_section_(b, m, null, r);
return r;
}
@@ -741,10 +733,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean commands_list_1_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "commands_list_1_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, AND_AND);
if (!r) r = consumeToken(b, OR_OR);
exit_section_(b, m, null, r);
return r;
}
@@ -771,12 +761,10 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean commands_list_1_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "commands_list_1_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, PIPE);
if (!r) r = consumeToken(b, PIPE_AMP);
if (!r) r = consumeToken(b, AMP);
if (!r) r = consumeToken(b, SEMI);
exit_section_(b, m, null, r);
return r;
}
@@ -816,11 +804,9 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean composed_var_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "composed_var_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, LEFT_PAREN);
if (!r) r = consumeToken(b, LEFT_DOUBLE_PAREN);
if (!r) r = consumeToken(b, LEFT_CURLY);
exit_section_(b, m, null, r);
return r;
}
@@ -859,7 +845,7 @@ public class ShParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// newlines pipeline_command_list end_of_list newlines
// newlines pipeline_command_list end_of_list newlines
public static boolean compound_list(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "compound_list")) return false;
boolean r, p;
@@ -1052,11 +1038,9 @@ public class ShParser implements PsiParser, LightPsiParser {
static boolean end_of_list(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "end_of_list")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, LINEFEED);
if (!r) r = consumeToken(b, SEMI);
if (!r) r = consumeToken(b, AMP);
exit_section_(b, m, null, r);
return r;
}
@@ -1178,7 +1162,7 @@ public class ShParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// word argument_list newlines block
// word argument_list newlines block
// | function (word | <<functionNameKeywordsRemapped>>) argument_list? newlines block
static boolean function_definition_inner(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "function_definition_inner")) return false;
@@ -1191,7 +1175,7 @@ public class ShParser implements PsiParser, LightPsiParser {
return r;
}
// word argument_list newlines block
// word argument_list newlines block
private static boolean function_definition_inner_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "function_definition_inner_0")) return false;
boolean r, p;
@@ -1348,14 +1332,12 @@ public class ShParser implements PsiParser, LightPsiParser {
static boolean heredoc_pipeline_separator(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "heredoc_pipeline_separator")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, AND_AND);
if (!r) r = consumeToken(b, OR_OR);
if (!r) r = consumeToken(b, AMP);
if (!r) r = consumeToken(b, PIPE);
if (!r) r = consumeToken(b, PIPE_AMP);
if (!r) r = consumeToken(b, SEMI);
exit_section_(b, m, null, r);
return r;
}
@@ -1545,10 +1527,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean include_directive_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "include_directive_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "source");
if (!r) r = consumeToken(b, ".");
exit_section_(b, m, null, r);
return r;
}
@@ -1615,11 +1595,9 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean list_terminator_recover_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "list_terminator_recover_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, DO);
if (!r) r = consumeToken(b, LEFT_CURLY);
if (!r) r = consumeToken(b, LINEFEED);
exit_section_(b, m, null, r);
return r;
}
@@ -1671,13 +1649,11 @@ public class ShParser implements PsiParser, LightPsiParser {
static boolean not_lvalue(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "not_lvalue")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BANG);
if (!r) r = vars(b, l + 1);
if (!r) r = consumeToken(b, DOLLAR);
if (!r) r = brace_expansion(b, l + 1);
if (!r) r = consumeToken(b, FILEDESCRIPTOR);
exit_section_(b, m, null, r);
return r;
}
@@ -1934,14 +1910,12 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean pipeline_command_list_separator_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pipeline_command_list_separator_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, AND_AND);
if (!r) r = consumeToken(b, OR_OR);
if (!r) r = consumeToken(b, AMP);
if (!r) r = consumeToken(b, SEMI);
if (!r) r = consumeToken(b, PIPE);
if (!r) r = consumeToken(b, LINEFEED);
exit_section_(b, m, null, r);
return r;
}
@@ -1962,7 +1936,6 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean pipeline_recover_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pipeline_recover_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, CASE);
if (!r) r = consumeToken(b, IF);
if (!r) r = consumeToken(b, WHILE);
@@ -1993,7 +1966,6 @@ public class ShParser implements PsiParser, LightPsiParser {
if (!r) r = consumeToken(b, DO);
if (!r) r = consumeToken(b, DONE);
if (!r) r = consumeToken(b, RIGHT_CURLY);
exit_section_(b, m, null, r);
return r;
}
@@ -2016,10 +1988,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean process_substitution_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "process_substitution_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, INPUT_PROCESS_SUBSTITUTION);
if (!r) r = consumeToken(b, OUTPUT_PROCESS_SUBSTITUTION);
exit_section_(b, m, null, r);
return r;
}
@@ -2087,10 +2057,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean redirection_inner_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "redirection_inner_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, REDIRECT_LESS_AMP);
if (!r) r = consumeToken(b, REDIRECT_GREATER_AMP);
exit_section_(b, m, null, r);
return r;
}
@@ -2098,10 +2066,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean redirection_inner_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "redirection_inner_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = number(b, l + 1);
if (!r) r = consumeToken(b, MINUS);
exit_section_(b, m, null, r);
return r;
}
@@ -2120,7 +2086,6 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean redirection_inner_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "redirection_inner_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, GT);
if (!r) r = consumeToken(b, LT);
if (!r) r = consumeToken(b, SHIFT_RIGHT);
@@ -2131,7 +2096,6 @@ public class ShParser implements PsiParser, LightPsiParser {
if (!r) r = consumeToken(b, REDIRECT_AMP_GREATER_GREATER);
if (!r) r = consumeToken(b, REDIRECT_LESS_GREATER);
if (!r) r = consumeToken(b, REDIRECT_GREATER_BAR);
exit_section_(b, m, null, r);
return r;
}
@@ -2615,11 +2579,9 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean equality_condition_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "equality_condition_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, EQ);
if (!r) r = consumeTokenSmart(b, NE);
if (!r) r = consumeTokenSmart(b, REGEXP);
exit_section_(b, m, null, r);
return r;
}
@@ -2627,10 +2589,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean comparison_condition_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "comparison_condition_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, LT);
if (!r) r = consumeTokenSmart(b, GT);
exit_section_(b, m, null, r);
return r;
}
@@ -2817,7 +2777,6 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean assignment_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "assignment_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, ASSIGN);
if (!r) r = consumeTokenSmart(b, MULT_ASSIGN);
if (!r) r = consumeTokenSmart(b, DIV_ASSIGN);
@@ -2829,7 +2788,6 @@ public class ShParser implements PsiParser, LightPsiParser {
if (!r) r = consumeTokenSmart(b, BIT_AND_ASSIGN);
if (!r) r = consumeTokenSmart(b, BIT_XOR_ASSIGN);
if (!r) r = consumeTokenSmart(b, BIT_OR_ASSIGN);
exit_section_(b, m, null, r);
return r;
}
@@ -2848,10 +2806,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean equality_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "equality_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, EQ);
if (!r) r = consumeTokenSmart(b, NE);
exit_section_(b, m, null, r);
return r;
}
@@ -2859,12 +2815,10 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean comparison_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "comparison_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, LE);
if (!r) r = consumeTokenSmart(b, GE);
if (!r) r = consumeTokenSmart(b, LT);
if (!r) r = consumeTokenSmart(b, GT);
exit_section_(b, m, null, r);
return r;
}
@@ -2872,10 +2826,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean bitwise_shift_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "bitwise_shift_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, SHIFT_LEFT);
if (!r) r = consumeTokenSmart(b, SHIFT_RIGHT);
exit_section_(b, m, null, r);
return r;
}
@@ -2883,10 +2835,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean add_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "add_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, PLUS);
if (!r) r = consumeTokenSmart(b, MINUS);
exit_section_(b, m, null, r);
return r;
}
@@ -2894,11 +2844,9 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean mul_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "mul_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, MULT);
if (!r) r = consumeTokenSmart(b, DIV);
if (!r) r = consumeTokenSmart(b, MOD);
exit_section_(b, m, null, r);
return r;
}
@@ -2918,10 +2866,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean logical_bitwise_negation_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "logical_bitwise_negation_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, BANG);
if (!r) r = consumeTokenSmart(b, BITWISE_NEGATION);
exit_section_(b, m, null, r);
return r;
}
@@ -2941,10 +2887,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean unary_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "unary_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, MINUS);
if (!r) r = consumeTokenSmart(b, PLUS);
exit_section_(b, m, null, r);
return r;
}
@@ -2964,10 +2908,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean pre_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pre_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, MINUS_MINUS);
if (!r) r = consumeTokenSmart(b, PLUS_PLUS);
exit_section_(b, m, null, r);
return r;
}
@@ -2975,10 +2917,8 @@ public class ShParser implements PsiParser, LightPsiParser {
private static boolean post_expression_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "post_expression_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, MINUS_MINUS);
if (!r) r = consumeTokenSmart(b, PLUS_PLUS);
exit_section_(b, m, null, r);
return r;
}
python/gen/com/jetbrains/commandInterface/commandLine/CommandLineElementTypes.java
+1 -1
View File
@@ -28,7 +28,7 @@ public interface CommandLineElementTypes {
class Factory {
public static PsiElement createElement(ASTNode node) {
IElementType type = node.getElementType();
if (type == ARGUMENT) {
if (type == ARGUMENT) {
return new CommandLineArgumentImpl(node);
}
else if (type == COMMAND) {
python/gen/com/jetbrains/commandInterface/commandLine/CommandLineParser.java
+6 -13
View File
@@ -23,22 +23,15 @@ public class CommandLineParser implements PsiParser, LightPsiParser {
boolean r;
b = adapt_builder_(t, b, this, null);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
if (t == ARGUMENT) {
r = argument(b, 0);
}
else if (t == COMMAND) {
r = command(b, 0);
}
else if (t == OPTION) {
r = option(b, 0);
}
else {
r = parse_root_(t, b, 0);
}
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
protected boolean parse_root_(IElementType t, PsiBuilder b) {
return parse_root_(t, b, 0);
}
static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return root(b, l + 1);
}