aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gen/org/jetbrains/markdown/MarkdownParser.java2150
-rw-r--r--src/Formats/HtmlFormatService.kt4
-rw-r--r--src/Formats/MarkdownFormatService.kt6
-rw-r--r--src/Formats/StructuredFormatService.kt5
-rw-r--r--src/Kotlin/ContentBuilder.kt30
-rw-r--r--src/Kotlin/CrossReferences.kt44
-rw-r--r--src/Kotlin/DocumentationContext.kt2
-rw-r--r--src/Kotlin/ResolveReferences.kt83
-rw-r--r--src/Languages/JavaLanguageService.kt25
-rw-r--r--src/Languages/KotlinLanguageService.kt29
-rw-r--r--src/Languages/LanguageService.kt17
-rw-r--r--src/Markdown/markdown.bnf6
-rw-r--r--src/Model/Content.kt4
-rw-r--r--styles/style.css6
-rw-r--r--test/src/markdown/ParserTest.kt2
15 files changed, 1253 insertions, 1160 deletions
diff --git a/gen/org/jetbrains/markdown/MarkdownParser.java b/gen/org/jetbrains/markdown/MarkdownParser.java
index 2ca6dffd..c6068e5b 100644
--- a/gen/org/jetbrains/markdown/MarkdownParser.java
+++ b/gen/org/jetbrains/markdown/MarkdownParser.java
@@ -13,131 +13,131 @@ import com.intellij.lang.PsiParser;
@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class MarkdownParser implements PsiParser {
- public ASTNode parse(IElementType root_, PsiBuilder builder_) {
- parse_only_(root_, builder_);
- return builder_.getTreeBuilt();
+ public ASTNode parse(IElementType t, PsiBuilder b) {
+ parse_only_(t, b);
+ return b.getTreeBuilt();
}
- public void parse_only_(IElementType root_, PsiBuilder builder_) {
- boolean result_;
- builder_ = adapt_builder_(root_, builder_, this, null);
- Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
- if (root_ == ANONYMOUS_SECTION) {
- result_ = AnonymousSection(builder_, 0);
+ public void parse_only_(IElementType t, PsiBuilder b) {
+ boolean r;
+ b = adapt_builder_(t, b, this, null);
+ Marker m = enter_section_(b, 0, _COLLAPSE_, null);
+ if (t == ANONYMOUS_SECTION) {
+ r = AnonymousSection(b, 0);
}
- else if (root_ == BLANK_LINE) {
- result_ = BlankLine(builder_, 0);
+ else if (t == BLANK_LINE) {
+ r = BlankLine(b, 0);
}
- else if (root_ == BLOCK) {
- result_ = Block(builder_, 0);
+ else if (t == BLOCK) {
+ r = Block(b, 0);
}
- else if (root_ == BULLET) {
- result_ = Bullet(builder_, 0);
+ else if (t == BULLET) {
+ r = Bullet(b, 0);
}
- else if (root_ == BULLET_LIST) {
- result_ = BulletList(builder_, 0);
+ else if (t == BULLET_LIST) {
+ r = BulletList(b, 0);
}
- else if (root_ == EMPH) {
- result_ = Emph(builder_, 0);
+ else if (t == EMPH) {
+ r = Emph(b, 0);
}
- else if (root_ == END_LINE) {
- result_ = EndLine(builder_, 0);
+ else if (t == END_LINE) {
+ r = EndLine(b, 0);
}
- else if (root_ == ENUMERATOR) {
- result_ = Enumerator(builder_, 0);
+ else if (t == ENUMERATOR) {
+ r = Enumerator(b, 0);
}
- else if (root_ == HORIZONTAL_RULE) {
- result_ = HorizontalRule(builder_, 0);
+ else if (t == HORIZONTAL_RULE) {
+ r = HorizontalRule(b, 0);
}
- else if (root_ == HREF) {
- result_ = Href(builder_, 0);
+ else if (t == HREF) {
+ r = Href(b, 0);
}
- else if (root_ == INLINE) {
- result_ = Inline(builder_, 0);
+ else if (t == INLINE) {
+ r = Inline(b, 0);
}
- else if (root_ == LINK) {
- result_ = Link(builder_, 0);
+ else if (t == LINK) {
+ r = Link(b, 0);
}
- else if (root_ == LIST_BLOCK) {
- result_ = ListBlock(builder_, 0);
+ else if (t == LIST_BLOCK) {
+ r = ListBlock(b, 0);
}
- else if (root_ == LIST_BLOCK_LINE) {
- result_ = ListBlockLine(builder_, 0);
+ else if (t == LIST_BLOCK_LINE) {
+ r = ListBlockLine(b, 0);
}
- else if (root_ == LIST_CONTINUATION_BLOCK) {
- result_ = ListContinuationBlock(builder_, 0);
+ else if (t == LIST_CONTINUATION_BLOCK) {
+ r = ListContinuationBlock(b, 0);
}
- else if (root_ == LIST_ITEM) {
- result_ = ListItem(builder_, 0);
+ else if (t == LIST_ITEM) {
+ r = ListItem(b, 0);
}
- else if (root_ == NAMED_SECTION) {
- result_ = NamedSection(builder_, 0);
+ else if (t == NAMED_SECTION) {
+ r = NamedSection(b, 0);
}
- else if (root_ == ORDERED_LIST) {
- result_ = OrderedList(builder_, 0);
+ else if (t == ORDERED_LIST) {
+ r = OrderedList(b, 0);
}
- else if (root_ == PARA) {
- result_ = Para(builder_, 0);
+ else if (t == PARA) {
+ r = Para(b, 0);
}
- else if (root_ == PLAIN_TEXT) {
- result_ = PlainText(builder_, 0);
+ else if (t == PLAIN_TEXT) {
+ r = PlainText(b, 0);
}
- else if (root_ == SECTION_BODY) {
- result_ = SectionBody(builder_, 0);
+ else if (t == SECTION_BODY) {
+ r = SectionBody(b, 0);
}
- else if (root_ == SECTION_NAME) {
- result_ = SectionName(builder_, 0);
+ else if (t == SECTION_NAME) {
+ r = SectionName(b, 0);
}
- else if (root_ == STRONG) {
- result_ = Strong(builder_, 0);
+ else if (t == STRONG) {
+ r = Strong(b, 0);
}
- else if (root_ == STRONG_STAR) {
- result_ = StrongStar(builder_, 0);
+ else if (t == STRONG_STAR) {
+ r = StrongStar(b, 0);
}
- else if (root_ == STRONG_UNDERSCORE) {
- result_ = StrongUnderscore(builder_, 0);
+ else if (t == STRONG_UNDERSCORE) {
+ r = StrongUnderscore(b, 0);
}
- else if (root_ == TARGET) {
- result_ = Target(builder_, 0);
+ else if (t == TARGET) {
+ r = Target(b, 0);
}
- else if (root_ == UNUSED) {
- result_ = Unused(builder_, 0);
+ else if (t == UNUSED) {
+ r = Unused(b, 0);
}
- else if (root_ == WHITESPACE) {
- result_ = Whitespace(builder_, 0);
+ else if (t == WHITESPACE) {
+ r = Whitespace(b, 0);
}
else {
- result_ = parse_root_(root_, builder_, 0);
+ r = parse_root_(t, b, 0);
}
- exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
+ exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
- protected boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
- return Document(builder_, level_ + 1);
+ protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
+ return Document(b, l + 1);
}
/* ********************************************************** */
// SectionBody
- public static boolean AnonymousSection(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "AnonymousSection")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<anonymous section>");
- result_ = SectionBody(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, ANONYMOUS_SECTION, result_, false, null);
- return result_;
+ public static boolean AnonymousSection(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "AnonymousSection")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<anonymous section>");
+ r = SectionBody(b, l + 1);
+ exit_section_(b, l, m, ANONYMOUS_SECTION, r, false, null);
+ return r;
}
/* ********************************************************** */
// OptionalSpace EOL
- public static boolean BlankLine(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "BlankLine")) return false;
- if (!nextTokenIs(builder_, "<blank line>", EOL, SPACE)) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<blank line>");
- result_ = OptionalSpace(builder_, level_ + 1);
- result_ = result_ && consumeToken(builder_, EOL);
- exit_section_(builder_, level_, marker_, BLANK_LINE, result_, false, null);
- return result_;
+ public static boolean BlankLine(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "BlankLine")) return false;
+ if (!nextTokenIs(b, "<blank line>", EOL, SPACE)) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<blank line>");
+ r = OptionalSpace(b, l + 1);
+ r = r && consumeToken(b, EOL);
+ exit_section_(b, l, m, BLANK_LINE, r, false, null);
+ return r;
}
/* ********************************************************** */
@@ -147,24 +147,24 @@ public class MarkdownParser implements PsiParser {
// | HorizontalRule
// | Para
// )
- public static boolean Block(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Block")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<block>");
- result_ = Block_0(builder_, level_ + 1);
- result_ = result_ && Block_1(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, BLOCK, result_, false, null);
- return result_;
+ public static boolean Block(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Block")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<block>");
+ r = Block_0(b, l + 1);
+ r = r && Block_1(b, l + 1);
+ exit_section_(b, l, m, BLOCK, r, false, null);
+ return r;
}
// BlankLine*
- private static boolean Block_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Block_0")) return false;
- int pos_ = current_position_(builder_);
+ private static boolean Block_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Block_0")) return false;
+ int c = current_position_(b);
while (true) {
- if (!BlankLine(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "Block_0", pos_)) break;
- pos_ = current_position_(builder_);
+ if (!BlankLine(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "Block_0", c)) break;
+ c = current_position_(b);
}
return true;
}
@@ -173,341 +173,341 @@ public class MarkdownParser implements PsiParser {
// | BulletList
// | HorizontalRule
// | Para
- private static boolean Block_1(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Block_1")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = OrderedList(builder_, level_ + 1);
- if (!result_) result_ = BulletList(builder_, level_ + 1);
- if (!result_) result_ = HorizontalRule(builder_, level_ + 1);
- if (!result_) result_ = Para(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean Block_1(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Block_1")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = OrderedList(b, l + 1);
+ if (!r) r = BulletList(b, l + 1);
+ if (!r) r = HorizontalRule(b, l + 1);
+ if (!r) r = Para(b, l + 1);
+ exit_section_(b, m, null, r);
+ return r;
}
/* ********************************************************** */
// !HorizontalRule NonindentSpace ('+' | '*' | '-') Space+
- public static boolean Bullet(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Bullet")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<bullet>");
- result_ = Bullet_0(builder_, level_ + 1);
- result_ = result_ && NonindentSpace(builder_, level_ + 1);
- result_ = result_ && Bullet_2(builder_, level_ + 1);
- result_ = result_ && Bullet_3(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, BULLET, result_, false, null);
- return result_;
+ public static boolean Bullet(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Bullet")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<bullet>");
+ r = Bullet_0(b, l + 1);
+ r = r && NonindentSpace(b, l + 1);
+ r = r && Bullet_2(b, l + 1);
+ r = r && Bullet_3(b, l + 1);
+ exit_section_(b, l, m, BULLET, r, false, null);
+ return r;
}
// !HorizontalRule
- private static boolean Bullet_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Bullet_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
- result_ = !HorizontalRule(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean Bullet_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Bullet_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NOT_, null);
+ r = !HorizontalRule(b, l + 1);
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
// '+' | '*' | '-'
- private static boolean Bullet_2(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Bullet_2")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = consumeToken(builder_, "+");
- if (!result_) result_ = consumeToken(builder_, "*");
- if (!result_) result_ = consumeToken(builder_, "-");
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean Bullet_2(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Bullet_2")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = consumeToken(b, "+");
+ if (!r) r = consumeToken(b, "*");
+ if (!r) r = consumeToken(b, "-");
+ exit_section_(b, m, null, r);
+ return r;
}
// Space+
- private static boolean Bullet_3(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Bullet_3")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = consumeToken(builder_, SPACE);
- int pos_ = current_position_(builder_);
- while (result_) {
- if (!consumeToken(builder_, SPACE)) break;
- if (!empty_element_parsed_guard_(builder_, "Bullet_3", pos_)) break;
- pos_ = current_position_(builder_);
+ private static boolean Bullet_3(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Bullet_3")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = consumeToken(b, SPACE);
+ int c = current_position_(b);
+ while (r) {
+ if (!consumeToken(b, SPACE)) break;
+ if (!empty_element_parsed_guard_(b, "Bullet_3", c)) break;
+ c = current_position_(b);
}
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ exit_section_(b, m, null, r);
+ return r;
}
/* ********************************************************** */
// &Bullet List
- public static boolean BulletList(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "BulletList")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<bullet list>");
- result_ = BulletList_0(builder_, level_ + 1);
- result_ = result_ && List(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, BULLET_LIST, result_, false, null);
- return result_;
+ public static boolean BulletList(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "BulletList")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<bullet list>");
+ r = BulletList_0(b, l + 1);
+ r = r && List(b, l + 1);
+ exit_section_(b, l, m, BULLET_LIST, r, false, null);
+ return r;
}
// &Bullet
- private static boolean BulletList_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "BulletList_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _AND_, null);
- result_ = Bullet(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean BulletList_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "BulletList_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _AND_, null);
+ r = Bullet(b, l + 1);
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
/* ********************************************************** */
// BOM? Whitespace* AnonymousSection? (Whitespace* NamedSection)*
- static boolean Document(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = Document_0(builder_, level_ + 1);
- result_ = result_ && Document_1(builder_, level_ + 1);
- result_ = result_ && Document_2(builder_, level_ + 1);
- result_ = result_ && Document_3(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ static boolean Document(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = Document_0(b, l + 1);
+ r = r && Document_1(b, l + 1);
+ r = r && Document_2(b, l + 1);
+ r = r && Document_3(b, l + 1);
+ exit_section_(b, m, null, r);
+ return r;
}
// BOM?
- private static boolean Document_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_0")) return false;
- consumeToken(builder_, BOM);
+ private static boolean Document_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_0")) return false;
+ consumeToken(b, BOM);
return true;
}
// Whitespace*
- private static boolean Document_1(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_1")) return false;
- int pos_ = current_position_(builder_);
+ private static boolean Document_1(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_1")) return false;
+ int c = current_position_(b);
while (true) {
- if (!Whitespace(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "Document_1", pos_)) break;
- pos_ = current_position_(builder_);
+ if (!Whitespace(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "Document_1", c)) break;
+ c = current_position_(b);
}
return true;
}
// AnonymousSection?
- private static boolean Document_2(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_2")) return false;
- AnonymousSection(builder_, level_ + 1);
+ private static boolean Document_2(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_2")) return false;
+ AnonymousSection(b, l + 1);
return true;
}
// (Whitespace* NamedSection)*
- private static boolean Document_3(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_3")) return false;
- int pos_ = current_position_(builder_);
+ private static boolean Document_3(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_3")) return false;
+ int c = current_position_(b);
while (true) {
- if (!Document_3_0(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "Document_3", pos_)) break;
- pos_ = current_position_(builder_);
+ if (!Document_3_0(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "Document_3", c)) break;
+ c = current_position_(b);
}
return true;
}
// Whitespace* NamedSection
- private static boolean Document_3_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_3_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = Document_3_0_0(builder_, level_ + 1);
- result_ = result_ && NamedSection(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean Document_3_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_3_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = Document_3_0_0(b, l + 1);
+ r = r && NamedSection(b, l + 1);
+ exit_section_(b, m, null, r);
+ return r;
}
// Whitespace*
- private static boolean Document_3_0_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Document_3_0_0")) return false;
- int pos_ = current_position_(builder_);
+ private static boolean Document_3_0_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Document_3_0_0")) return false;
+ int c = current_position_(b);
while (true) {
- if (!Whitespace(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "Document_3_0_0", pos_)) break;
- pos_ = current_position_(builder_);
+ if (!Whitespace(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "Document_3_0_0", c)) break;
+ c = current_position_(b);
}
return true;
}
/* ********************************************************** */
// EmphStar | EmphUnderscore
- public static boolean Emph(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Emph")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<emph>");
- result_ = EmphStar(builder_, level_ + 1);
- if (!result_) result_ = EmphUnderscore(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, EMPH, result_, false, null);
- return result_;
+ public static boolean Emph(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Emph")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<emph>");
+ r = EmphStar(b, l + 1);
+ if (!r) r = EmphUnderscore(b, l + 1);
+ exit_section_(b, l, m, EMPH, r, false, null);
+ return r;
}
/* ********************************************************** */
// '*' !Whitespace (!'*' Inline)+ '*'
- static boolean EmphStar(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphStar")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = consumeToken(builder_, "*");
- result_ = result_ && EmphStar_1(builder_, level_ + 1);
- result_ = result_ && EmphStar_2(builder_, level_ + 1);
- result_ = result_ && consumeToken(builder_, "*");
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ static boolean EmphStar(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphStar")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = consumeToken(b, "*");
+ r = r && EmphStar_1(b, l + 1);
+ r = r && EmphStar_2(b, l + 1);
+ r = r && consumeToken(b, "*");
+ exit_section_(b, m, null, r);
+ return r;
}
// !Whitespace
- private static boolean EmphStar_1(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphStar_1")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
- result_ = !Whitespace(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean EmphStar_1(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphStar_1")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NOT_, null);
+ r = !Whitespace(b, l + 1);
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
// (!'*' Inline)+
- private static boolean EmphStar_2(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphStar_2")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = EmphStar_2_0(builder_, level_ + 1);
- int pos_ = current_position_(builder_);
- while (result_) {
- if (!EmphStar_2_0(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "EmphStar_2", pos_)) break;
- pos_ = current_position_(builder_);
+ private static boolean EmphStar_2(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphStar_2")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = EmphStar_2_0(b, l + 1);
+ int c = current_position_(b);
+ while (r) {
+ if (!EmphStar_2_0(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "EmphStar_2", c)) break;
+ c = current_position_(b);
}
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ exit_section_(b, m, null, r);
+ return r;
}
// !'*' Inline
- private static boolean EmphStar_2_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphStar_2_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = EmphStar_2_0_0(builder_, level_ + 1);
- result_ = result_ && Inline(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean EmphStar_2_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphStar_2_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = EmphStar_2_0_0(b, l + 1);
+ r = r && Inline(b, l + 1);
+ exit_section_(b, m, null, r);
+ return r;
}
// !'*'
- private static boolean EmphStar_2_0_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphStar_2_0_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
- result_ = !consumeToken(builder_, "*");
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean EmphStar_2_0_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphStar_2_0_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NOT_, null);
+ r = !consumeToken(b, "*");
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
/* ********************************************************** */
// '_' !Whitespace (!'_' Inline)+ '_'
- static boolean EmphUnderscore(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphUnderscore")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = consumeToken(builder_, "_");
- result_ = result_ && EmphUnderscore_1(builder_, level_ + 1);
- result_ = result_ && EmphUnderscore_2(builder_, level_ + 1);
- result_ = result_ && consumeToken(builder_, "_");
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ static boolean EmphUnderscore(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphUnderscore")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = consumeToken(b, "_");
+ r = r && EmphUnderscore_1(b, l + 1);
+ r = r && EmphUnderscore_2(b, l + 1);
+ r = r && consumeToken(b, "_");
+ exit_section_(b, m, null, r);
+ return r;
}
// !Whitespace
- private static boolean EmphUnderscore_1(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphUnderscore_1")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
- result_ = !Whitespace(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean EmphUnderscore_1(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphUnderscore_1")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NOT_, null);
+ r = !Whitespace(b, l + 1);
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
// (!'_' Inline)+
- private static boolean EmphUnderscore_2(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphUnderscore_2")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = EmphUnderscore_2_0(builder_, level_ + 1);
- int pos_ = current_position_(builder_);
- while (result_) {
- if (!EmphUnderscore_2_0(builder_, level_ + 1)) break;
- if (!empty_element_parsed_guard_(builder_, "EmphUnderscore_2", pos_)) break;
- pos_ = current_position_(builder_);
+ private static boolean EmphUnderscore_2(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphUnderscore_2")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = EmphUnderscore_2_0(b, l + 1);
+ int c = current_position_(b);
+ while (r) {
+ if (!EmphUnderscore_2_0(b, l + 1)) break;
+ if (!empty_element_parsed_guard_(b, "EmphUnderscore_2", c)) break;
+ c = current_position_(b);
}
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ exit_section_(b, m, null, r);
+ return r;
}
// !'_' Inline
- private static boolean EmphUnderscore_2_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphUnderscore_2_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = EmphUnderscore_2_0_0(builder_, level_ + 1);
- result_ = result_ && Inline(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean EmphUnderscore_2_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphUnderscore_2_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = EmphUnderscore_2_0_0(b, l + 1);
+ r = r && Inline(b, l + 1);
+ exit_section_(b, m, null, r);
+ return r;
}
// !'_'
- private static boolean EmphUnderscore_2_0_0(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EmphUnderscore_2_0_0")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NOT_, null);
- result_ = !consumeToken(builder_, "_");
- exit_section_(builder_, level_, marker_, null, result_, false, null);
- return result_;
+ private static boolean EmphUnderscore_2_0_0(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EmphUnderscore_2_0_0")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NOT_, null);
+ r = !consumeToken(b, "_");
+ exit_section_(b, l, m, null, r, false, null);
+ return r;
}
/* ********************************************************** */
// TerminalEndline | NormalEndline
- public static boolean EndLine(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "EndLine")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<end line>");
- result_ = TerminalEndline(builder_, level_ + 1);
- if (!result_) result_ = NormalEndline(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, END_LINE, result_, false, null);
- return result_;
+ public static boolean EndLine(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "EndLine")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<end line>");
+ r = TerminalEndline(b, l + 1);
+ if (!r) r = NormalEndline(b, l + 1);
+ exit_section_(b, l, m, END_LINE, r, false, null);
+ return r;
}
/* ********************************************************** */
// NonindentSpace Number '.' Space+
- public static boolean Enumerator(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Enumerator")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<enumerator>");
- result_ = NonindentSpace(builder_, level_ + 1);
- result_ = result_ && consumeToken(builder_, NUMBER);
- result_ = result_ && consumeToken(builder_, ".");
- result_ = result_ && Enumerator_3(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, ENUMERATOR, result_, false, null);
- return result_;
+ public static boolean Enumerator(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Enumerator")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<enumerator>");
+ r = NonindentSpace(b, l + 1);
+ r = r && consumeToken(b, NUMBER);
+ r = r && consumeToken(b, ".");
+ r = r && Enumerator_3(b, l + 1);
+ exit_section_(b, l, m, ENUMERATOR, r, false, null);
+ return r;
}
// Space+
- private static boolean Enumerator_3(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "Enumerator_3")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = consumeToken(builder_, SPACE);
- int pos_ = current_position_(builder_);
- while (result_) {
- if (!consumeToken(builder_, SPACE)) break;
- if (!empty_element_parsed_guard_(builder_, "Enumerator_3", pos_)) break;
- pos_ = current_position_(builder_);
+ private static boolean Enumerator_3(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "Enumerator_3")) return false;
+ boolean r;
+ Marker m = enter_section_(b);
+ r = consumeToken(b, SPACE);
+ int c = current_position_(b);
+ while (r) {
+ if (!consumeToken(b, SPACE)) break;
+ if (!empty_element_parsed_guard_(b, "Enumerator_3", c)) break;
+ c = current_position_(b);
}
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ exit_section_(b, m, null, r);
+ return r;
}
/* ********************************************************** */
@@ -516,1089 +516,1093 @@ public class MarkdownParser implements PsiParser {
// | '-' OptionalSpace '-' OptionalSpace '-' (OptionalSpace '-')*
// | '_' OptionalSpace '_' OptionalSpace '_' (OptionalSpace '_')*)
// OptionalSpace EOL BlankLine+
- public static boolean HorizontalRule(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "HorizontalRule")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_, level_, _NONE_, "<horizontal rule>");
- result_ = NonindentSpace(builder_, level_ + 1);
- result_ = result_ && HorizontalRule_1(builder_, level_ + 1);
- result_ = result_ && OptionalSpace(builder_, level_ + 1);
- result_ = result_ && consumeToken(builder_, EOL);
- result_ = result_ && HorizontalRule_4(builder_, level_ + 1);
- exit_section_(builder_, level_, marker_, HORIZONTAL_RULE, result_, false, null);
- return result_;
+ public static boolean HorizontalRule(PsiBuilder b, int l) {
+ if (!recursion_guard_(b, l, "HorizontalRule")) return false;
+ boolean r;
+ Marker m = enter_section_(b, l, _NONE_, "<horizontal rule>");
+ r = NonindentSpace(b, l + 1);
+ r = r && HorizontalRule_1(b, l + 1);
+ r = r && OptionalSpace(b, l + 1);
+ r = r && consumeToken(b, EOL);
+ r = r && HorizontalRule_4(b, l + 1);
+ exit_section_(b, l, m, HORIZONTAL_RULE, r, false, null);
+ return r;
}
// '*' OptionalSpace '*' OptionalSpace '*' (OptionalSpace '*')*
// | '-' OptionalSpace '-' OptionalSpace '-' (OptionalSpace '-')*
// | '_' OptionalSpace '_' OptionalSpace '_' (OptionalSpace '_')*
- private static boolean HorizontalRule_1(PsiBuilder builder_, int level_) {
- if (!recursion_guard_(builder_, level_, "HorizontalRule_1")) return false;
- boolean result_;
- Marker marker_ = enter_section_(builder_);
- result_ = HorizontalRule_1_0(builder_, level_ + 1);
- if (!result_) result_ = HorizontalRule_1_1(builder_, level_ + 1);
- if (!result_) result_ = HorizontalRule_1_2(builder_, level_ + 1);
- exit_section_(builder_, marker_, null, result_);
- return result_;
+ private static boolean HorizontalRule_1(PsiBuilder b,