Package com.vladsch.flexmark.parser.internal

Class InlineParserImpl

    • Field Detail

      • originalSpecialCharacters

        protected final java.util.BitSet originalSpecialCharacters

      • delimiterCharacters

        protected final java.util.BitSet delimiterCharacters

      • delimiterProcessors

        protected final java.util.Map<java.lang.Character,​DelimiterProcessor> delimiterProcessors

      • linkRefProcessors

        protected java.util.List<LinkRefProcessor> linkRefProcessors

      • inlineParserExtensions

        protected java.util.Map<java.lang.Character,​java.util.List<InlineParserExtension>> inlineParserExtensions

      • specialCharacters

        protected java.util.BitSet specialCharacters

      • customCharacters

        protected java.util.BitSet customCharacters

      • customSpecialCharacterFactoryMap

        protected java.util.Map<java.lang.Character,​CharacterNodeFactory> customSpecialCharacterFactoryMap

      • customSpecialCharacterNodes

        protected java.util.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 ![)).

    • Method Detail

      • parseCustom

        @Nullable
public @Nullable java.util.List<Node> parseCustom​(@NotNull
                                                  @NotNull BasedSequence input,
                                                  @NotNull
                                                  @NotNull Node node,
                                                  @NotNull
                                                  @NotNull java.util.BitSet customCharacters,
                                                  @NotNull
                                                  @NotNull java.util.Map<java.lang.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

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

      • 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,
                                          java.lang.Boolean isTentative)

      • containsLinkRefs

        protected static boolean containsLinkRefs​(BasedSequence nodeChars,
                                          Node next,
                                          java.lang.Boolean isTentative)

      • collapseLinkRefChildren

        protected static void collapseLinkRefChildren​(Node node,
                                              java.util.function.Function<LinkRefDerived,​java.lang.Boolean> isTentative,
                                              boolean trimFirstLastChild)

      • 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 java.lang.Object clone()
                          throws java.lang.CloneNotSupportedException
        Overrides:
        clone in class java.lang.Object
        Throws:
        java.lang.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

      • 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

      • calculateDelimiterCharacters

        public static java.util.BitSet calculateDelimiterCharacters​(DataHolder options,
                                                            java.util.Set<java.lang.Character> characters)

      • calculateSpecialCharacters

        public static java.util.BitSet calculateSpecialCharacters​(DataHolder options,
                                                          java.util.BitSet delimiterCharacters)

      • addDelimiterProcessors

        private static void addDelimiterProcessors​(java.util.List<? extends DelimiterProcessor> delimiterProcessors,
                                           java.util.Map<java.lang.Character,​DelimiterProcessor> map)

      • addDelimiterProcessorForChar

        private static void addDelimiterProcessorForChar​(char delimiterChar,
                                                 DelimiterProcessor toAdd,
                                                 java.util.Map<java.lang.Character,​DelimiterProcessor> delimiterProcessors)