synapticloop.documentr.generator.plugin

Class ExtendedParser

java.lang.Object

org.parboiled.BaseActions<V>

org.parboiled.BaseParser<Object>

org.pegdown.Parser

synapticloop.documentr.generator.plugin.ExtendedParser

All Implemented Interfaces:

org.parboiled.ContextAware<Object>, org.pegdown.Extensions

public class ExtendedParser
extends org.pegdown.Parser

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static interface	ExtendedParser.SuperNodeCreator
protected static interface	ExtendedParser.SuperNodeTaskItemCreator

Nested classes/interfaces inherited from class org.pegdown.Parser

org.pegdown.Parser.ParseRunnerProvider

Field Summary

Fields

Modifier and Type	Field and Description
protected static char	CROSSED_OUT
protected static Set<String>	HTML_TAGS
protected long	maxParsingTimeInMillis
protected int	options
protected org.pegdown.Parser.ParseRunnerProvider	parseRunnerProvider
protected org.pegdown.plugins.PegDownPlugins	plugins

Fields inherited from class org.pegdown.Parser

DefaultParseRunnerProvider

Fields inherited from class org.parboiled.BaseParser

ANY, DEDENT, EMPTY, EOI, INDENT, NOTHING

Fields inherited from interface org.pegdown.Extensions

ABBREVIATIONS, ALL, ALL_OPTIONALS, ALL_WITH_OPTIONALS, ANCHORLINKS, ATXHEADERSPACE, AUTOLINKS, DEFINITIONS, EXTANCHORLINKS, FENCED_CODE_BLOCKS, FORCELISTITEMPARA, HARDWRAPS, NONE, QUOTES, RELAXEDHRULES, SMARTS, SMARTYPANTS, STRIKETHROUGH, SUPPRESS_ALL_HTML, SUPPRESS_HTML_BLOCKS, SUPPRESS_INLINE_HTML, TABLES, TASKLISTITEMS, WIKILINKS

Constructor Summary

Constructors

Constructor and Description
ExtendedParser(Integer options, Long maxParsingTimeInMillis, org.pegdown.Parser.ParseRunnerProvider parseRunnerProvider)
ExtendedParser(Integer options, Long maxParsingTimeInMillis, org.pegdown.Parser.ParseRunnerProvider parseRunnerProvider, org.pegdown.plugins.PegDownPlugins plugins)

Method Summary

Modifier and Type	Method and Description
org.parboiled.Rule	Abbreviation()
org.parboiled.Rule	AbbreviationText(org.parboiled.support.Var<org.pegdown.ast.AbbreviationNode> node)
boolean	addAsChild()
org.parboiled.Rule	Alphanumeric()
org.parboiled.Rule	AtxHeading()
org.parboiled.Rule	AtxInline()
org.parboiled.Rule	AtxStart()
org.parboiled.Rule	AutoLink()
org.parboiled.Rule	AutoLinkEmail()
org.parboiled.Rule	AutoLinkEnd()
org.parboiled.Rule	AutoLinkUrl()
org.parboiled.Rule	BlankLine()
org.parboiled.Rule	Block()
org.parboiled.Rule	BlockQuote()
org.parboiled.Rule	Bullet()
org.parboiled.Rule	BulletList()
org.parboiled.Rule	CaptionInline()
org.parboiled.Rule	CaptionStart()
org.parboiled.Rule	CharEntity()
org.parboiled.Rule	CharLine(char c)
protected boolean	checkForParsingTimeout()
org.parboiled.Rule	Code()
org.parboiled.Rule	Code(org.parboiled.Rule ticks)
org.parboiled.Rule	CodeFence(org.parboiled.support.Var<Integer> markerLength)
void	collectChildrensText(org.pegdown.ast.SuperNode node, synapticloop.documentr.generator.plugin.ExtendedParser.AnchorNodeInfo nodeInfo)
org.parboiled.Rule	CrossedOut(org.parboiled.Rule rule, org.parboiled.support.StringBuilderVar block)
org.parboiled.Rule	CrossedOutLessOne(org.parboiled.Rule rule, org.parboiled.support.StringBuilderVar block)
boolean	debugMsg(String msg, String text)
org.parboiled.Rule	DecEntity()
org.parboiled.Rule	DefinedHtmlTagName(org.parboiled.support.StringVar tagName)
org.parboiled.Rule	Definition()
org.parboiled.Rule	DefinitionList()
org.parboiled.Rule	DefListBullet()
org.parboiled.Rule	DefListTerm()
org.parboiled.Rule	DefTermInline()
org.parboiled.Rule	Digit()
org.parboiled.Rule	DoubleAngleQuoted()
org.parboiled.Rule	DoubleQuoted()
org.parboiled.Rule	Emph()
org.parboiled.Rule	EmphOrStrong(String chars)
org.parboiled.Rule	EmphOrStrongClose(String chars)
org.parboiled.Rule	EmphOrStrongOpen(String chars)
org.parboiled.Rule	Endline()
org.parboiled.Rule	Entity()
org.parboiled.Rule	Enumerator()
org.parboiled.Rule	EscapableChar()
org.parboiled.Rule	EscapedChar()
org.parboiled.Rule	ExplicitLink(boolean image)
boolean	ext(int extension)
org.parboiled.Rule	FencedCodeBlock()
protected void	fixIndices(org.pegdown.ast.Node node, int[] ixMap)
org.parboiled.Rule	Heading()
org.parboiled.Rule	HexEntity()
org.parboiled.Rule	HorizontalRule()
org.parboiled.Rule	HorizontalRule(char c)
org.parboiled.Rule	HtmlAttribute()
org.parboiled.Rule	HtmlBlock()
org.parboiled.Rule	HtmlBlockClose(org.parboiled.support.StringVar tagName)
org.parboiled.Rule	HtmlBlockInTags()
org.parboiled.Rule	HtmlBlockOpen(org.parboiled.support.StringVar tagName)
org.parboiled.Rule	HtmlBlockSelfClosing()
org.parboiled.Rule	HtmlComment()
org.parboiled.Rule	HtmlTag()
org.parboiled.Rule	HtmlTagBlock(org.parboiled.support.StringVar tagName)
org.parboiled.Rule	Image()
org.parboiled.Rule	ImageAlt()
org.parboiled.Rule	Indent()
org.parboiled.Rule	Inline()
org.parboiled.Rule	InlineHtml()
org.parboiled.Rule	InlineOrIntermediateEndline()
org.parboiled.Rule	Inlines()
boolean	isHtmlTag(String string)
protected boolean	isLegalEmphOrStrongClosePos() This method checks if the last parsed character or sequence is a valid prefix for a closing char for an emph or strong sequence.
protected boolean	isLegalEmphOrStrongStartPos() This method checks if current position is a legal start position for a strong or emph sequence by checking the last parsed character(-sequence).
protected boolean	isStrongCloseCharStolen(String chars) This method checks if current parent is a strong parent based on param `chars`.
org.parboiled.Rule	Label()
org.parboiled.Rule	Letter()
org.parboiled.Rule	Line(org.parboiled.support.StringBuilderVar sb)
org.parboiled.Rule	LineBreak()
org.parboiled.Rule	Link()
org.parboiled.Rule	LinkSource()
org.parboiled.Rule	LinkTitle()
org.parboiled.Rule	LinkTitle(char delimiter)
org.parboiled.Rule	ListItem(org.parboiled.Rule itemStart, ExtendedParser.SuperNodeCreator itemNodeCreator)
org.parboiled.Rule	ListItemIndentedBlocks(org.parboiled.support.StringBuilderVar block)
protected boolean	mayEnterEmphOrStrong(String chars) This method checks if the parser can enter an emph or strong sequence Emph only allows Strong as direct child, Strong only allows Emph as direct child.
org.parboiled.Rule	Newline()
org.parboiled.Rule	NodeSequence(Object... nodeRules)
org.parboiled.Rule	NonAutoLink()
org.parboiled.Rule	NonAutoLinkInline()
org.parboiled.Rule	NonindentSpace()
org.parboiled.Rule	NonLinkInline()
org.parboiled.Rule	Nonspacechar()
org.parboiled.Rule	NormalChar()
org.parboiled.Rule	NormalEndline()
org.parboiled.Rule	NOrMore(char c, int n)
org.parboiled.Rule	NotNewline()
org.parboiled.Rule	OrderedList()
org.parboiled.Rule	Para()
org.pegdown.ast.RootNode	parse(char[] source)
org.pegdown.ast.RootNode	parseInternal(char[] source)
org.pegdown.ast.RootNode	parseInternal(org.parboiled.support.StringBuilderVar block)
org.pegdown.ast.Node	popAsNode()
String	popAsString()
org.parboiled.Rule	Quoted()
org.parboiled.Rule	Reference()
org.parboiled.Rule	ReferenceLink(boolean image)
org.parboiled.Rule	ReferenceNoEOL()
org.parboiled.Rule	RefSrc(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)
org.parboiled.Rule	RefSrcContent(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)
org.parboiled.Rule	RefTitle(char open, char close, org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)
org.parboiled.Rule	RefTitle(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)
org.parboiled.Rule	Root()
protected boolean	setClosed() Mark the current StrongEmphSuperNode as closed sequence
org.parboiled.Rule	SetextHeading()
org.parboiled.Rule	SetextHeading1()
org.parboiled.Rule	SetextHeading2()
org.parboiled.Rule	SetextInline()
boolean	setIndices()
org.parboiled.Rule	SingleQuoted()
org.parboiled.Rule	SingleQuoteEnd()
org.parboiled.Rule	Smarts()
org.parboiled.Rule	Sp()
org.parboiled.Rule	Space()
org.parboiled.Rule	Spacechar()
org.parboiled.Rule	SpecialChar()
org.parboiled.Rule	Spn1()
protected boolean	stealBackStrongCloseChar() Steals the last close char by marking a previously closed emph/strong node as unclosed.
org.parboiled.Rule	Str()
org.parboiled.Rule	Strike()
org.parboiled.Rule	Strong()
org.parboiled.Rule	StrongOrEmph()
org.parboiled.Rule	Symbol()
org.parboiled.Rule	Table()
org.parboiled.Rule	TableCaption()
org.parboiled.Rule	TableCell()
org.parboiled.Rule	TableColumn(org.parboiled.support.Var<org.pegdown.ast.TableNode> tableNode, org.parboiled.support.Var<Boolean> pipeSeen)
org.parboiled.Rule	TableDivider(org.parboiled.support.Var<org.pegdown.ast.TableNode> tableNode)
org.parboiled.Rule	TableRow()
org.parboiled.Rule	TaskListItem(org.parboiled.Rule itemStart, ExtendedParser.SuperNodeTaskItemCreator itemNodeCreator)
org.parboiled.Rule	TerminalEndline()
org.parboiled.Rule	TestNotItem()
org.parboiled.Rule	TestNotListItem()
org.parboiled.Rule	Ticks(int count)
org.parboiled.Rule	UlOrStarLine()
org.parboiled.Rule	Verbatim()
org.parboiled.Rule	WikiLink()
boolean	wrapInAnchor()

Methods inherited from class org.pegdown.Parser

collectChildrensText, ListItem, TaskListItem

Methods inherited from class org.parboiled.BaseParser

ACTION, AnyOf, AnyOf, AnyOf, Ch, CharRange, FirstOf, FirstOf, fromCharArray, fromCharLiteral, fromStringLiteral, IgnoreCase, IgnoreCase, IgnoreCase, newInstance, NoneOf, NoneOf, NTimes, NTimes, OneOrMore, OneOrMore, Optional, Optional, Sequence, Sequence, String, String, Test, Test, TestNot, TestNot, toRule, toRules, ZeroOrMore, ZeroOrMore

Methods inherited from class org.parboiled.BaseActions

currentChar, currentIndex, drop, drop, dup, getContext, hasError, inPredicate, match, matchedChar, matchEnd, matchLength, matchOrDefault, matchRange, matchStart, nodeSuppressed, peek, peek, poke, poke, pop, pop, position, push, push, pushAll, setContext, swap, swap3, swap4, swap5, swap6

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CROSSED_OUT

protected static final char CROSSED_OUT

See Also:

Constant Field Values

options

protected final int options

maxParsingTimeInMillis

protected final long maxParsingTimeInMillis

parseRunnerProvider

protected final org.pegdown.Parser.ParseRunnerProvider parseRunnerProvider

plugins

protected final org.pegdown.plugins.PegDownPlugins plugins

HTML_TAGS

protected static final Set<String> HTML_TAGS

Constructor Detail

ExtendedParser

public ExtendedParser(Integer options,
                      Long maxParsingTimeInMillis,
                      org.pegdown.Parser.ParseRunnerProvider parseRunnerProvider,
                      org.pegdown.plugins.PegDownPlugins plugins)

ExtendedParser

public ExtendedParser(Integer options,
                      Long maxParsingTimeInMillis,
                      org.pegdown.Parser.ParseRunnerProvider parseRunnerProvider)

Method Detail

debugMsg

public boolean debugMsg(String msg,
                        String text)

Overrides:

debugMsg in class org.pegdown.Parser

parse

public org.pegdown.ast.RootNode parse(char[] source)

Overrides:

parse in class org.pegdown.Parser

Root

public org.parboiled.Rule Root()

Overrides:

Root in class org.pegdown.Parser

Block

public org.parboiled.Rule Block()

Overrides:

Block in class org.pegdown.Parser

Para

public org.parboiled.Rule Para()

Overrides:

Para in class org.pegdown.Parser

BlockQuote

public org.parboiled.Rule BlockQuote()

Overrides:

BlockQuote in class org.pegdown.Parser

Verbatim

public org.parboiled.Rule Verbatim()

Overrides:

Verbatim in class org.pegdown.Parser

FencedCodeBlock

public org.parboiled.Rule FencedCodeBlock()

Overrides:

FencedCodeBlock in class org.pegdown.Parser

CodeFence

public org.parboiled.Rule CodeFence(org.parboiled.support.Var<Integer> markerLength)

Overrides:

CodeFence in class org.pegdown.Parser

HorizontalRule

public org.parboiled.Rule HorizontalRule()

Overrides:

HorizontalRule in class org.pegdown.Parser

HorizontalRule

public org.parboiled.Rule HorizontalRule(char c)

Overrides:

HorizontalRule in class org.pegdown.Parser

Heading

public org.parboiled.Rule Heading()

Overrides:

Heading in class org.pegdown.Parser

AtxHeading

public org.parboiled.Rule AtxHeading()

Overrides:

AtxHeading in class org.pegdown.Parser

AtxStart

public org.parboiled.Rule AtxStart()

Overrides:

AtxStart in class org.pegdown.Parser

AtxInline

public org.parboiled.Rule AtxInline()

Overrides:

AtxInline in class org.pegdown.Parser

SetextHeading

public org.parboiled.Rule SetextHeading()

Overrides:

SetextHeading in class org.pegdown.Parser

SetextHeading1

public org.parboiled.Rule SetextHeading1()

Overrides:

SetextHeading1 in class org.pegdown.Parser

SetextHeading2

public org.parboiled.Rule SetextHeading2()

Overrides:

SetextHeading2 in class org.pegdown.Parser

SetextInline

public org.parboiled.Rule SetextInline()

Overrides:

SetextInline in class org.pegdown.Parser

wrapInAnchor

public boolean wrapInAnchor()

Overrides:

wrapInAnchor in class org.pegdown.Parser

collectChildrensText

public void collectChildrensText(org.pegdown.ast.SuperNode node,
                                 synapticloop.documentr.generator.plugin.ExtendedParser.AnchorNodeInfo nodeInfo)

DefinitionList

public org.parboiled.Rule DefinitionList()

Overrides:

DefinitionList in class org.pegdown.Parser

DefListTerm

public org.parboiled.Rule DefListTerm()

Overrides:

DefListTerm in class org.pegdown.Parser

DefTermInline

public org.parboiled.Rule DefTermInline()

Overrides:

DefTermInline in class org.pegdown.Parser

Definition

public org.parboiled.Rule Definition()

Overrides:

Definition in class org.pegdown.Parser

DefListBullet

public org.parboiled.Rule DefListBullet()

Overrides:

DefListBullet in class org.pegdown.Parser

BulletList

public org.parboiled.Rule BulletList()

Overrides:

BulletList in class org.pegdown.Parser

OrderedList

public org.parboiled.Rule OrderedList()

Overrides:

OrderedList in class org.pegdown.Parser

ListItem

public org.parboiled.Rule ListItem(org.parboiled.Rule itemStart,
                                   ExtendedParser.SuperNodeCreator itemNodeCreator)

TaskListItem

public org.parboiled.Rule TaskListItem(org.parboiled.Rule itemStart,
                                       ExtendedParser.SuperNodeTaskItemCreator itemNodeCreator)

CrossedOut

public org.parboiled.Rule CrossedOut(org.parboiled.Rule rule,
                                     org.parboiled.support.StringBuilderVar block)

Overrides:

CrossedOut in class org.pegdown.Parser

CrossedOutLessOne

public org.parboiled.Rule CrossedOutLessOne(org.parboiled.Rule rule,
                                            org.parboiled.support.StringBuilderVar block)

Overrides:

CrossedOutLessOne in class org.pegdown.Parser

ListItemIndentedBlocks

public org.parboiled.Rule ListItemIndentedBlocks(org.parboiled.support.StringBuilderVar block)

Overrides:

ListItemIndentedBlocks in class org.pegdown.Parser

TestNotItem

public org.parboiled.Rule TestNotItem()

Overrides:

TestNotItem in class org.pegdown.Parser

TestNotListItem

public org.parboiled.Rule TestNotListItem()

Overrides:

TestNotListItem in class org.pegdown.Parser

Enumerator

public org.parboiled.Rule Enumerator()

Overrides:

Enumerator in class org.pegdown.Parser

Bullet

public org.parboiled.Rule Bullet()

Overrides:

Bullet in class org.pegdown.Parser

HtmlBlock

public org.parboiled.Rule HtmlBlock()

Overrides:

HtmlBlock in class org.pegdown.Parser

HtmlBlockInTags

public org.parboiled.Rule HtmlBlockInTags()

Overrides:

HtmlBlockInTags in class org.pegdown.Parser

HtmlTagBlock

public org.parboiled.Rule HtmlTagBlock(org.parboiled.support.StringVar tagName)

Overrides:

HtmlTagBlock in class org.pegdown.Parser

HtmlBlockSelfClosing

public org.parboiled.Rule HtmlBlockSelfClosing()

Overrides:

HtmlBlockSelfClosing in class org.pegdown.Parser

HtmlBlockOpen

public org.parboiled.Rule HtmlBlockOpen(org.parboiled.support.StringVar tagName)

Overrides:

HtmlBlockOpen in class org.pegdown.Parser

HtmlBlockClose

public org.parboiled.Rule HtmlBlockClose(org.parboiled.support.StringVar tagName)

Overrides:

HtmlBlockClose in class org.pegdown.Parser

DefinedHtmlTagName

public org.parboiled.Rule DefinedHtmlTagName(org.parboiled.support.StringVar tagName)

Overrides:

DefinedHtmlTagName in class org.pegdown.Parser

isHtmlTag

public boolean isHtmlTag(String string)

Overrides:

isHtmlTag in class org.pegdown.Parser

Inlines

public org.parboiled.Rule Inlines()

Overrides:

Inlines in class org.pegdown.Parser

InlineOrIntermediateEndline

public org.parboiled.Rule InlineOrIntermediateEndline()

Overrides:

InlineOrIntermediateEndline in class org.pegdown.Parser

Inline

public org.parboiled.Rule Inline()

Overrides:

Inline in class org.pegdown.Parser

NonAutoLinkInline

public org.parboiled.Rule NonAutoLinkInline()

Overrides:

NonAutoLinkInline in class org.pegdown.Parser

NonLinkInline

public org.parboiled.Rule NonLinkInline()

Overrides:

NonLinkInline in class org.pegdown.Parser

Endline

public org.parboiled.Rule Endline()

Overrides:

Endline in class org.pegdown.Parser

LineBreak

public org.parboiled.Rule LineBreak()

Overrides:

LineBreak in class org.pegdown.Parser

TerminalEndline

public org.parboiled.Rule TerminalEndline()

Overrides:

TerminalEndline in class org.pegdown.Parser

NormalEndline

public org.parboiled.Rule NormalEndline()

Overrides:

NormalEndline in class org.pegdown.Parser

UlOrStarLine

public org.parboiled.Rule UlOrStarLine()

Overrides:

UlOrStarLine in class org.pegdown.Parser

CharLine

public org.parboiled.Rule CharLine(char c)

Overrides:

CharLine in class org.pegdown.Parser

StrongOrEmph

public org.parboiled.Rule StrongOrEmph()

Overrides:

StrongOrEmph in class org.pegdown.Parser

Emph

public org.parboiled.Rule Emph()

Overrides:

Emph in class org.pegdown.Parser

Strong

public org.parboiled.Rule Strong()

Overrides:

Strong in class org.pegdown.Parser

Strike

public org.parboiled.Rule Strike()

Overrides:

Strike in class org.pegdown.Parser

EmphOrStrong

public org.parboiled.Rule EmphOrStrong(String chars)

Overrides:

EmphOrStrong in class org.pegdown.Parser

EmphOrStrongOpen

public org.parboiled.Rule EmphOrStrongOpen(String chars)

Overrides:

EmphOrStrongOpen in class org.pegdown.Parser

EmphOrStrongClose

public org.parboiled.Rule EmphOrStrongClose(String chars)

Overrides:

EmphOrStrongClose in class org.pegdown.Parser

mayEnterEmphOrStrong

protected boolean mayEnterEmphOrStrong(String chars)

This method checks if the parser can enter an emph or strong sequence Emph only allows Strong as direct child, Strong only allows Emph as direct child.

Overrides:

mayEnterEmphOrStrong in class org.pegdown.Parser

isLegalEmphOrStrongStartPos

protected boolean isLegalEmphOrStrongStartPos()

This method checks if current position is a legal start position for a strong or emph sequence by checking the last parsed character(-sequence).

Overrides:

isLegalEmphOrStrongStartPos in class org.pegdown.Parser

setClosed

protected boolean setClosed()

Mark the current StrongEmphSuperNode as closed sequence

Overrides:

setClosed in class org.pegdown.Parser

isStrongCloseCharStolen

protected boolean isStrongCloseCharStolen(String chars)

This method checks if current parent is a strong parent based on param `chars`. If so, it checks if the latest inline node to be added as child does not end with a closing character of the parent. When this is true, a next test should check if the closing character(s) of the child should become (part of) the closing character(s) of the parent.

Overrides:

isStrongCloseCharStolen in class org.pegdown.Parser

stealBackStrongCloseChar

protected boolean stealBackStrongCloseChar()

Steals the last close char by marking a previously closed emph/strong node as unclosed.

Overrides:

stealBackStrongCloseChar in class org.pegdown.Parser

isLegalEmphOrStrongClosePos

protected boolean isLegalEmphOrStrongClosePos()

This method checks if the last parsed character or sequence is a valid prefix for a closing char for an emph or strong sequence.

Overrides:

isLegalEmphOrStrongClosePos in class org.pegdown.Parser

Image

public org.parboiled.Rule Image()

Overrides:

Image in class org.pegdown.Parser

Link

public org.parboiled.Rule Link()

Overrides:

Link in class org.pegdown.Parser

NonAutoLink

public org.parboiled.Rule NonAutoLink()

Overrides:

NonAutoLink in class org.pegdown.Parser

ExplicitLink

public org.parboiled.Rule ExplicitLink(boolean image)

Overrides:

ExplicitLink in class org.pegdown.Parser

ReferenceLink

public org.parboiled.Rule ReferenceLink(boolean image)

Overrides:

ReferenceLink in class org.pegdown.Parser

LinkSource

public org.parboiled.Rule LinkSource()

Overrides:

LinkSource in class org.pegdown.Parser

LinkTitle

public org.parboiled.Rule LinkTitle()

Overrides:

LinkTitle in class org.pegdown.Parser

LinkTitle

public org.parboiled.Rule LinkTitle(char delimiter)

Overrides:

LinkTitle in class org.pegdown.Parser

AutoLink

public org.parboiled.Rule AutoLink()

Overrides:

AutoLink in class org.pegdown.Parser

WikiLink

public org.parboiled.Rule WikiLink()

Overrides:

WikiLink in class org.pegdown.Parser

AutoLinkUrl

public org.parboiled.Rule AutoLinkUrl()

Overrides:

AutoLinkUrl in class org.pegdown.Parser

AutoLinkEmail

public org.parboiled.Rule AutoLinkEmail()

Overrides:

AutoLinkEmail in class org.pegdown.Parser

AutoLinkEnd

public org.parboiled.Rule AutoLinkEnd()

Overrides:

AutoLinkEnd in class org.pegdown.Parser

ImageAlt

public org.parboiled.Rule ImageAlt()

Overrides:

ImageAlt in class org.pegdown.Parser

Label

public org.parboiled.Rule Label()

Overrides:

Label in class org.pegdown.Parser

Reference

public org.parboiled.Rule Reference()

Overrides:

Reference in class org.pegdown.Parser

ReferenceNoEOL

public org.parboiled.Rule ReferenceNoEOL()

Overrides:

ReferenceNoEOL in class org.pegdown.Parser

RefSrc

public org.parboiled.Rule RefSrc(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)

Overrides:

RefSrc in class org.pegdown.Parser

RefSrcContent

public org.parboiled.Rule RefSrcContent(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)

Overrides:

RefSrcContent in class org.pegdown.Parser

RefTitle

public org.parboiled.Rule RefTitle(org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)

Overrides:

RefTitle in class org.pegdown.Parser

RefTitle

public org.parboiled.Rule RefTitle(char open,
                                   char close,
                                   org.parboiled.support.Var<org.pegdown.ast.ReferenceNode> ref)

Overrides:

RefTitle in class org.pegdown.Parser

Code

public org.parboiled.Rule Code()

Overrides:

Code in class org.pegdown.Parser

Code

public org.parboiled.Rule Code(org.parboiled.Rule ticks)

Overrides:

Code in class org.pegdown.Parser

Ticks

public org.parboiled.Rule Ticks(int count)

Overrides:

Ticks in class org.pegdown.Parser

InlineHtml

public org.parboiled.Rule InlineHtml()

Overrides:

InlineHtml in class org.pegdown.Parser

HtmlComment

public org.parboiled.Rule HtmlComment()

Overrides:

HtmlComment in class org.pegdown.Parser

HtmlTag

public org.parboiled.Rule HtmlTag()

Overrides:

HtmlTag in class org.pegdown.Parser

HtmlAttribute

public org.parboiled.Rule HtmlAttribute()

Overrides:

HtmlAttribute in class org.pegdown.Parser

Quoted

public org.parboiled.Rule Quoted()

Overrides:

Quoted in class org.pegdown.Parser

BlankLine

public org.parboiled.Rule BlankLine()

Overrides:

BlankLine in class org.pegdown.Parser

Line

public org.parboiled.Rule Line(org.parboiled.support.StringBuilderVar sb)

Overrides:

Line in class org.pegdown.Parser

Entity

public org.parboiled.Rule Entity()

Overrides:

Entity in class org.pegdown.Parser

HexEntity

public org.parboiled.Rule HexEntity()

Overrides:

HexEntity in class org.pegdown.Parser

DecEntity

public org.parboiled.Rule DecEntity()

Overrides:

DecEntity in class org.pegdown.Parser

CharEntity

public org.parboiled.Rule CharEntity()

Overrides:

CharEntity in class org.pegdown.Parser

Str

public org.parboiled.Rule Str()

Overrides:

Str in class org.pegdown.Parser

Space

public org.parboiled.Rule Space()

Overrides:

Space in class org.pegdown.Parser

Spn1

public org.parboiled.Rule Spn1()

Overrides:

Spn1 in class org.pegdown.Parser

Sp

public org.parboiled.Rule Sp()

Overrides:

Sp in class org.pegdown.Parser

Spacechar

public org.parboiled.Rule Spacechar()

Overrides:

Spacechar in class org.pegdown.Parser

Nonspacechar

public org.parboiled.Rule Nonspacechar()

Overrides:

Nonspacechar in class org.pegdown.Parser

NormalChar

public org.parboiled.Rule NormalChar()

Overrides:

NormalChar in class org.pegdown.Parser

EscapedChar

public org.parboiled.Rule EscapedChar()

Overrides:

EscapedChar in class org.pegdown.Parser

Symbol

public org.parboiled.Rule Symbol()

Overrides:

Symbol in class org.pegdown.Parser

SpecialChar

public org.parboiled.Rule SpecialChar()

Overrides:

SpecialChar in class org.pegdown.Parser

EscapableChar

public org.parboiled.Rule EscapableChar()

Overrides:

EscapableChar in class org.pegdown.Parser

NotNewline

public org.parboiled.Rule NotNewline()

Overrides:

NotNewline in class org.pegdown.Parser

Newline

public org.parboiled.Rule Newline()

Overrides:

Newline in class org.pegdown.Parser

NonindentSpace

public org.parboiled.Rule NonindentSpace()

Overrides:

NonindentSpace in class org.pegdown.Parser

Indent

public org.parboiled.Rule Indent()

Overrides:

Indent in class org.pegdown.Parser

Alphanumeric

public org.parboiled.Rule Alphanumeric()

Overrides:

Alphanumeric in class org.pegdown.Parser

Letter

public org.parboiled.Rule Letter()

Overrides:

Letter in class org.pegdown.Parser

Digit

public org.parboiled.Rule Digit()

Overrides:

Digit in class org.pegdown.Parser

Abbreviation

public org.parboiled.Rule Abbreviation()

Overrides:

Abbreviation in class org.pegdown.Parser

AbbreviationText

public org.parboiled.Rule AbbreviationText(org.parboiled.support.Var<org.pegdown.ast.AbbreviationNode> node)

Overrides:

AbbreviationText in class org.pegdown.Parser

Table

public org.parboiled.Rule Table()

Overrides:

Table in class org.pegdown.Parser

TableCaption

public org.parboiled.Rule TableCaption()

Overrides:

TableCaption in class org.pegdown.Parser

CaptionStart

public org.parboiled.Rule CaptionStart()

Overrides:

CaptionStart in class org.pegdown.Parser

CaptionInline

public org.parboiled.Rule CaptionInline()

Overrides:

CaptionInline in class org.pegdown.Parser

TableDivider

public org.parboiled.Rule TableDivider(org.parboiled.support.Var<org.pegdown.ast.TableNode> tableNode)

Overrides:

TableDivider in class org.pegdown.Parser

TableColumn

public org.parboiled.Rule TableColumn(org.parboiled.support.Var<org.pegdown.ast.TableNode> tableNode,
                                      org.parboiled.support.Var<Boolean> pipeSeen)

Overrides:

TableColumn in class org.pegdown.Parser

TableRow

public org.parboiled.Rule TableRow()

Overrides:

TableRow in class org.pegdown.Parser

TableCell

public org.parboiled.Rule TableCell()

Overrides:

TableCell in class org.pegdown.Parser

Smarts

public org.parboiled.Rule Smarts()

Overrides:

Smarts in class org.pegdown.Parser

SingleQuoted

public org.parboiled.Rule SingleQuoted()

Overrides:

SingleQuoted in class org.pegdown.Parser

SingleQuoteEnd

public org.parboiled.Rule SingleQuoteEnd()

Overrides:

SingleQuoteEnd in class org.pegdown.Parser

DoubleQuoted

public org.parboiled.Rule DoubleQuoted()

Overrides:

DoubleQuoted in class org.pegdown.Parser

DoubleAngleQuoted

public org.parboiled.Rule DoubleAngleQuoted()

Overrides:

DoubleAngleQuoted in class org.pegdown.Parser

NOrMore

public org.parboiled.Rule NOrMore(char c,
                                  int n)

Overrides:

NOrMore in class org.pegdown.Parser

NodeSequence

public org.parboiled.Rule NodeSequence(Object... nodeRules)

Overrides:

NodeSequence in class org.pegdown.Parser

setIndices

public boolean setIndices()

Overrides:

setIndices in class org.pegdown.Parser

addAsChild

public boolean addAsChild()

Overrides:

addAsChild in class org.pegdown.Parser

popAsNode

public org.pegdown.ast.Node popAsNode()

Overrides:

popAsNode in class org.pegdown.Parser

popAsString

public String popAsString()

Overrides:

popAsString in class org.pegdown.Parser

ext

public boolean ext(int extension)

Overrides:

ext in class org.pegdown.Parser

parseInternal

public org.pegdown.ast.RootNode parseInternal(org.parboiled.support.StringBuilderVar block)

Overrides:

parseInternal in class org.pegdown.Parser

fixIndices

protected void fixIndices(org.pegdown.ast.Node node,
                          int[] ixMap)

Overrides:

fixIndices in class org.pegdown.Parser

parseInternal

public org.pegdown.ast.RootNode parseInternal(char[] source)

Overrides:

parseInternal in class org.pegdown.Parser

checkForParsingTimeout

protected boolean checkForParsingTimeout()

Overrides:

checkForParsingTimeout in class org.pegdown.Parser