"Fossies" - the Fresh Open Source Software Archive

Member "Tahchee-1.0.0/Sources/tahchee/plugins/_kiwi/inlines.py" (22 Oct 2009, 21437 Bytes) of package /linux/privat/old/tahchee-1.0.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Python source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. For more information about "inlines.py" see the Fossies "Dox" file reference documentation.

    1 #!/usr/bin/env python
    2 # Encoding: iso-8859-1
    3 # vim: ts=4 sw=4 tw=80 noet
    4 # -----------------------------------------------------------------------------
    5 # Project           :   Kiwi
    6 # -----------------------------------------------------------------------------
    7 # Author            :   Sebastien Pierre (SPE)           <sebastien@type-z.org>
    8 # -----------------------------------------------------------------------------
    9 # Creation date     :   19-Nov-2003
   10 # Last mod.         :   05-Aug-2008
   11 # -----------------------------------------------------------------------------
   12 
   13 import re
   14 
   15 __pychecker__ = "unusednames=y"
   16 
   17 #------------------------------------------------------------------------------
   18 #
   19 #  Error messages
   20 #
   21 #------------------------------------------------------------------------------
   22 
   23 END_WITHOUT_START = "Markup `%s' end found without previous markup start"
   24 START_WITHOUT_END = "Markup `%s' start found without following markup end"
   25 MUST_BE_START_OR_END = \
   26 "Unrecognised markup specifier: 'start' or 'end' would be expected"
   27 
   28 #------------------------------------------------------------------------------
   29 #
   30 #  Regular expressions
   31 #
   32 #------------------------------------------------------------------------------
   33 
   34 #The regular expressions listed below are ordered conforming to their order
   35 #of insertion into the parser.
   36 
   37 # Kiwi core
   38 
   39 COMMENT          = u"^\s*#.*$"
   40 RE_COMMENT       = re.compile(COMMENT, re.LOCALE | re.MULTILINE )
   41 
   42 ESCAPED_START    = u"<\["
   43 RE_ESCAPED_START = re.compile(ESCAPED_START, re.LOCALE)
   44 ESCAPED_END      = u"\]>"
   45 RE_ESCAPED_END   = re.compile(ESCAPED_END, re.LOCALE)
   46 ESCAPED_REPLACE  = u'\\"'
   47 RE_ESCAPED_REPLACE=re.compile(ESCAPED_REPLACE, re.LOCALE)
   48 
   49 ESCAPED_STRING   = u'\\\\"([^"]+)"'
   50 RE_ESCAPED_STRING = re.compile(ESCAPED_STRING, re.MULTILINE|re.LOCALE)
   51 
   52 # Text style
   53 
   54 CODE             = u"`([^\`]+)`"
   55 RE_CODE          = re.compile(CODE, re.LOCALE|re.MULTILINE)
   56 CODE_2           = u"``((`?[^`])+)``"
   57 RE_CODE_2        = re.compile(CODE_2, re.LOCALE|re.MULTILINE)
   58 CODE_3           = u"'([^']+)'"
   59 RE_CODE_3        = re.compile(CODE_3, re.LOCALE|re.MULTILINE)
   60 PRE              = u"^((\s*\>(\t|   ))(.*)\n?)+"
   61 RE_PRE           = re.compile(PRE, re.LOCALE|re.MULTILINE)
   62 EMPHASIS         = u"\*([^*]+)\*"
   63 RE_EMPHASIS      = re.compile(EMPHASIS, re.LOCALE|re.MULTILINE)
   64 STRONG           = u"\*\*([^*]+)\*\*"
   65 RE_STRONG        = re.compile(STRONG, re.LOCALE|re.MULTILINE)
   66 TERM             = u"\_([^_]+)_"
   67 RE_TERM          = re.compile(TERM, re.LOCALE|re.MULTILINE)
   68 QUOTED           = u"''(('?[^'])+)''"
   69 RE_QUOTED        = re.compile(QUOTED, re.LOCALE|re.MULTILINE)
   70 CITATION         = u"([^]+)"
   71 RE_CITATION      = re.compile(CITATION,re.LOCALE|re.MULTILINE)
   72 
   73 # Special Characters
   74 
   75 BREAK            = u"\s*\n\s*\|\s*\n()"
   76 RE_BREAK         = re.compile(BREAK)
   77 SWALLOW_BREAK    = u"\s*\|\s*\n()"
   78 RE_SWALLOW_BREAK = re.compile(SWALLOW_BREAK)
   79 NEWLINE          = u"\s*\\\\n\s*()"
   80 RE_NEWLINE       = re.compile(NEWLINE)
   81 LONGDASH         = u" -- ()"
   82 RE_LONGDASH      = re.compile(LONGDASH)
   83 LONGLONGDASH     = u" --- ()"
   84 RE_LONGLONGDASH      = re.compile(LONGLONGDASH)
   85 ARROW            = u"<-+>|-+->|<-+"
   86 RE_ARROW         = re.compile(ARROW,)
   87 DOTS             = u"\.\.\.()"
   88 RE_DOTS          = re.compile(DOTS,)
   89 ENTITIES         = u"(&(\w+|#[0-9]+);)"
   90 RE_ENTITIES      = re.compile(ENTITIES,)
   91 
   92 # Linking content
   93 
   94 EMAIL            = u"\<([\w.\-_]+@[\w.\-_]+)\>"
   95 RE_EMAIL         = re.compile(EMAIL, re.LOCALE|re.MULTILINE)
   96 URL              = u"\<([A-z]+://[^\>]+)\>"
   97 RE_URL           = re.compile(URL, re.LOCALE|re.MULTILINE)
   98 URL_2            = u"([A-z]+://[^\>]+)"
   99 RE_URL_2         = re.compile(URL_2, re.LOCALE|re.MULTILINE)
  100 LINK             = u"""\[([^\]]+)\]\s*((\(([^ \)]+)(\s+"([^"]+)"\s*)?\))|\[([\w\s]+)\])?"""
  101 RE_LINK          = re.compile(LINK, re.LOCALE|re.MULTILINE)
  102 TARGET           = u"\|([\w\s]+(:[^\|]*)?)\|"
  103 RE_TARGET        = re.compile(TARGET, re.LOCALE)
  104 
  105 # Custom markup
  106 MARKUP_ATTR      = u"""\w+\s*=\s*('[^']*'|"[^"]*")"""
  107 MARKUP           = u"\<(\w+)(\s*%s)*\s*/?>|\</(\w+)\s*>" % (MARKUP_ATTR)
  108 RE_MARKUP        = re.compile(MARKUP, re.LOCALE|re.MULTILINE)
  109 
  110 def _processText( context, text ):
  111     """Common operation for expanding tabs and normalising text. Use by
  112     acronyms, citations and quotes."""
  113     if not text: return text
  114     text = context.parser.expandTabs(text)
  115     text = context.parser.normaliseText(text)
  116     return text
  117 
  118 #------------------------------------------------------------------------------
  119 #
  120 #  InlineParser
  121 #
  122 #------------------------------------------------------------------------------
  123 
  124 class InlineParser:
  125 
  126     def __init__( self, name, regexp, result=lambda x,y: x.group(1),
  127         requiresLeadingSpace=False):
  128         """Creates a new InlineParser.
  129 
  130         Name is the name of the parser, *regexp* is the string expression
  131         of the regular expression that will match the element that the
  132         InlineParser is looking for, or regexp can also be a precompiled
  133         regular expression object.
  134 
  135         Result is a lambda expression that will return the content of the
  136         Inline generated by the *parse* method. The lambda takes two
  137         arguments : the match object and the string in which the match object
  138         has been found."""
  139         self.name   = name
  140         #Checks if regexp is a string or a precompiled regular expression
  141         if type(regexp) in (type(u""), type("")):
  142             self.regexp = re.compile(regexp, re.LOCALE|re.MULTILINE)
  143         else:
  144             self.regexp = regexp
  145         self.result = result
  146         self.requiresLeadingSpace = requiresLeadingSpace
  147 
  148     def _recognisesBefore( self, context, match ):
  149         """A function that is called to check if the text before the current
  150         offset is recognized by this parser. This is used by
  151         'requiresLeadingSpace'."""
  152         if match.start() == 0: return True
  153         previous_char = context.currentFragment()[match.start()-1]
  154         return previous_char in u' \t();:-!?'
  155 
  156     def recognises( self, context ):
  157         """Recognises this inlines in the given context, within the current
  158         context block. It returns (None, None) when the inline was not recognised,
  159         otherwise it returns the offset of the matching element in the current
  160         context, plus information that will be given as argument to the parse
  161         method. This means that the returned offset is RELATIVE TO THE CURRENT
  162         CONTEXT OFFSET."""
  163         match = self.regexp.search(context.currentFragment())
  164         fragment = context.currentFragment()
  165         if match:
  166             match_start = max(0,match.start()-1)
  167             if self.requiresLeadingSpace and not self._recognisesBefore(context, match):
  168                 return (None, None)
  169             return (match.start(), match)
  170         else:
  171             return (None, None)
  172 
  173     def endOf( self, recogniseInfo ):
  174         """Returns the end of this inline using the given recogniseInfo."""
  175         return recogniseInfo.end()
  176 
  177     def parse( self, context, node, recogniseInfo  ):
  178         """Parses the given context within the current block range, returning
  179         the new offset (relative to the block start offset, ie. the start of
  180         context.currentFragment). Note that the context offsets are the same
  181         as those given to the recognise method call which created
  182         recogniseInfo.
  183 
  184         The given context starts at the same offset as when recognises was
  185         called. Modifications are made to the given node."""
  186         match = recogniseInfo
  187         assert match!=None
  188         text = self.result(match, context.documentText)
  189         if self.name:
  190             inline_node = context.document.createElementNS(None, self.name)
  191             if text:
  192                 text_node   = context.document.createTextNode(text)
  193                 inline_node.appendChild(text_node)
  194             node.appendChild(inline_node)
  195         elif not self.name is None:
  196             inline_node   = context.document.createTextNode(text)
  197             node.appendChild(inline_node)
  198         return self.endOf(recogniseInfo)
  199 
  200 #------------------------------------------------------------------------------
  201 #
  202 #  Arrow parsers
  203 #
  204 #------------------------------------------------------------------------------
  205 
  206 class ArrowInlineParser( InlineParser ):
  207 
  208     def __init__( self ):
  209         InlineParser.__init__( self, "arrow", RE_ARROW )
  210 
  211     def parse( self, context, node, match ):
  212         assert match
  213         text = match.group()
  214         arrow_type = None
  215         if text[0] == "<":
  216             if text[-1] == ">": arrow_type = "double"
  217             else: arrow_type = "left"
  218         else:
  219             arrow_type = "right"
  220         arrow_node = context.document.createElementNS(None, "arrow")
  221         arrow_node.setAttributeNS(None, "type", arrow_type)
  222         node.appendChild(arrow_node)
  223         return match.end()
  224 
  225 #------------------------------------------------------------------------------
  226 #
  227 #  Entity parsers
  228 #
  229 #------------------------------------------------------------------------------
  230 
  231 class EntityInlineParser( InlineParser ):
  232 
  233     def __init__( self ):
  234         InlineParser.__init__( self, "entity", RE_ENTITIES )
  235 
  236     def parse( self, context, node, match ):
  237         assert match
  238         text = match.group(2)
  239         entity_node = context.document.createElementNS(None, "entity")
  240         entity_node.setAttributeNS(None, "num", text)
  241         node.appendChild(entity_node)
  242         return match.end()
  243 
  244 #------------------------------------------------------------------------------
  245 #
  246 #  Pre parsers
  247 #
  248 #------------------------------------------------------------------------------
  249 
  250 class PreInlineParser( InlineParser ):
  251 
  252     def __init__( self ):
  253         InlineParser.__init__( self, "pre", PRE )
  254 
  255     def recognises( self, context ):
  256         return InlineParser.recognises(self,context)
  257 
  258     def parse( self, context, node, match ):
  259         lines = []
  260         for text in match.group().split("\n"):
  261             submatch = RE_PRE.match(text + "\n")
  262             if text: text = context.parser.expandTabs(submatch.group(4))
  263             lines.append(text)
  264         pre_node = context.document.createElementNS(None, 'pre')
  265         pre_node.appendChild(context.document.createTextNode("\n".join(lines)))
  266         node.appendChild(pre_node)
  267         return match.end()
  268 
  269 #------------------------------------------------------------------------------
  270 #
  271 #  CommentInlineParser
  272 #
  273 #------------------------------------------------------------------------------
  274 
  275 class CommentInlineParser( InlineParser ):
  276 
  277     def __init__( self ):
  278         InlineParser.__init__( self, "comment", RE_COMMENT )
  279 
  280     def processText( self, text ):
  281         new_text = ""
  282         for line in text.split("\n"):
  283             line = line.strip()
  284             if len(line)>1:
  285                 line = line[1:]
  286                 new_text += line + "\n"
  287         if new_text: new_text = new_text[:-1]
  288         new_text = " "+new_text+" "
  289         return new_text
  290 
  291     def parse( self, context, node, recogniseInfo ):
  292         match = recogniseInfo
  293         assert match!=None
  294         node.appendChild(context.document.createComment(
  295             self.processText(match.group())))
  296         return match.end()
  297 
  298 #------------------------------------------------------------------------------
  299 #
  300 #  Escape inline parser
  301 #
  302 #------------------------------------------------------------------------------
  303 
  304 class EscapedInlineParser( InlineParser ):
  305 
  306     def __init__( self ):
  307         InlineParser.__init__( self, "escaped", None )
  308 
  309     def recognises( self, context ):
  310         start_match = RE_ESCAPED_START.search(context.currentFragment())
  311         if start_match:
  312             # And search the escape starting from the end of the escaped
  313             end_match = RE_ESCAPED_END.search(
  314                 context.currentFragment(), start_match.end())
  315             if end_match:
  316                 return (start_match.start(), (start_match, end_match))
  317             else:
  318                 return (None, None)
  319         return (None, None)
  320 
  321     def endOf( self, recogniseInfo ):
  322         return recogniseInfo[1].end()
  323 
  324     def parse( self, context, node, recogniseInfo  ):
  325         # We get start and end match, end being relative to the start
  326         start_match, end_match = recogniseInfo
  327         assert start_match!=None and end_match!=None
  328 
  329         # Create a text node with the escaped text
  330         escaped_node = context.document.createTextNode(
  331             context.currentFragment()[start_match.end():end_match.start()])
  332         node.appendChild(escaped_node)
  333         # And increase the offset
  334         return self.endOf(recogniseInfo)
  335 
  336 #------------------------------------------------------------------------------
  337 #
  338 #  Escaped String Inline Parser
  339 #
  340 #------------------------------------------------------------------------------
  341 
  342 class EscapedStringInlineParser( InlineParser ):
  343 
  344     def __init__( self ):
  345         InlineParser.__init__( self, None, RE_ESCAPED_STRING )
  346 
  347     def parse( self, context, node, match ):
  348         res = context.document.createTextNode(match.group(1))
  349         node.appendChild(res)
  350         return match.end()
  351 
  352 #------------------------------------------------------------------------------
  353 #
  354 #  Link/Reference parser
  355 #
  356 #------------------------------------------------------------------------------
  357 
  358 class LinkInlineParser( InlineParser ):
  359 
  360     def __init__( self ):
  361         InlineParser.__init__( self, "link", RE_LINK )
  362 
  363     def recognises( self, context ):
  364         result = InlineParser.recognises(self, context)
  365         # We avoid conflict with the tasks list. This may not be
  366         # always necessary, but it's safer to have it.
  367         if result[1]:
  368             r = result[1].group().strip()
  369             if len(r) == 3 and r[0] == "[" and r[2]=="]":
  370                 return (None, None)
  371         return result
  372 
  373     def parse( self, context, node, match ):
  374         assert match
  375         # We detect wether the link is an URL or Ref link
  376         link_node = context.document.createElementNS(None, "link")
  377         if match.group(7):
  378             ref_entry = match.group(7)
  379             link_node.setAttributeNS(None, "type",   "ref")
  380             link_node.setAttributeNS(None, "target", ref_entry)
  381         else:
  382             ref_url   = match.group(4)
  383             ref_title = match.group(5)
  384             if not ref_url:
  385                 link_node.setAttributeNS(None, "type", "ref")
  386                 link_node.setAttributeNS(None, "target", match.group(1))
  387             else:
  388                 link_node.setAttributeNS(None, "type", "url")
  389                 link_node.setAttributeNS(None, "target", ref_url)
  390         context._links.append(link_node)
  391         #Now we parse the content of the link
  392         offsets = context.saveOffsets()
  393         context.setCurrentBlock(context.getOffset() + match.start() + 1,
  394         context.getOffset() + match.start() + 1 + len(match.group(1)))
  395         context.parser.parseBlock(context, link_node, _processText)
  396         context.restoreOffsets(offsets)
  397         node.appendChild(link_node)
  398         return match.end()
  399 
  400 #------------------------------------------------------------------------------
  401 #
  402 #  Target parser
  403 #
  404 #------------------------------------------------------------------------------
  405 
  406 class TargetInlineParser( InlineParser ):
  407 
  408     def __init__( self ):
  409         InlineParser.__init__( self, "target", RE_TARGET )
  410 
  411     def parse( self, context, node, match ):
  412         assert match
  413         # We detect wether the link is an URL or Ref link
  414         target_node = context.document.createElementNS(None, "target")
  415         name_and_text = match.group(1).split(":", 1)
  416         if len(name_and_text) == 1:
  417             name = name_and_text[0]
  418             text = None
  419         else:
  420             name = name_and_text[0]
  421             text = name_and_text[1]
  422             if not text: text = name
  423         target_node.setAttributeNS(None, "name", name.replace("  ", " ").strip().lower())
  424         if text:
  425             text_node   = context.document.createTextNode(text)
  426             target_node.appendChild(text_node)
  427         context._targets.append(target_node)
  428         node.appendChild(target_node)
  429         return match.end()
  430 
  431 #------------------------------------------------------------------------------
  432 #
  433 #  MarkupInlineParser
  434 #
  435 #------------------------------------------------------------------------------
  436 
  437 def Markup_isStartTag( match ):
  438     return not Markup_isEndTag(match) and not match.group().endswith("/>")
  439 
  440 def Markup_isEndTag( match ):
  441     return match.group().startswith("</")
  442 
  443 def Markup_attributes( match ):
  444     """Returns the attribute string of this markup stat element."""
  445     text = match.group()[1 + len(match.group(1))+1:-1]
  446     if text and text[-1] == "/": text = text[:-1]
  447     text = text.strip()
  448     return text
  449 
  450 class MarkupInlineParser( InlineParser ):
  451     """Parses Kiwi generic markup elements."""
  452 
  453     def __init__( self ):
  454         InlineParser.__init__(self, None, RE_MARKUP)
  455 
  456     def parse( self, context, node, recogniseInfo  ):
  457         """Parses the given tag, and returns the offset where the parsed tag
  458         ends. If the tag is an "inline block" tag, then its content is also
  459         parsed."""
  460         match = recogniseInfo
  461         # Is it an inline ?
  462         if match.group().endswith("/>"):
  463             # TODO: Check if element name is recognised or not
  464             markup_name = match.group(1)
  465             markup_node = context.document.createElementNS(None, markup_name.strip())
  466             markup_node.setAttributeNS(None, "_html", "true")
  467             for key, value in context.parseAttributes(Markup_attributes(match)).items():
  468                 markup_node.setAttributeNS(None, key, value)
  469             node.appendChild(markup_node)
  470             return match.end()
  471         # Or is it a block start ?
  472         elif self.isStartTag(match):
  473             # We search for an end, taking care of setting the offset after the
  474             # recognised inline.
  475             markup_name  = match.group(1).strip()
  476             markup_range = self.findEnd( markup_name, context, match.end())
  477             if not markup_range:
  478                 context.parser.error( START_WITHOUT_END % (markup_name), context )
  479                 return match.end()
  480             else:
  481                 markup_end   = markup_range[0] + context.getOffset()
  482                 # We do not want the context to be altered by block parsing
  483                 offsets = context.saveOffsets()
  484                 context.setCurrentBlock(context.getOffset()+match.end(),
  485                     context.getOffset()+markup_range[0])
  486                 # We check if there is a specific block parser for this markup
  487                 custom_parser = context.parser.customParsers.get(markup_name)
  488                 # Here we have found a custom parser, which is in charge for
  489                 # creating nodes
  490                 if custom_parser:
  491                     custom_parser.process(context, None)
  492                 # Otherwise we create the node for the markup and continue
  493                 # parsing
  494                 else:
  495                     markup_node = context.document.createElementNS(None, "Content")
  496                     markup_node.setAttributeNS(None, "_html", "true")
  497                     node.appendChild(markup_node)
  498                     # We add the attributes to this tag
  499                     for key, value in context.parseAttributes(Markup_attributes(match)).items():
  500                         markup_node.setAttributeNS(None, key, value)
  501                     # FIXME: This should not be necessary
  502                     old_node = context.currentNode
  503                     context.currentNode = markup_node
  504                     context.currentNode = markup_node
  505                     before_offset = context.getOffset()
  506                     next_block = context.parser._findNextBlockSeparator(context)
  507                     # There may be many blocks contained in the markup delimited
  508                     # by the node. Here we try to parse all the blocks until be
  509                     # reach the end of the markup minus 1 (that is the last
  510                     # separator before the block end)
  511                     if context.offsetInBlock(next_block[0]) or context.offsetInBlock(next_block[1]):
  512                         end_offset  = context.blockEndOffset
  513                         context.setOffset(context.blockStartOffset)
  514                         while context.getOffset() < markup_end :
  515                             context.parser._parseNextBlock(context, end=markup_end)
  516                     # If there was no block contained, we parse the text as a
  517                     # single block
  518                     else:
  519                         context.parser.parseBlock(context, markup_node, self.processText)
  520                     markup_node.nodeName = markup_name
  521                     markup_node.tagName = markup_name
  522                     context.currentNode = old_node
  523                 context.restoreOffsets(offsets)
  524                 return markup_range[1]
  525         # Or is a a closing element ?
  526         elif self.isEndTag(match):
  527             context.parser.error( END_WITHOUT_START % (match.group(4).strip()),
  528             context )
  529             return match.end()
  530         else:
  531             context.parser.error( MUST_BE_START_OR_END, context )
  532             return match.end()
  533 
  534     def _searchMarkup( self, context ):
  535         """Looks for the next markup inline in the current context. This also
  536         takes care of markups that are contained into an escaped text tag.
  537 
  538         WARNING : this operation mutates the context offsets, so this should
  539         always be enclosed in offset store and restore. The context offset is
  540         set BEFORE the searched markup, so that the returned recognition info
  541         is relative to the context offset.
  542 
  543         Returns the result of this parser `recognise' method, or null."""
  544         inline_parsers = ( context.parser.escapedParser, self )
  545         # We look for a block inline
  546         while not context.blockEndReached():
  547             result = context.findNextInline(inline_parsers)
  548             if result:
  549                 if result[2] == self:
  550                     return result[1]
  551                 else:
  552                     context.increaseOffset(result[2].endOf(result[1]))
  553             else:
  554                 break
  555         return None
  556 
  557     def isStartTag( self, match ):
  558         return Markup_isStartTag(match)
  559 
  560     def isEndTag( self, match ):
  561         return Markup_isEndTag(match)
  562 
  563     def findEnd( self, blockName, context, offsetIncr=0 ):
  564         """Finds the end of the given markup end in the current block. Returns
  565         a couple (start, end) indicating the start and end offsets of the found
  566         end block, relative to the context offset. The given 'offsetIncr'
  567         parameter tells the number of characters to skip before searching for
  568         the end markup. This has no impact on the result.
  569 
  570         The context offsets are left unchanged."""
  571         depth = markup_match =  1
  572         block_name = None
  573         offsets = context.saveOffsets()
  574         original_offset = context.getOffset()
  575         context.increaseOffset(offsetIncr)
  576         # We look for start and end markups
  577         while depth>0 and markup_match and not context.blockEndReached():
  578             markup_match = self._searchMarkup(context)
  579             if markup_match:
  580                 if self.isStartTag(markup_match):
  581                     depth += 1
  582                 elif self.isEndTag(markup_match):
  583                     depth -= 1
  584                     block_name = markup_match.group(4).strip()
  585                 if depth > 0:
  586                     context.increaseOffset(markup_match.end())
  587         # We have found at least one matching block
  588         end_markup_range = None
  589         if depth==0 and block_name and block_name==blockName:
  590             # The match is relative to the current context offset
  591             match_start = context.getOffset() - original_offset + markup_match.start()
  592             match_end   = context.getOffset() - original_offset + markup_match.end()
  593             end_markup_range = ( match_start, match_end )
  594         context.restoreOffsets(offsets)
  595         return end_markup_range
  596 
  597     def processText( self, context, text ):
  598         return context.parser.normaliseText(text)
  599 
  600 # EOF