ralsina/tartrazine
1
0
Fork 0
mirror of https://github.com/ralsina/tartrazine.git synced 2024-09-20 15:31:21 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
02878b9c9f
tartrazine/_testdata/Java/GrammarKit.java
Miguel Molina 8ff885a3a8
implement IsGenerated helper to filter out generated files 
Closes #17

Implements the IsGenerated helper function to filter out generated
files using the rules and matchers in:
- https://github.com/github/linguist/blob/master/lib/linguist/generated.rb

Since the vast majority of matchers have very different logic, it cannot
be autogenerated directly from linguist like other logics in enry, so it's
translated by hand.

There are three different types of matchers in this implementation:
- By extension, which mark as generated based only in the extension. These
  are the fastest matchers, so they're done first.
- By file name, which matches patterns against the filename. These
  are performed in second place. Unlike linguist, we try to use string
  functions instead of regexps as much as possible.
- Finally, the rest of the matchers, which go into the content and try
  to identify if they're generated or not based on the content. Unlike
  linguist, we try to only read the content we need and not split it
  all unless it's necessary and use byte functions instead of regexps
  as much as possible.

Signed-off-by: Miguel Molina <miguel@erizocosmi.co>
2020-05-28 08:55:13 +02:00

626 lines
20 KiB
Java
Raw Blame History

// This is a generated file. Not intended for manual editing.
package org.intellij.grammar.parser;
import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static org.intellij.grammar.psi.BnfTypes.*;
import static org.intellij.grammar.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 GrammarParser implements PsiParser, LightPsiParser {
public ASTNode parse(IElementType t, PsiBuilder b) {
parseLight(t, b);
return b.getTreeBuilt();
}
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);
if (t == BNF_ATTR) {
r = attr(b, 0);
}
else if (t == BNF_ATTR_PATTERN) {
r = attr_pattern(b, 0);
}
else if (t == BNF_ATTR_VALUE) {
r = attr_value(b, 0);
}
else if (t == BNF_ATTRS) {
r = attrs(b, 0);
}
else if (t == BNF_CHOICE) {
r = choice(b, 0);
}
else if (t == BNF_EXPRESSION) {
r = expression(b, 0);
}
else if (t == BNF_LITERAL_EXPRESSION) {
r = literal_expression(b, 0);
}
else if (t == BNF_MODIFIER) {
r = modifier(b, 0);
}
else if (t == BNF_PAREN_EXPRESSION) {
r = paren_expression(b, 0);
}
else if (t == BNF_PREDICATE) {
r = predicate(b, 0);
}
else if (t == BNF_PREDICATE_SIGN) {
r = predicate_sign(b, 0);
}
else if (t == BNF_QUANTIFIED) {
r = quantified(b, 0);
}
else if (t == BNF_QUANTIFIER) {
r = quantifier(b, 0);
}
else if (t == BNF_REFERENCE_OR_TOKEN) {
r = reference_or_token(b, 0);
}
else if (t == BNF_RULE) {
r = rule(b, 0);
}
else if (t == BNF_SEQUENCE) {
r = sequence(b, 0);
}
else if (t == BNF_STRING_LITERAL_EXPRESSION) {
r = string_literal_expression(b, 0);
}
else {
r = parse_root_(t, b, 0);
}
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return grammar(b, l + 1);
}
public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
create_token_set_(BNF_LITERAL_EXPRESSION, BNF_STRING_LITERAL_EXPRESSION),
create_token_set_(BNF_CHOICE, BNF_EXPRESSION, BNF_LITERAL_EXPRESSION, BNF_PAREN_EXPRESSION,
BNF_PREDICATE, BNF_QUANTIFIED, BNF_REFERENCE_OR_TOKEN, BNF_SEQUENCE,
BNF_STRING_LITERAL_EXPRESSION),
};
/* ********************************************************** */
// id attr_pattern? '=' attr_value ';'?
public static boolean attr(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, "<attr>");
r = consumeToken(b, BNF_ID);
p = r; // pin = 1
r = r && report_error_(b, attr_1(b, l + 1));
r = p && report_error_(b, consumeToken(b, BNF_OP_EQ)) && r;
r = p && report_error_(b, attr_value(b, l + 1)) && r;
r = p && attr_4(b, l + 1) && r;
exit_section_(b, l, m, BNF_ATTR, r, p, attr_recover_until_parser_);
return r || p;
}
// attr_pattern?
private static boolean attr_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_1")) return false;
attr_pattern(b, l + 1);
return true;
}
// ';'?
private static boolean attr_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_4")) return false;
consumeToken(b, BNF_SEMICOLON);
return true;
}
/* ********************************************************** */
// '(' string ')'
public static boolean attr_pattern(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_pattern")) return false;
if (!nextTokenIs(b, BNF_LEFT_PAREN)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_PAREN);
r = r && consumeToken(b, BNF_STRING);
r = r && consumeToken(b, BNF_RIGHT_PAREN);
exit_section_(b, m, BNF_ATTR_PATTERN, r);
return r;
}
/* ********************************************************** */
// !'}'
static boolean attr_recover_until(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_recover_until")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_RIGHT_BRACE);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// (reference_or_token | literal_expression) !'='
public static boolean attr_value(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<attr value>");
r = attr_value_0(b, l + 1);
r = r && attr_value_1(b, l + 1);
exit_section_(b, l, m, BNF_ATTR_VALUE, r, false, null);
return r;
}
// reference_or_token | literal_expression
private static boolean attr_value_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = reference_or_token(b, l + 1);
if (!r) r = literal_expression(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !'='
private static boolean attr_value_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attr_value_1")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_OP_EQ);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// '{' attr* '}'
public static boolean attrs(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attrs")) return false;
if (!nextTokenIs(b, BNF_LEFT_BRACE)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_LEFT_BRACE);
p = r; // pin = 1
r = r && report_error_(b, attrs_1(b, l + 1));
r = p && consumeToken(b, BNF_RIGHT_BRACE) && r;
exit_section_(b, l, m, BNF_ATTRS, r, p, null);
return r || p;
}
// attr*
private static boolean attrs_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "attrs_1")) return false;
int c = current_position_(b);
while (true) {
if (!attr(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "attrs_1", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// '{' sequence ('|' sequence)* '}' | sequence choice_tail*
public static boolean choice(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<choice>");
r = choice_0(b, l + 1);
if (!r) r = choice_1(b, l + 1);
exit_section_(b, l, m, BNF_CHOICE, r, false, null);
return r;
}
// '{' sequence ('|' sequence)* '}'
private static boolean choice_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_BRACE);
r = r && sequence(b, l + 1);
r = r && choice_0_2(b, l + 1);
r = r && consumeToken(b, BNF_RIGHT_BRACE);
exit_section_(b, m, null, r);
return r;
}
// ('|' sequence)*
private static boolean choice_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0_2")) return false;
int c = current_position_(b);
while (true) {
if (!choice_0_2_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "choice_0_2", c)) break;
c = current_position_(b);
}
return true;
}
// '|' sequence
private static boolean choice_0_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_0_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_OP_OR);
r = r && sequence(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// sequence choice_tail*
private static boolean choice_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = sequence(b, l + 1);
r = r && choice_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// choice_tail*
private static boolean choice_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_1_1")) return false;
int c = current_position_(b);
while (true) {
if (!choice_tail(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "choice_1_1", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// '|' sequence
static boolean choice_tail(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "choice_tail")) return false;
if (!nextTokenIs(b, BNF_OP_OR)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_OP_OR);
p = r; // pin = 1
r = r && sequence(b, l + 1);
exit_section_(b, l, m, null, r, p, null);
return r || p;
}
/* ********************************************************** */
// choice?
public static boolean expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "expression")) return false;
Marker m = enter_section_(b, l, _COLLAPSE_, "<expression>");
choice(b, l + 1);
exit_section_(b, l, m, BNF_EXPRESSION, true, false, null);
return true;
}
/* ********************************************************** */
// (attrs | rule) *
static boolean grammar(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "grammar")) return false;
int c = current_position_(b);
while (true) {
if (!grammar_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "grammar", c)) break;
c = current_position_(b);
}
return true;
}
// attrs | rule
private static boolean grammar_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "grammar_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = attrs(b, l + 1);
if (!r) r = rule(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// string_literal_expression | number
public static boolean literal_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "literal_expression")) return false;
if (!nextTokenIs(b, "<literal expression>", BNF_NUMBER, BNF_STRING)) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<literal expression>");
r = string_literal_expression(b, l + 1);
if (!r) r = consumeToken(b, BNF_NUMBER);
exit_section_(b, l, m, BNF_LITERAL_EXPRESSION, r, false, null);
return r;
}
/* ********************************************************** */
// 'private' | 'external' | 'wrapped'
public static boolean modifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "modifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<modifier>");
r = consumeToken(b, "private");
if (!r) r = consumeToken(b, "external");
if (!r) r = consumeToken(b, "wrapped");
exit_section_(b, l, m, BNF_MODIFIER, r, false, null);
return r;
}
/* ********************************************************** */
// quantified | predicate
static boolean option(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "option")) return false;
boolean r;
Marker m = enter_section_(b);
r = quantified(b, l + 1);
if (!r) r = predicate(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// '(' expression ')'
public static boolean paren_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "paren_expression")) return false;
if (!nextTokenIs(b, BNF_LEFT_PAREN)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeToken(b, BNF_LEFT_PAREN);
p = r; // pin = 1
r = r && report_error_(b, expression(b, l + 1));
r = p && consumeToken(b, BNF_RIGHT_PAREN) && r;
exit_section_(b, l, m, BNF_PAREN_EXPRESSION, r, p, null);
return r || p;
}
/* ********************************************************** */
// predicate_sign simple
public static boolean predicate(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "predicate")) return false;
if (!nextTokenIs(b, "<predicate>", BNF_OP_NOT, BNF_OP_AND)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<predicate>");
r = predicate_sign(b, l + 1);
r = r && simple(b, l + 1);
exit_section_(b, l, m, BNF_PREDICATE, r, false, null);
return r;
}
/* ********************************************************** */
// '&' | '!'
public static boolean predicate_sign(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "predicate_sign")) return false;
if (!nextTokenIs(b, "<predicate sign>", BNF_OP_NOT, BNF_OP_AND)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<predicate sign>");
r = consumeToken(b, BNF_OP_AND);
if (!r) r = consumeToken(b, BNF_OP_NOT);
exit_section_(b, l, m, BNF_PREDICATE_SIGN, r, false, null);
return r;
}
/* ********************************************************** */
// '[' expression ']' | simple quantifier?
public static boolean quantified(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<quantified>");
r = quantified_0(b, l + 1);
if (!r) r = quantified_1(b, l + 1);
exit_section_(b, l, m, BNF_QUANTIFIED, r, false, null);
return r;
}
// '[' expression ']'
private static boolean quantified_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_LEFT_BRACKET);
r = r && expression(b, l + 1);
r = r && consumeToken(b, BNF_RIGHT_BRACKET);
exit_section_(b, m, null, r);
return r;
}
// simple quantifier?
private static boolean quantified_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple(b, l + 1);
r = r && quantified_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// quantifier?
private static boolean quantified_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantified_1_1")) return false;
quantifier(b, l + 1);
return true;
}
/* ********************************************************** */
// '?' | '+' | '*'
public static boolean quantifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "quantifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, "<quantifier>");
r = consumeToken(b, BNF_OP_OPT);
if (!r) r = consumeToken(b, BNF_OP_ONEMORE);
if (!r) r = consumeToken(b, BNF_OP_ZEROMORE);
exit_section_(b, l, m, BNF_QUANTIFIER, r, false, null);
return r;
}
/* ********************************************************** */
// id
public static boolean reference_or_token(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "reference_or_token")) return false;
if (!nextTokenIs(b, BNF_ID)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_ID);
exit_section_(b, m, BNF_REFERENCE_OR_TOKEN, r);
return r;
}
/* ********************************************************** */
// modifier* id '::=' expression attrs? ';'?
public static boolean rule(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, "<rule>");
r = rule_0(b, l + 1);
r = r && consumeToken(b, BNF_ID);
r = r && consumeToken(b, BNF_OP_IS);
p = r; // pin = 3
r = r && report_error_(b, expression(b, l + 1));
r = p && report_error_(b, rule_4(b, l + 1)) && r;
r = p && rule_5(b, l + 1) && r;
exit_section_(b, l, m, BNF_RULE, r, p, rule_recover_until_parser_);
return r || p;
}
// modifier*
private static boolean rule_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_0")) return false;
int c = current_position_(b);
while (true) {
if (!modifier(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "rule_0", c)) break;
c = current_position_(b);
}
return true;
}
// attrs?
private static boolean rule_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_4")) return false;
attrs(b, l + 1);
return true;
}
// ';'?
private static boolean rule_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_5")) return false;
consumeToken(b, BNF_SEMICOLON);
return true;
}
/* ********************************************************** */
// !'{'
static boolean rule_recover_until(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "rule_recover_until")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !consumeToken(b, BNF_LEFT_BRACE);
exit_section_(b, l, m, null, r, false, null);
return r;
}
/* ********************************************************** */
// option +
public static boolean sequence(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "sequence")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, "<sequence>");
r = option(b, l + 1);
int c = current_position_(b);
while (r) {
if (!option(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "sequence", c)) break;
c = current_position_(b);
}
exit_section_(b, l, m, BNF_SEQUENCE, r, false, null);
return r;
}
/* ********************************************************** */
// !(modifier* id '::=' ) reference_or_token | literal_expression | paren_expression
static boolean simple(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0(b, l + 1);
if (!r) r = literal_expression(b, l + 1);
if (!r) r = paren_expression(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !(modifier* id '::=' ) reference_or_token
private static boolean simple_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0_0(b, l + 1);
r = r && reference_or_token(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// !(modifier* id '::=' )
private static boolean simple_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0")) return false;
boolean r;
Marker m = enter_section_(b, l, _NOT_, null);
r = !simple_0_0_0(b, l + 1);
exit_section_(b, l, m, null, r, false, null);
return r;
}
// modifier* id '::='
private static boolean simple_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = simple_0_0_0_0(b, l + 1);
r = r && consumeToken(b, BNF_ID);
r = r && consumeToken(b, BNF_OP_IS);
exit_section_(b, m, null, r);
return r;
}
// modifier*
private static boolean simple_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "simple_0_0_0_0")) return false;
int c = current_position_(b);
while (true) {
if (!modifier(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "simple_0_0_0_0", c)) break;
c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// string
public static boolean string_literal_expression(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "string_literal_expression")) return false;
if (!nextTokenIs(b, BNF_STRING)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, BNF_STRING);
exit_section_(b, m, BNF_STRING_LITERAL_EXPRESSION, r);
return r;
}
final static Parser attr_recover_until_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return attr_recover_until(b, l + 1);
}
};
final static Parser rule_recover_until_parser_ = new Parser() {
public boolean parse(PsiBuilder b, int l) {
return rule_recover_until(b, l + 1);
}
};
}
Reference in New Issue View Git Blame Copy Permalink