Class InlineParserImpl

java.lang.Object
com.vladsch.flexmark.parser.LightInlineParserImpl
com.vladsch.flexmark.parser.internal.InlineParserImpl
All Implemented Interfaces:
ParagraphPreProcessor, InlineParser, LightInlineParser
Direct Known Subclasses:
CommonmarkInlineParser
public class InlineParserImpl extends LightInlineParserImpl implements InlineParser, ParagraphPreProcessor

  • Field Details

    • 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

    • linkDestinationParser

      protected LinkDestinationParser linkDestinationParser

    • specialCharacters

      protected BitSet specialCharacters

    • customCharacters

      protected BitSet customCharacters

    • customSpecialCharacterFactoryMap

      protected Map<Character, CharacterNodeFactory> customSpecialCharacterFactoryMap

    • customSpecialCharacterNodes

      protected ArrayList<Node> customSpecialCharacterNodes

    • referenceRepository

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

    • 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.)

    • lastBracket

      private Bracket lastBracket
      Top opening bracket ([ or ![)).

  • Constructor Details

  • Method Details

    • initializeDocument

      public void initializeDocument(@NotNull @NotNull Document document)
      Specified by:
      initializeDocument in interface InlineParser

    • finalizeDocument

      public void finalizeDocument(@NotNull @NotNull Document document)
      Specified by:
      finalizeDocument in interface InlineParser

    • getLastDelimiter

      public Delimiter getLastDelimiter()
      Specified by:
      getLastDelimiter in interface InlineParser

    • getLastBracket

      public Bracket getLastBracket()
      Specified by:
      getLastBracket in interface InlineParser

    • parseCustom

      @Nullable public @Nullable List<Node> parseCustom(@NotNull @NotNull BasedSequence input, @NotNull @NotNull Node node, @NotNull @NotNull BitSet customCharacters, @NotNull @NotNull Map<Character, CharacterNodeFactory> nodeFactoryMap)
      Specified by:
      parseCustom in interface InlineParser

    • parse

      public void parse(@NotNull @NotNull BasedSequence content, @NotNull @NotNull 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(@Nullable @Nullable Node fromNode, @Nullable @Nullable 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

    • parseReference

      protected int parseReference(Block block, 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

    • 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

    • parseInline

      protected boolean parseInline(boolean customOnly)

    • processCustomCharacters

      private boolean processCustomCharacters()

    • 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

    • addBracket

      private void addBracket(Bracket bracket)

    • removeLastBracket

      private void removeLastBracket()

    • matchLinkRef

      private InlineParserImpl.ReferenceProcessorMatch matchLinkRef(Bracket opener, int startIndex, int lookAhead, int nesting)

    • 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(Node node, Boolean isTentative)

    • containsLinkRefs

      protected static boolean containsLinkRefs(BasedSequence nodeChars, Node next, Boolean isTentative)

    • collapseLinkRefChildren

      protected static void collapseLinkRefChildren(Node node, Function<LinkRefDerived, Boolean> isTentative, boolean trimFirstLastChild)

    • parseLinkDestination

      public BasedSequence parseLinkDestination()
      Attempt to parse link destination,
      Specified by:
      parseLinkDestination in interface InlineParser
      Returns:
      the string or null if no match.

    • parseLinkTitle

      public 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 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(@NotNull @NotNull Delimiter opener, @NotNull @NotNull Delimiter closer)
      Specified by:
      removeDelimitersBetween in interface InlineParser

    • removeDelimiterAndNode

      public void removeDelimiterAndNode(@NotNull @NotNull 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(@NotNull @NotNull 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(@NotNull @NotNull Delimiter delim)
      Specified by:
      removeDelimiter in interface InlineParser

    • calculateInlineParserExtensions

      static Map<Character, List<InlineParserExtensionFactory>> calculateInlineParserExtensions(DataHolder options, List<InlineParserExtensionFactory> extensionFactories)

    • calculateDelimiterCharacters

      public static BitSet calculateDelimiterCharacters(DataHolder options, Set<Character> characters)

    • calculateSpecialCharacters

      public static BitSet calculateSpecialCharacters(DataHolder options, BitSet delimiterCharacters)

    • calculateDelimiterProcessors

      public static Map<Character, DelimiterProcessor> calculateDelimiterProcessors(DataHolder options, List<DelimiterProcessor> delimiterProcessors)

    • calculateLinkRefProcessors

      public static LinkRefProcessorData calculateLinkRefProcessors(DataHolder options, List<LinkRefProcessorFactory> linkRefProcessors)

    • addDelimiterProcessors

      private static void addDelimiterProcessors(List<? extends DelimiterProcessor> delimiterProcessors, Map<Character, DelimiterProcessor> map)

    • addDelimiterProcessorForChar

      private static void addDelimiterProcessorForChar(char delimiterChar, DelimiterProcessor toAdd, Map<Character, DelimiterProcessor> delimiterProcessors)