com.vladsch.flexmark.internal

Class InlineParserImpl

java.lang.Object

com.vladsch.flexmark.internal.InlineParserImpl

All Implemented Interfaces:

ParagraphPreProcessor, InlineParser

Direct Known Subclasses:

CommonmarkInlineParser

public class InlineParserImpl
extends Object
implements InlineParser, ParagraphPreProcessor

Field Summary

Fields

Modifier and Type	Field and Description
protected com.vladsch.flexmark.ast.Node	block
protected ArrayList<com.vladsch.flexmark.util.sequence.BasedSequence>	currentText
protected BitSet	customCharacters
protected Map<Character,CharacterNodeFactory>	customSpecialCharacterFactoryMap
protected ArrayList<com.vladsch.flexmark.ast.Node>	customSpecialCharacterNodes
protected BitSet	delimiterCharacters
protected Map<Character,DelimiterProcessor>	delimiterProcessors
protected com.vladsch.flexmark.ast.Document	document
protected int	index
protected List<InlineParserExtensionFactory>	inlineParserExtensionFactories
protected Map<Character,List<InlineParserExtension>>	inlineParserExtensions
protected com.vladsch.flexmark.util.sequence.BasedSequence	input
protected Delimiter	lastDelimiter Top delimiter (emphasis, strong emphasis or custom emphasis).
protected List<LinkRefProcessor>	linkRefProcessors
protected LinkRefProcessorData	linkRefProcessorsData
protected Parsing	myParsing
protected InlineParserOptions	options
protected BitSet	originalSpecialCharacters
protected ReferenceRepository	referenceRepository Link references by ID, needs to be built up using parseReference before calling parse.
protected BitSet	specialCharacters

Constructor Summary

Constructors

Constructor and Description
InlineParserImpl(com.vladsch.flexmark.util.options.DataHolder options, BitSet specialCharacters, BitSet delimiterCharacters, Map<Character,DelimiterProcessor> delimiterProcessors, LinkRefProcessorData linkRefProcessorsData, List<InlineParserExtensionFactory> inlineParserExtensionFactories)

Method Summary

Modifier and Type	Method and Description
void	appendNode(com.vladsch.flexmark.ast.Node node)
Text	appendSeparateText(com.vladsch.flexmark.util.sequence.BasedSequence text)
void	appendText(com.vladsch.flexmark.util.sequence.BasedSequence text)
void	appendText(com.vladsch.flexmark.util.sequence.BasedSequence text, int beginIndex, int endIndex)
static BitSet	calculateDelimiterCharacters(com.vladsch.flexmark.util.options.DataHolder options, Set<Character> characters)
static Map<Character,DelimiterProcessor>	calculateDelimiterProcessors(com.vladsch.flexmark.util.options.DataHolder options, List<DelimiterProcessor> delimiterProcessors)
static Map<Character,List<InlineParserExtensionFactory>>	calculateInlineParserExtensions(com.vladsch.flexmark.util.options.DataHolder options, List<InlineParserExtensionFactory> extensionFactories)
static LinkRefProcessorData	calculateLinkRefProcessors(com.vladsch.flexmark.util.options.DataHolder options, List<LinkRefProcessorFactory> linkRefProcessors)
static BitSet	calculateSpecialCharacters(com.vladsch.flexmark.util.options.DataHolder options, BitSet delimiterCharacters)
protected Object	clone()
protected static void	collapseLinkRefChildren(com.vladsch.flexmark.ast.Node node, Boolean isTentative)
protected static boolean	containsLinkRefs(com.vladsch.flexmark.util.sequence.BasedSequence nodeChars, com.vladsch.flexmark.ast.Node next, Boolean isDefined)
void	finalizeDocument(com.vladsch.flexmark.ast.Document document)
boolean	flushTextNode()
com.vladsch.flexmark.ast.Node	getBlock()
ArrayList<com.vladsch.flexmark.util.sequence.BasedSequence>	getCurrentText()
com.vladsch.flexmark.ast.Document	getDocument()
int	getIndex()
com.vladsch.flexmark.util.sequence.BasedSequence	getInput()
Bracket	getLastBracket()
Delimiter	getLastDelimiter()
InlineParserOptions	getOptions()
Parsing	getParsing()
void	initializeDocument(Parsing parsing, com.vladsch.flexmark.ast.Document document)
com.vladsch.flexmark.util.sequence.BasedSequence	match(Pattern re) If RE matches at current index in the input, advance index and return the match; otherwise return null.
Matcher	matcher(Pattern re) If RE matches at current index in the input, advance index and return the match; otherwise return null.
com.vladsch.flexmark.util.sequence.BasedSequence[]	matchWithGroups(Pattern re) If RE matches at current index in the input, advance index and return the match; otherwise return null.
void	mergeIfNeeded(Text first, Text last)
void	mergeTextNodes(com.vladsch.flexmark.ast.Node fromNode, com.vladsch.flexmark.ast.Node toNode)
void	moveNodes(com.vladsch.flexmark.ast.Node fromNode, com.vladsch.flexmark.ast.Node toNode)
boolean	nonIndentSp() Parse zero or more non-indent spaces
void	parse(com.vladsch.flexmark.util.sequence.BasedSequence content, com.vladsch.flexmark.ast.Node block) Parse content in block into inline children, using reference map to resolve references.
boolean	parseAutolink() Attempt to parse an autolink (URL or email in pointy brackets).
protected boolean	parseBackslash() Parse a backslash-escaped special character, adding either the escaped character, a hard line break (if the backslash is followed by a newline), or a literal backslash to the block's children.
protected boolean	parseBackticks() Attempt to parse backticks, adding either a backtick code span or a literal sequence of backticks.
protected boolean	parseBang() If next character is [, and ! delimiter to delimiter stack and add a text node to block's children.
protected boolean	parseCloseBracket() Try to match close bracket against an opening in the delimiter stack.
List<com.vladsch.flexmark.ast.Node>	parseCustom(com.vladsch.flexmark.util.sequence.BasedSequence input, com.vladsch.flexmark.ast.Node node, BitSet customCharacters, Map<Character,CharacterNodeFactory> nodeFactoryMap)
protected boolean	parseDelimiters(DelimiterProcessor delimiterProcessor, char delimiterChar) Attempt to parse delimiters like emphasis, strong emphasis or custom delimiters.
boolean	parseEntity() Attempt to parse an entity, return Entity object if successful.
boolean	parseHtmlInline() Attempt to parse inline HTML.
protected boolean	parseInline() Parse the next inline element in subject, advancing input index.
com.vladsch.flexmark.util.sequence.BasedSequence	parseLinkDestination() Attempt to parse link destination,
int	parseLinkLabel() Attempt to parse a link label
com.vladsch.flexmark.util.sequence.BasedSequence	parseLinkTitle() Attempt to parse link title (sans quotes),
boolean	parseNewline() Parse a newline.
protected boolean	parseOpenBracket() Add open bracket to delimiter stack and add a text node to block's children.
protected int	parseReference(com.vladsch.flexmark.ast.Block block, com.vladsch.flexmark.util.sequence.BasedSequence s) Attempt to parse a reference definition, modifying the internal reference map.
protected boolean	parseString() Parse a run of ordinary characters, or a single character with a special meaning in markdown, as a plain string.
char	peek()
char	peek(int ahead)
int	preProcessBlock(Paragraph block, ParserState state) Process Paragraph Content on closing of the paragraph block to removeIndex non-text lines.
void	processDelimiters(Delimiter stackBottom)
void	removeDelimiter(Delimiter delim)
void	removeDelimiterAndNode(Delimiter delim) Remove the delimiter and the corresponding text node.
void	removeDelimiterKeepNode(Delimiter delim) Remove the delimiter but keep the corresponding node as text.
void	removeDelimitersBetween(Delimiter opener, Delimiter closer)
protected com.vladsch.flexmark.internal.InlineParserImpl.DelimiterData	scanDelimiters(DelimiterProcessor delimiterProcessor, char delimiterChar) Scan a sequence of characters with code delimiterChar, and return information about the number of delimiters and whether they are positioned such that they can open and/or close emphasis or strong emphasis.
void	setIndex(int index)
boolean	sp() Parse zero or more spaces
boolean	spnl() Parse zero or more space characters, including at most one newline and zero or more spaces.
boolean	spnlUrl() Parse zero or more space characters, including at one newline.
com.vladsch.flexmark.util.sequence.BasedSequence	toEOL() Parse to end of line, including EOL

Methods inherited from class java.lang.Object

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

Field Detail

originalSpecialCharacters

protected final BitSet originalSpecialCharacters

delimiterCharacters

protected final BitSet delimiterCharacters

delimiterProcessors

protected final Map<Character,DelimiterProcessor> delimiterProcessors

linkRefProcessorsData

protected final LinkRefProcessorData linkRefProcessorsData

linkRefProcessors

protected List<LinkRefProcessor> linkRefProcessors

inlineParserExtensions

protected Map<Character,List<InlineParserExtension>> inlineParserExtensions

inlineParserExtensionFactories

protected List<InlineParserExtensionFactory> inlineParserExtensionFactories

specialCharacters

protected BitSet specialCharacters

customCharacters

protected BitSet customCharacters

customSpecialCharacterFactoryMap

protected Map<Character,CharacterNodeFactory> customSpecialCharacterFactoryMap

customSpecialCharacterNodes

protected ArrayList<com.vladsch.flexmark.ast.Node> customSpecialCharacterNodes

referenceRepository

protected ReferenceRepository referenceRepository

Link references by ID, needs to be built up using parseReference before calling parse.

block

protected com.vladsch.flexmark.ast.Node block

input

protected com.vladsch.flexmark.util.sequence.BasedSequence input

index

protected int index

lastDelimiter

protected Delimiter lastDelimiter

Top delimiter (emphasis, strong emphasis or custom emphasis). (Brackets are on a separate stack, different from the algorithm described in the spec.)

currentText

protected ArrayList<com.vladsch.flexmark.util.sequence.BasedSequence> currentText

document

protected com.vladsch.flexmark.ast.Document document

options

protected final InlineParserOptions options

myParsing

protected Parsing myParsing

Constructor Detail

InlineParserImpl

public InlineParserImpl(com.vladsch.flexmark.util.options.DataHolder options,
                        BitSet specialCharacters,
                        BitSet delimiterCharacters,
                        Map<Character,DelimiterProcessor> delimiterProcessors,
                        LinkRefProcessorData linkRefProcessorsData,
                        List<InlineParserExtensionFactory> inlineParserExtensionFactories)

Method Detail

calculateInlineParserExtensions

public static Map<Character,List<InlineParserExtensionFactory>> calculateInlineParserExtensions(com.vladsch.flexmark.util.options.DataHolder options,
                                                                                                List<InlineParserExtensionFactory> extensionFactories)

initializeDocument

public void initializeDocument(Parsing parsing,
                               com.vladsch.flexmark.ast.Document document)

Specified by:

initializeDocument in interface InlineParser

finalizeDocument

public void finalizeDocument(com.vladsch.flexmark.ast.Document document)

Specified by:

finalizeDocument in interface InlineParser

getCurrentText

public ArrayList<com.vladsch.flexmark.util.sequence.BasedSequence> getCurrentText()

calculateDelimiterCharacters

public static BitSet calculateDelimiterCharacters(com.vladsch.flexmark.util.options.DataHolder options,
                                                  Set<Character> characters)

calculateSpecialCharacters

public static BitSet calculateSpecialCharacters(com.vladsch.flexmark.util.options.DataHolder options,
                                                BitSet delimiterCharacters)

calculateDelimiterProcessors

public static Map<Character,DelimiterProcessor> calculateDelimiterProcessors(com.vladsch.flexmark.util.options.DataHolder options,
                                                                             List<DelimiterProcessor> delimiterProcessors)

calculateLinkRefProcessors

public static LinkRefProcessorData calculateLinkRefProcessors(com.vladsch.flexmark.util.options.DataHolder options,
                                                              List<LinkRefProcessorFactory> linkRefProcessors)

getInput

public com.vladsch.flexmark.util.sequence.BasedSequence getInput()

Specified by:

getInput in interface InlineParser

getIndex

public int getIndex()

Specified by:

getIndex in interface InlineParser

setIndex

public void setIndex(int index)

Specified by:

setIndex in interface InlineParser

getLastDelimiter

public Delimiter getLastDelimiter()

Specified by:

getLastDelimiter in interface InlineParser

getLastBracket

public Bracket getLastBracket()

Specified by:

getLastBracket in interface InlineParser

getDocument

public com.vladsch.flexmark.ast.Document getDocument()

Specified by:

getDocument in interface InlineParser

getOptions

public InlineParserOptions getOptions()

Specified by:

getOptions in interface InlineParser

getParsing

public Parsing getParsing()

Specified by:

getParsing in interface InlineParser

getBlock

public com.vladsch.flexmark.ast.Node getBlock()

Specified by:

getBlock in interface InlineParser

parseCustom

public List<com.vladsch.flexmark.ast.Node> parseCustom(com.vladsch.flexmark.util.sequence.BasedSequence input,
                                                       com.vladsch.flexmark.ast.Node node,
                                                       BitSet customCharacters,
                                                       Map<Character,CharacterNodeFactory> nodeFactoryMap)

Specified by:

parseCustom in interface InlineParser

parse

public void parse(com.vladsch.flexmark.util.sequence.BasedSequence content,
                  com.vladsch.flexmark.ast.Node block)

Parse content in block into inline children, using reference map to resolve references.

Specified by:

parse in interface InlineParser

Parameters:

content - the content to parse as inline

block - the node to append resulting nodes to (as children)

mergeTextNodes

public void mergeTextNodes(com.vladsch.flexmark.ast.Node fromNode,
                           com.vladsch.flexmark.ast.Node toNode)

Specified by:

mergeTextNodes in interface InlineParser

mergeIfNeeded

public void mergeIfNeeded(Text first,
                          Text last)

Specified by:

mergeIfNeeded in interface InlineParser

preProcessBlock

public int preProcessBlock(Paragraph block,
                           ParserState state)

Description copied from interface: ParagraphPreProcessor

Process Paragraph Content on closing of the paragraph block to removeIndex non-text lines.

This is used by extensions to take leading lines from a paragraph and convert them to other blocks by Default leading lines that define references are removed and Reference nodes are inserted before.

Specified by:

preProcessBlock in interface ParagraphPreProcessor

Parameters:

block - paragraph node to process

state - parser state

Returns:

number of characters processed from the start of the block

moveNodes

public void moveNodes(com.vladsch.flexmark.ast.Node fromNode,
                      com.vladsch.flexmark.ast.Node toNode)

Specified by:

moveNodes in interface InlineParser

parseReference

protected int parseReference(com.vladsch.flexmark.ast.Block block,
                             com.vladsch.flexmark.util.sequence.BasedSequence s)

Attempt to parse a reference definition, modifying the internal reference map.

Parameters:

block - the block whose text is being parsed for references

s - sequence of the blocks characters

Returns:

number of characters were parsed as a reference from the start of the sequence, 0 if none

appendText

public void appendText(com.vladsch.flexmark.util.sequence.BasedSequence text)

appendText

public void appendText(com.vladsch.flexmark.util.sequence.BasedSequence text,
                       int beginIndex,
                       int endIndex)

Specified by:

appendText in interface InlineParser

appendNode

public void appendNode(com.vladsch.flexmark.ast.Node node)

Specified by:

appendNode in interface InlineParser

appendSeparateText

public Text appendSeparateText(com.vladsch.flexmark.util.sequence.BasedSequence text)

Specified by:

appendSeparateText in interface InlineParser

flushTextNode

public boolean flushTextNode()

Specified by:

flushTextNode in interface InlineParser

parseInline

protected boolean parseInline()

Parse the next inline element in subject, advancing input index. On success, add the result to block's children and return true. On failure, return false.

Returns:

false on failure true on success

match

public com.vladsch.flexmark.util.sequence.BasedSequence match(Pattern re)

If RE matches at current index in the input, advance index and return the match; otherwise return null.

Specified by:

match in interface InlineParser

Parameters:

re - pattern to match

Returns:

sequence matched or null

matchWithGroups

public com.vladsch.flexmark.util.sequence.BasedSequence[] matchWithGroups(Pattern re)

If RE matches at current index in the input, advance index and return the match; otherwise return null.

Specified by:

matchWithGroups in interface InlineParser

Parameters:

re - pattern to match

Returns:

sequence matched or null

matcher

public Matcher matcher(Pattern re)

If RE matches at current index in the input, advance index and return the match; otherwise return null.

Specified by:

matcher in interface InlineParser

Parameters:

re - pattern to match

Returns:

matched matcher or null

peek

public char peek()

Specified by:

peek in interface InlineParser

Returns:

the char at the current input index, or '\0' in case there are no more characters.

peek

public char peek(int ahead)

Specified by:

peek in interface InlineParser

spnl

public boolean spnl()

Parse zero or more space characters, including at most one newline and zero or more spaces.

Specified by:

spnl in interface InlineParser

Returns:

true

nonIndentSp

public boolean nonIndentSp()

Parse zero or more non-indent spaces

Specified by:

nonIndentSp in interface InlineParser

Returns:

true

sp

public boolean sp()

Parse zero or more spaces

Specified by:

sp in interface InlineParser

Returns:

true

spnlUrl

public boolean spnlUrl()

Parse zero or more space characters, including at one newline.

Specified by:

spnlUrl in interface InlineParser

Returns:

true

toEOL

public com.vladsch.flexmark.util.sequence.BasedSequence toEOL()

Parse to end of line, including EOL

Specified by:

toEOL in interface InlineParser

Returns:

characters parsed or null if no end of line

parseNewline

public boolean parseNewline()

Parse a newline. If it was preceded by two spaces, append a hard line break; otherwise a soft line break.

Specified by:

parseNewline in interface InlineParser

Returns:

true

parseBackslash

protected boolean parseBackslash()

Parse a backslash-escaped special character, adding either the escaped character, a hard line break (if the backslash is followed by a newline), or a literal backslash to the block's children.

Returns:

true

parseBackticks

protected boolean parseBackticks()

Attempt to parse backticks, adding either a backtick code span or a literal sequence of backticks.

Returns:

true if matched backticks, false otherwise

parseDelimiters

protected boolean parseDelimiters(DelimiterProcessor delimiterProcessor,
                                  char delimiterChar)

Attempt to parse delimiters like emphasis, strong emphasis or custom delimiters.

Parameters:

delimiterProcessor - delimiter processor instance

delimiterChar - delimiter character being processed

Returns:

true if processed characters false otherwise

parseOpenBracket

protected boolean parseOpenBracket()

Add open bracket to delimiter stack and add a text node to block's children.

Returns:

true

parseBang

protected boolean parseBang()

If next character is [, and ! delimiter to delimiter stack and add a text node to block's children. Otherwise just add a text node.

Returns:

true if processed characters false otherwise

parseCloseBracket

protected boolean parseCloseBracket()

Try to match close bracket against an opening in the delimiter stack. Add either a link or image, or a plain [ character, to block's children. If there is a matching delimiter, removeIndex it from the delimiter stack.

Also handles custom link ref processing

Returns:

true

containsLinkRefs

protected static boolean containsLinkRefs(com.vladsch.flexmark.util.sequence.BasedSequence nodeChars,
                                          com.vladsch.flexmark.ast.Node next,
                                          Boolean isDefined)

collapseLinkRefChildren

protected static void collapseLinkRefChildren(com.vladsch.flexmark.ast.Node node,
                                              Boolean isTentative)

parseLinkDestination

public com.vladsch.flexmark.util.sequence.BasedSequence parseLinkDestination()

Attempt to parse link destination,

Specified by:

parseLinkDestination in interface InlineParser

Returns:

the string or null if no match.

parseLinkTitle

public com.vladsch.flexmark.util.sequence.BasedSequence parseLinkTitle()

Attempt to parse link title (sans quotes),

Specified by:

parseLinkTitle in interface InlineParser

Returns:

the string or null if no match.

parseLinkLabel

public int parseLinkLabel()

Attempt to parse a link label

Specified by:

parseLinkLabel in interface InlineParser

Returns:

number of characters parsed.

parseAutolink

public boolean parseAutolink()

Attempt to parse an autolink (URL or email in pointy brackets).

Specified by:

parseAutolink in interface InlineParser

Returns:

true if processed characters false otherwise

parseHtmlInline

public boolean parseHtmlInline()

Attempt to parse inline HTML.

Specified by:

parseHtmlInline in interface InlineParser

Returns:

true if processed characters false otherwise

parseEntity

public boolean parseEntity()

Attempt to parse an entity, return Entity object if successful.

Specified by:

parseEntity in interface InlineParser

Returns:

true if processed characters false otherwise

parseString

protected boolean parseString()

Parse a run of ordinary characters, or a single character with a special meaning in markdown, as a plain string.

Returns:

true if processed characters false otherwise

clone

protected Object clone()
                throws CloneNotSupportedException

Overrides:

clone in class Object

Throws:

CloneNotSupportedException

scanDelimiters

protected com.vladsch.flexmark.internal.InlineParserImpl.DelimiterData scanDelimiters(DelimiterProcessor delimiterProcessor,
                                                                                      char delimiterChar)

Scan a sequence of characters with code delimiterChar, and return information about the number of delimiters and whether they are positioned such that they can open and/or close emphasis or strong emphasis.

Parameters:

delimiterProcessor - delimiter processor instance

delimiterChar - delimiter character being scanned

Returns:

information about delimiter run, or null

processDelimiters

public void processDelimiters(Delimiter stackBottom)

Specified by:

processDelimiters in interface InlineParser

removeDelimitersBetween

public void removeDelimitersBetween(Delimiter opener,
                                    Delimiter closer)

Specified by:

removeDelimitersBetween in interface InlineParser

removeDelimiterAndNode

public void removeDelimiterAndNode(Delimiter delim)

Remove the delimiter and the corresponding text node. For used delimiters, e.g. `*` in `*foo*`.

Specified by:

removeDelimiterAndNode in interface InlineParser

Parameters:

delim - delimiter to remove

removeDelimiterKeepNode

public void removeDelimiterKeepNode(Delimiter delim)

Remove the delimiter but keep the corresponding node as text. For unused delimiters such as `_` in `foo_bar`.

Specified by:

removeDelimiterKeepNode in interface InlineParser

Parameters:

delim - delimiter being processed

removeDelimiter

public void removeDelimiter(Delimiter delim)

Specified by:

removeDelimiter in interface InlineParser