diff --git a/lib/linguist/generated.rb b/lib/linguist/generated.rb index 35766e4d..7747406f 100644 --- a/lib/linguist/generated.rb +++ b/lib/linguist/generated.rb @@ -72,7 +72,9 @@ module Linguist vcr_cassette? || generated_module? || generated_unity3d_meta? || - generated_racc? + generated_racc? || + generated_jflex? || + generated_grammarkit? end # Internal: Is the blob an Xcode file? @@ -373,5 +375,32 @@ module Linguist return false unless lines.count > 2 return lines[2].start_with?("# This file is automatically generated by Racc") end + + # Internal: Is this a JFlex-generated file? + # + # A JFlex-generated file contains: + # /* The following code was generated by JFlex x.y.z on d/at/e ti:me */ + # on the first line. + # + # Return true or false + def generated_jflex? + return false unless extname == '.java' + return false unless lines.count > 1 + return lines[0].start_with?("/* The following code was generated by JFlex ") + end + + # Internal: Is this a GrammarKit-generated file? + # + # A GrammarKit-generated file typically contain: + # // This is a generated file. Not intended for manual editing. + # on the first line. This is not always the case, as it's possible to + # customize the class header. + # + # Return true or false + def generated_grammarkit? + return false unless extname == '.java' + return false unless lines.count > 1 + return lines[0].start_with?("// This is a generated file. Not intended for manual editing.") + end end end diff --git a/samples/Java/GrammarKit.java b/samples/Java/GrammarKit.java new file mode 100644 index 00000000..a5db6da8 --- /dev/null +++ b/samples/Java/GrammarKit.java @@ -0,0 +1,625 @@ +// 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_, ""); + 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_, ""); + 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_, ""); + 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_, ""); + 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, "", BNF_NUMBER, BNF_STRING)) return false; + boolean r; + Marker m = enter_section_(b, l, _COLLAPSE_, ""); + 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_, ""); + 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, "", BNF_OP_NOT, BNF_OP_AND)) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, ""); + 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, "", BNF_OP_NOT, BNF_OP_AND)) return false; + boolean r; + Marker m = enter_section_(b, l, _NONE_, ""); + 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_, ""); + 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_, ""); + 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_, ""); + 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_, ""); + 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); + } + }; +} diff --git a/samples/Java/JFlexLexer.java b/samples/Java/JFlexLexer.java new file mode 100644 index 00000000..e54564fb --- /dev/null +++ b/samples/Java/JFlexLexer.java @@ -0,0 +1,482 @@ +/* The following code was generated by JFlex 1.4.3 on 28/01/16 11:27 */ + +package test; +import com.intellij.lexer.*; +import com.intellij.psi.tree.IElementType; +import static org.intellij.grammar.psi.BnfTypes.*; + + +/** + * This class is a scanner generated by + * JFlex 1.4.3 + * on 28/01/16 11:27 from the specification file + * /home/abigail/code/intellij-grammar-kit-test/src/test/_GrammarLexer.flex + */ +public class _GrammarLexer implements FlexLexer { + /** initial size of the lookahead buffer */ + private static final int ZZ_BUFFERSIZE = 16384; + + /** lexical states */ + public static final int YYINITIAL = 0; + + /** + * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l + * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l + * at the beginning of a line + * l is of the form l = 2*k, k a non negative integer + */ + private static final int ZZ_LEXSTATE[] = { + 0, 0 + }; + + /** + * Translates characters to character classes + */ + private static final String ZZ_CMAP_PACKED = + "\11\0\1\1\1\1\1\0\1\1\1\1\22\0\1\1\101\0\1\13"+ + "\1\0\1\3\1\14\1\0\1\10\1\0\1\2\3\0\1\12\1\7"+ + "\3\0\1\6\1\4\1\5\1\11\uff8a\0"; + + /** + * Translates characters to character classes + */ + private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED); + + /** + * Translates DFA states to action switch labels. + */ + private static final int [] ZZ_ACTION = zzUnpackAction(); + + private static final String ZZ_ACTION_PACKED_0 = + "\1\0\1\1\1\2\3\1\1\3\10\0\1\4\1\5"; + + private static int [] zzUnpackAction() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAction(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /** + * Translates a state to a row index in the transition table + */ + private static final int [] ZZ_ROWMAP = zzUnpackRowMap(); + + private static final String ZZ_ROWMAP_PACKED_0 = + "\0\0\0\15\0\32\0\47\0\64\0\101\0\15\0\116"+ + "\0\133\0\150\0\165\0\202\0\217\0\234\0\251\0\15"+ + "\0\15"; + + private static int [] zzUnpackRowMap() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackRowMap(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int high = packed.charAt(i++) << 16; + result[j++] = high | packed.charAt(i++); + } + return j; + } + + /** + * The transition table of the DFA + */ + private static final int [] ZZ_TRANS = zzUnpackTrans(); + + private static final String ZZ_TRANS_PACKED_0 = + "\1\2\1\3\1\4\1\2\1\5\2\2\1\6\5\2"+ + "\16\0\1\3\16\0\1\7\16\0\1\10\20\0\1\11"+ + "\11\0\1\12\20\0\1\13\4\0\1\14\25\0\1\15"+ + "\10\0\1\16\21\0\1\17\10\0\1\20\12\0\1\21"+ + "\6\0"; + + private static int [] zzUnpackTrans() { + int [] result = new int[182]; + int offset = 0; + offset = zzUnpackTrans(ZZ_TRANS_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackTrans(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + value--; + do result[j++] = value; while (--count > 0); + } + return j; + } + + + /* error codes */ + private static final int ZZ_UNKNOWN_ERROR = 0; + private static final int ZZ_NO_MATCH = 1; + private static final int ZZ_PUSHBACK_2BIG = 2; + private static final char[] EMPTY_BUFFER = new char[0]; + private static final int YYEOF = -1; + private static java.io.Reader zzReader = null; // Fake + + /* error messages for the codes above */ + private static final String ZZ_ERROR_MSG[] = { + "Unkown internal scanner error", + "Error: could not match input", + "Error: pushback value was too large" + }; + + /** + * ZZ_ATTRIBUTE[aState] contains the attributes of state aState + */ + private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute(); + + private static final String ZZ_ATTRIBUTE_PACKED_0 = + "\1\0\1\11\4\1\1\11\10\0\2\11"; + + private static int [] zzUnpackAttribute() { + int [] result = new int[17]; + int offset = 0; + offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result); + return result; + } + + private static int zzUnpackAttribute(String packed, int offset, int [] result) { + int i = 0; /* index in packed string */ + int j = offset; /* index in unpacked array */ + int l = packed.length(); + while (i < l) { + int count = packed.charAt(i++); + int value = packed.charAt(i++); + do result[j++] = value; while (--count > 0); + } + return j; + } + + /** the current state of the DFA */ + private int zzState; + + /** the current lexical state */ + private int zzLexicalState = YYINITIAL; + + /** this buffer contains the current text to be matched and is + the source of the yytext() string */ + private CharSequence zzBuffer = ""; + + /** this buffer may contains the current text array to be matched when it is cheap to acquire it */ + private char[] zzBufferArray; + + /** the textposition at the last accepting state */ + private int zzMarkedPos; + + /** the textposition at the last state to be included in yytext */ + private int zzPushbackPos; + + /** the current text position in the buffer */ + private int zzCurrentPos; + + /** startRead marks the beginning of the yytext() string in the buffer */ + private int zzStartRead; + + /** endRead marks the last character in the buffer, that has been read + from input */ + private int zzEndRead; + + /** + * zzAtBOL == true <=> the scanner is currently at the beginning of a line + */ + private boolean zzAtBOL = true; + + /** zzAtEOF == true <=> the scanner is at the EOF */ + private boolean zzAtEOF; + + /* user code: */ + public _GrammarLexer() { + this((java.io.Reader)null); + } + + + /** + * Creates a new scanner + * + * @param in the java.io.Reader to read input from. + */ + public _GrammarLexer(java.io.Reader in) { + this.zzReader = in; + } + + + /** + * Unpacks the compressed character translation table. + * + * @param packed the packed character translation table + * @return the unpacked character translation table + */ + private static char [] zzUnpackCMap(String packed) { + char [] map = new char[0x10000]; + int i = 0; /* index in packed string */ + int j = 0; /* index in unpacked array */ + while (i < 52) { + int count = packed.charAt(i++); + char value = packed.charAt(i++); + do map[j++] = value; while (--count > 0); + } + return map; + } + + public final int getTokenStart(){ + return zzStartRead; + } + + public final int getTokenEnd(){ + return getTokenStart() + yylength(); + } + + public void reset(CharSequence buffer, int start, int end,int initialState){ + zzBuffer = buffer; + zzBufferArray = com.intellij.util.text.CharArrayUtil.fromSequenceWithoutCopying(buffer); + zzCurrentPos = zzMarkedPos = zzStartRead = start; + zzPushbackPos = 0; + zzAtEOF = false; + zzAtBOL = true; + zzEndRead = end; + yybegin(initialState); + } + + /** + * Refills the input buffer. + * + * @return false, iff there was new input. + * + * @exception java.io.IOException if any I/O-Error occurs + */ + private boolean zzRefill() throws java.io.IOException { + return true; + } + + + /** + * Returns the current lexical state. + */ + public final int yystate() { + return zzLexicalState; + } + + + /** + * Enters a new lexical state + * + * @param newState the new lexical state + */ + public final void yybegin(int newState) { + zzLexicalState = newState; + } + + + /** + * Returns the text matched by the current regular expression. + */ + public final CharSequence yytext() { + return zzBuffer.subSequence(zzStartRead, zzMarkedPos); + } + + + /** + * Returns the character at position pos from the + * matched text. + * + * It is equivalent to yytext().charAt(pos), but faster + * + * @param pos the position of the character to fetch. + * A value from 0 to yylength()-1. + * + * @return the character at position pos + */ + public final char yycharat(int pos) { + return zzBufferArray != null ? zzBufferArray[zzStartRead+pos]:zzBuffer.charAt(zzStartRead+pos); + } + + + /** + * Returns the length of the matched text region. + */ + public final int yylength() { + return zzMarkedPos-zzStartRead; + } + + + /** + * Reports an error that occured while scanning. + * + * In a wellformed scanner (no or only correct usage of + * yypushback(int) and a match-all fallback rule) this method + * will only be called with things that "Can't Possibly Happen". + * If this method is called, something is seriously wrong + * (e.g. a JFlex bug producing a faulty scanner etc.). + * + * Usual syntax/scanner level error handling should be done + * in error fallback rules. + * + * @param errorCode the code of the errormessage to display + */ + private void zzScanError(int errorCode) { + String message; + try { + message = ZZ_ERROR_MSG[errorCode]; + } + catch (ArrayIndexOutOfBoundsException e) { + message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR]; + } + + throw new Error(message); + } + + + /** + * Pushes the specified amount of characters back into the input stream. + * + * They will be read again by then next call of the scanning method + * + * @param number the number of characters to be read again. + * This number must not be greater than yylength()! + */ + public void yypushback(int number) { + if ( number > yylength() ) + zzScanError(ZZ_PUSHBACK_2BIG); + + zzMarkedPos -= number; + } + + + /** + * Resumes scanning until the next regular expression is matched, + * the end of input is encountered or an I/O-Error occurs. + * + * @return the next token + * @exception java.io.IOException if any I/O-Error occurs + */ + public IElementType advance() throws java.io.IOException { + int zzInput; + int zzAction; + + // cached fields: + int zzCurrentPosL; + int zzMarkedPosL; + int zzEndReadL = zzEndRead; + CharSequence zzBufferL = zzBuffer; + char[] zzBufferArrayL = zzBufferArray; + char [] zzCMapL = ZZ_CMAP; + + int [] zzTransL = ZZ_TRANS; + int [] zzRowMapL = ZZ_ROWMAP; + int [] zzAttrL = ZZ_ATTRIBUTE; + + while (true) { + zzMarkedPosL = zzMarkedPos; + + zzAction = -1; + + zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL; + + zzState = ZZ_LEXSTATE[zzLexicalState]; + + + zzForAction: { + while (true) { + + if (zzCurrentPosL < zzEndReadL) + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + else if (zzAtEOF) { + zzInput = YYEOF; + break zzForAction; + } + else { + // store back cached positions + zzCurrentPos = zzCurrentPosL; + zzMarkedPos = zzMarkedPosL; + boolean eof = zzRefill(); + // get translated positions and possibly new buffer + zzCurrentPosL = zzCurrentPos; + zzMarkedPosL = zzMarkedPos; + zzBufferL = zzBuffer; + zzEndReadL = zzEndRead; + if (eof) { + zzInput = YYEOF; + break zzForAction; + } + else { + zzInput = (zzBufferArrayL != null ? zzBufferArrayL[zzCurrentPosL++] : zzBufferL.charAt(zzCurrentPosL++)); + } + } + int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ]; + if (zzNext == -1) break zzForAction; + zzState = zzNext; + + int zzAttributes = zzAttrL[zzState]; + if ( (zzAttributes & 1) == 1 ) { + zzAction = zzState; + zzMarkedPosL = zzCurrentPosL; + if ( (zzAttributes & 8) == 8 ) break zzForAction; + } + + } + } + + // store back cached position + zzMarkedPos = zzMarkedPosL; + + switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) { + case 1: + { return com.intellij.psi.TokenType.BAD_CHARACTER; + } + case 6: break; + case 4: + { return BNF_STRING; + } + case 7: break; + case 5: + { return BNF_NUMBER; + } + case 8: break; + case 3: + { return BNF_ID; + } + case 9: break; + case 2: + { return com.intellij.psi.TokenType.WHITE_SPACE; + } + case 10: break; + default: + if (zzInput == YYEOF && zzStartRead == zzCurrentPos) { + zzAtEOF = true; + return null; + } + else { + zzScanError(ZZ_NO_MATCH); + } + } + } + } + + +} diff --git a/test/test_generated.rb b/test/test_generated.rb index 164e1fc2..591f50ed 100644 --- a/test/test_generated.rb +++ b/test/test_generated.rb @@ -69,5 +69,11 @@ class TestGenerated < Minitest::Test # Specflow generated_fixture_without_loading_data("Features/BindingCulture.feature.cs") + + # JFlex + generated_sample_loading_data("Java/JFlexLexer.java") + + # GrammarKit + generated_sample_loading_data("Java/GrammarKit.java") end end