Texml/handler.py

   1 """ Tranform TeXML SAX stream """
   2 # $Id: handler.py,v 1.14 2006-06-14 04:45:06 olpa Exp $
   3
   4 import xml.sax.handler
   5 from xml.sax.handler import feature_namespaces
   6
   7 from Texml import texmlwr
   8 from Texml import specmap
   9 import string
  10
  11 # Unbreakable spaces should not be deleted by strip(), but it happens:
  12 # http://uucode.com/blog/2010/06/01/python-wtf-strip-eats-too-much/
  13 # The solution from the web page does not work with old versions
  14 # of python, therefore let's define a fallback functionality.
  15 try:
  16   "dummy".strip(string.whitespace)
  17   strip_args = (string.whitespace, )
  18 except:
  19   strip_args = ()
  20
  21 #
  22 # TeXML SAX handler works correct but misfeaturely when SAX parser
  23 # reports characters in several calls instead of one call.
  24 # This wrappers fixes the problem
  25 #
  26
  27 class ParseFile:
  28     """
  29
  30     Wrapper class to make the library easier to use.
  31
  32     See the above notes for use.
  33
  34     """
  35
  36     def __init__(self):
  37         pass
  38
  39     def parse_file(self, texml_writer, read_obj, use_context):
  40
  41         handle = glue_handler(texml_writer, use_context)
  42
  43         parser = xml.sax.make_parser()
  44         parser.setFeature(feature_namespaces, 1)
  45         parser.setContentHandler(handle)
  46         parser.setFeature("http://xml.org/sax/features/external-general-entities", True)
  47
  48
  49         parser.parse(read_obj)
  50
  51 class InvalidXmlException(Exception):
  52     """
  53     handle invalid xml
  54
  55     """
  56     pass
  57
  58 class glue_handler(xml.sax.ContentHandler):
  59
  60   """
  61   Not really a public class. use ParseFile instead.
  62
  63   """
  64
  65   def __init__(self, texml_writer, use_context,
  66         name_space = 'http://getfo.sourceforge.net/texml/ns1'):
  67     self.h = Handler(texml_writer, use_context)
  68     self.c = None
  69
  70     self.__name_space = name_space
  71     self.__current_name_space = None
  72
  73   def startDocument(self):
  74     self.c = None
  75     self.h.startDocument()
  76
  77   def flushChars(self):
  78     if self.c != None:
  79       self.h.characters(self.c)
  80       self.c = None
  81
  82   def endDocument(self):
  83     self.flushChars()
  84     self.h.endDocument()
  85
  86   # no longer use
  87   def startElement_off(self, name, attrs):
  88     self.flushChars()
  89     self.h.startElement(name, attrs)
  90
  91   def setDocumentLocator(self, locator):
  92       self.locator = locator
  93
  94   def startElementNS(self, name, qname, attrs):
  95     # change attrs to regular dictionary
  96     the_attrs = {}
  97     keys = attrs.keys()
  98     for key in keys:
  99         att = key[1]
 100         value = attrs[key]
 101         the_attrs[att] = value
 102
 103     name_space = name[0]
 104     self.__current_name_space = name_space
 105     local_name = name[1]
 106
 107     # get the column and line number and use the handler
 108     col_num = self.locator.getColumnNumber()
 109     line_num =  self.locator.getLineNumber()
 110     self.h.set_location(col_num, line_num)
 111     self.h.set_namespace(name_space)
 112
 113     if name_space == self.__name_space or name_space == None:
 114         self.flushChars()
 115         self.h.startElement(local_name, the_attrs)
 116     # report an error and quit
 117     else:
 118         self.h.invalid_xml(local_name)
 119
 120   # no longer use
 121   def endElement_off(self, name):
 122     self.flushChars()
 123     self.h.endElement(name)
 124
 125   def endElementNS(self, name, qname):
 126     col_num = self.locator.getColumnNumber()
 127     line_num =  self.locator.getLineNumber()
 128     self.h.set_location(col_num, line_num)
 129     name_space = name[0]
 130     local_name = name[1]
 131     if name_space == self.__name_space or name_space == None:
 132         self.flushChars()
 133         self.h.endElement(local_name)
 134     # otherwise, ignore!
 135
 136
 137   def processingInstruction(self, target, data):
 138     self.flushChars()
 139     # No action. The only effect is that chunk
 140     # ... aa  <!-- xx -->  bb ...
 141     # is reported twice ('... aa  ' and ' bb ...')
 142     # instead of onece ('... aa    bb ...')
 143
 144   def characters(self, content):
 145     col_num = self.locator.getColumnNumber()
 146     line_num =  self.locator.getLineNumber()
 147     self.h.set_location(col_num, line_num)
 148     if None == self.c:
 149       self.c = content
 150     else:
 151       self.c = self.c + content
 152
 153 # WhiteSpace (WS) elimination
 154 # In most cases, WS around tags (both opening and closing) are removed.
 155 # But these tags save ws: <ctrl/> and <spec/>.
 156 # WS processing is allowed or disallowed by "process_ws".
 157
 158 class Handler:
 159
 160   """
 161   Not really a public class.
 162
 163   Handles the infile, using the glue_handle class to get the data as
 164   elements or characters.
 165
 166   """
 167
 168   # Object variables
 169   # writer
 170   # no_text_content
 171   # text_is_only_spaces
 172   #
 173   # Whitespace handling:
 174   # process_ws
 175   # process_ws_stack
 176   # nl_spec
 177   # nl_spec_stack
 178   #
 179   # For <env/> support:
 180   # cmdname
 181   # cmdname_stack
 182   # endenv
 183   # endenv_stack
 184   #
 185   # For <cmd/> support:
 186   # has_parm # Stacking is not required: if <cmd/> is in <cmd/>,
 187   #          # then is it wrapped by <parm/> or <opt/>
 188
 189   def __init__(self, texml_writer, use_context):
 190     """ Create writer, create maps """
 191     self.__use_context = use_context
 192     # Paul Tremblay added this on 2005-03-08
 193     self.writer        = texml_writer
 194     self.cmdname_stack = []
 195     self.endenv_stack  = []
 196     self.cmdname       = ''
 197     self.endenv        = ''
 198     self.has_parm      = 0
 199     self.no_text_content     = 0
 200     self.text_is_only_spaces = 0
 201     self.process_ws          = 1
 202     self.process_ws_stack    = []
 203     self.nl_spec             = None
 204     self.nl_spec_stack       = []
 205     self.__name_space        = None
 206     #
 207     # Create handler maps
 208     #
 209     self.model_nomath = {
 210       'TeXML':  self.on_texml,
 211       'cmd':    self.on_cmd,
 212       'env':    self.on_env,
 213       'group':  self.on_group,
 214       'ctrl':   self.on_ctrl,
 215       'spec':   self.on_spec,
 216       'pdf':    self.on_pdf
 217     }
 218     self.model_content          = self.model_nomath.copy()
 219     self.model_content['math']  = self.on_math
 220     self.model_content['dmath'] = self.on_dmath
 221     self.model_cmd    = {
 222       'opt':    self.on_opt,
 223       'parm':   self.on_parm
 224     }
 225     self.model_env    = self.model_content.copy() # copy, so == will true only for environment, not for any tag that shares model_content
 226     self.model_env.update(self.model_cmd)
 227     self.model_opt    = self.model_content
 228     self.model_parm   = self.model_content
 229     self.end_handlers = {
 230       'TeXML':  self.on_texml_end,
 231       'cmd':    self.on_cmd_end,
 232       'env':    self.on_env_end,
 233       'group':  self.on_group_end,
 234       'ctrl':   self.on_ctrl_end,
 235       'spec':   self.on_spec_end,
 236       'opt':    self.on_opt_end,
 237       'parm':   self.on_parm_end,
 238       'math':   self.on_math_end,
 239       'dmath':  self.on_dmath_end,
 240       'pdf':    self.on_pdf_end
 241     }
 242
 243   def set_location(self, col, line):
 244       self.__col_num = col
 245       self.__line_num = line
 246
 247   def set_namespace(self, name):
 248       self.__name_space = name
 249
 250   def invalid_xml(self,  local_name):
 251       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 252       if self.__name_space:
 253         msg += 'Element "%s" for namespace "%s" not expected' % (local_name, self.__name_space)
 254       else:
 255         msg += '%s not expected' % (local_name)
 256
 257       raise InvalidXmlException(msg)
 258
 259   def invalid_xml_other(self, msg):
 260       # for other types of invalid XML
 261       raise InvalidXmlException(msg)
 262
 263   # -------------------------------------------------------------------
 264
 265   def startDocument(self):
 266     """ Initialize data structures before parsing """
 267     self.model       = {'TeXML': self.on_texml}
 268     self.model_stack = []
 269
 270   def endDocument(self):
 271     """ Finalize document """
 272     self.writer.conditionalNewline()
 273
 274   def startElement(self, name, attrs):
 275     """ Handle start of an element"""
 276     if name in self.model:
 277       self.model[name](attrs)
 278     else:
 279       self.invalid_xml(name)
 280
 281   def characters(self, content):
 282     """ Handle text data """
 283     #
 284     # First, check if content allowed at all
 285     #
 286     # Elements like <spec/> should be empty
 287     if self.no_text_content:
 288       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 289       msg  += "Text content is not expected: '%s'" % content.encode('latin-1', 'replace')
 290       self.invalid_xml_other(msg)
 291     # Element <cmd/> should not have text content,
 292     # but it also may contain spaces due to indenting
 293     # Element <env/> may have <opt/> and <parm/>, so we do
 294     # magic to delete whitespace at beginning of environment
 295     if self.text_is_only_spaces:
 296       stripped = content.lstrip(*strip_args)
 297       if 0 != len(stripped):
 298         msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 299         msg += "Only whitespaces are expected, not text content: '%s'" % content.encode('latin-1', 'replace')
 300         self.invalid_xml_other(msg)
 301       return                                               # return
 302     #
 303     # Eliminate whitespaces
 304     #
 305     post_content_ws = 0
 306     if self.process_ws:
 307       content2 = content.lstrip(*strip_args)
 308       if len(content2) != len(content):
 309         self.writer.writeWeakWS()
 310       content  = content2.rstrip(*strip_args)
 311       if len(content2) != len(content):
 312         post_content_ws = 1
 313     #
 314     # Finally, write content
 315     #
 316     self.writer.write(content)
 317     if post_content_ws:
 318       self.writer.writeWeakWS()
 319
 320   def endElement(self, name):
 321     """ Handle end of en element """
 322     self.end_handlers[name]()
 323     self.unstack_model()
 324
 325   def stack_model(self, model):
 326     """ Remember content model of parent and set model for current node """
 327     self.model_stack.append(self.model)
 328     self.model = model
 329
 330   def unstack_model(self):
 331     """ Restore content model of parent """
 332     self.model = self.model_stack.pop()
 333
 334   # -----------------------------------------------------------------
 335
 336   def get_boolean(self, attrs, aname, default):
 337     """ Returns true if value of attribute "aname" is "1", false if "0" and None if attribute not exists. Raises error in other cases."""
 338     aval = attrs.get(aname, None)
 339     if None == aval:
 340       return default
 341     elif '1' == aval:
 342       return 1
 343     elif '0' == aval:
 344       return 0
 345     raise ValueError("Value of boolean attribute '%s' is not '0' or '1', but '%s'" % (aname, aval))
 346
 347     msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 348     msg += "Value of boolean attribute '%s' is not '0' or '1', but '%s'" % (aname, aval)
 349     self.invalid_xml_other(msg)
 350
 351   def on_texml(self, attrs):
 352     """ Handle TeXML element """
 353     self.stack_model(self.model_content)
 354     #
 355     # Set new mode ("text" or "math")
 356     #
 357     str = attrs.get('mode', None)
 358     if None == str:
 359       mode = texmlwr.DEFAULT
 360     elif 'text' == str:
 361       mode = texmlwr.TEXT
 362     elif 'math' == str:
 363       mode = texmlwr.MATH
 364     else:
 365       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 366       msg += "Unknown value of TeXML/@mode attribute: '%s'" % str
 367       self.invalid_xml_other(msg)
 368     emptylines = self.get_boolean(attrs, 'emptylines', None)
 369     escape     = self.get_boolean(attrs, 'escape',     None)
 370     ligatures  = self.get_boolean(attrs, 'ligatures',  None)
 371     self.writer.stack_mode(mode)
 372     self.writer.stack_emptylines(emptylines)
 373     self.writer.stack_escape(escape)
 374     self.writer.stack_ligatures(ligatures)
 375     ws = self.get_boolean(attrs, 'ws', None)
 376     self.process_ws_stack.append(self.process_ws)
 377     if ws != None:
 378       self.process_ws  =  0 == ws
 379       self.writer.set_allow_weak_ws_to_nl(not ws)
 380
 381   def on_texml_end(self):
 382     """ Handle TeXML element. Restore old mode. """
 383     self.writer.unstack_ligatures()
 384     self.writer.unstack_escape()
 385     self.writer.unstack_emptylines()
 386     self.writer.unstack_mode()
 387     self.process_ws = self.process_ws_stack.pop()
 388     self.writer.set_allow_weak_ws_to_nl(self.process_ws)
 389
 390   # -----------------------------------------------------------------
 391
 392   def on_cmd(self, attrs):
 393     """ Handle 'cmd' element """
 394     self.stack_model(self.model_cmd)
 395     #
 396     # Get name of the command
 397     #
 398     name = attrs.get('name', '')
 399     if 0 == len(name):
 400       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 401       msg += "Attribute cmd/@name is empty"
 402       self.invalid_xml_other(msg)
 403     if self.get_boolean(attrs, 'nl1', 0):
 404       self.writer.conditionalNewline()
 405     self.writer.writech('\\', 0)
 406     self.writer.write(name, 0)
 407     #
 408     # Setup in-cmd processing
 409     #
 410     self.has_parm            = 0
 411     self.text_is_only_spaces = 1
 412     self.nl_spec_stack.append(self.nl_spec)
 413     self.nl_spec = (self.get_boolean(attrs, 'nl2', 0), self.get_boolean(attrs, 'gr', 1))
 414
 415   def on_cmd_end(self):
 416     self.text_is_only_spaces = 0
 417     #
 418     # Write additional space or newline if command has no parameters
 419     #
 420     (nl, gr) = self.nl_spec
 421     self.nl_spec = self.nl_spec_stack.pop()
 422     if not(self.has_parm):
 423       if gr:
 424         self.writer.write('{}', 0)
 425       else:
 426         self.writer.writeWeakWS()
 427     if nl:
 428       self.writer.conditionalNewline()
 429
 430   def on_opt(self, attrs):
 431     """ Handle 'opt' element """
 432     self.on_opt_parm('[', attrs)
 433
 434   def on_parm(self, attrs):
 435     """ Handle 'parm' element """
 436     self.on_opt_parm('{', attrs)
 437
 438   def on_opt_end(self):
 439     self.on_opt_parm_end(']')
 440
 441   def on_parm_end(self):
 442     self.on_opt_parm_end('}')
 443
 444   def on_opt_parm(self, ch, attrs):
 445     """ Handle 'parm' and 'opt' """
 446     self.stack_model(self.model_opt)
 447     if self.model_stack[-1] == self.model_env:
 448       self.nl_spec_stack.append(self.nl_spec)
 449       self.nl_spec = self.writer.ungetWeakWS()
 450     self.writer.writech(ch, 0)
 451     self.text_is_only_spaces = 0
 452
 453   def on_opt_parm_end(self, ch):
 454     self.writer.writech(ch, 0)
 455     self.has_parm            = 1 # At the end to avoid collision of nesting
 456     # <opt/> can be only inside <cmd/> or (very rarely) in <env/>
 457     if self.model_stack[-1] != self.model_env:
 458       self.text_is_only_spaces = 1
 459     else:
 460       self.text_is_only_spaces = 0
 461       if self.nl_spec:
 462         self.writer.writeWeakWS(self.nl_spec)
 463       self.nl_spec = self.nl_spec_stack.pop()
 464
 465   # -----------------------------------------------------------------
 466
 467   def on_env(self, attrs):
 468     """ Handle 'cmd' element """
 469     self.stack_model(self.model_env)
 470     #
 471     # Get name of the environment, and begin and end commands
 472     #
 473     name = attrs.get('name', '')
 474     if 0 == len(name):
 475       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 476       msg += 'Attribute env/@name is empty'
 477       self.invalid_xml_other(msg)
 478     # added by Paul Tremblay on 2004-02-19
 479     # the environment in context is \startenvironmentname ...
 480     # \stopenvironmentname
 481     if self.__use_context:
 482         begenv = attrs.get('start', 'start')
 483     else:
 484         begenv = attrs.get('begin', 'begin')
 485     self.cmdname_stack.append(self.cmdname)
 486     self.endenv_stack.append(self.endenv)
 487     self.cmdname = name
 488
 489     # added by Paul Tremblay on 2004-02-19
 490     if self.__use_context:
 491         self.endenv  = attrs.get('stop',   'stop')
 492     else:
 493         self.endenv  = attrs.get('end',   'end')
 494     #
 495     # Write <env/> and setup newline processing
 496     #
 497     if self.get_boolean(attrs, 'nl1', 1):
 498       self.writer.conditionalNewline()
 499
 500     # added by Paul Tremblay on 2004-02-19
 501     # See note above
 502     if self.__use_context:
 503         self.writer.write('\%s%s' % (begenv, name), 0)
 504     else:
 505         self.writer.write('\%s{%s}' % (begenv, name), 0)
 506     if self.get_boolean(attrs, 'nl2', 1):
 507       self.writer.writeWeakWS(texmlwr.WEAK_WS_IS_NEWLINE)
 508     self.nl_spec_stack.append(self.nl_spec)
 509     self.nl_spec = (self.get_boolean(attrs, 'nl3', 1), self.get_boolean(attrs, 'nl4', 1))
 510
 511   def on_env_end(self):
 512     nl3, nl4 = self.nl_spec
 513     self.nl_spec = self.nl_spec_stack.pop()
 514     if nl3:
 515       self.writer.conditionalNewline()
 516
 517     # added by Paul Tremblay on 2004-02-19
 518     if self.__use_context:
 519         self.writer.write('\%s%s' % (self.endenv, self.cmdname), 0)
 520     else:
 521         self.writer.write('\%s{%s}' % (self.endenv, self.cmdname), 0)
 522     if nl4:
 523       self.writer.conditionalNewline()
 524     self.cmdname = self.cmdname_stack.pop()
 525     self.endenv  = self.endenv_stack.pop()
 526
 527   def on_group(self, attrs):
 528     """ Handle 'group' element """
 529     self.stack_model(self.model_content)
 530     self.writer.writech('{', 0)
 531
 532   def on_group_end(self):
 533     self.writer.writech('}', 0)
 534
 535   # -----------------------------------------------------------------
 536
 537   def on_ctrl(self, attrs):
 538     #
 539     # Get character, check and print tex command
 540     #
 541     ch = attrs.get('ch', '')
 542     if 1 != len(ch):
 543       msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 544       msg += "Attribute ctrl/@ch is not a char: '%s'" % ch
 545       self.invalid_xml_other(msg)
 546     self.writer.writech('\\', 0)
 547     self.writer.writech(ch,   0)
 548     #
 549     # Content of this element is empty
 550     #
 551     self.stack_model({})
 552     self.no_text_content = 1
 553
 554   def on_ctrl_end(self):
 555     self.no_text_content = 0
 556
 557   def on_spec(self, attrs):
 558     #
 559     # Get category, get corresponding character
 560     #
 561     cat = attrs.get('cat', '')
 562     if 'nl?' == cat:
 563       self.writer.conditionalNewline()
 564     else:
 565       if not (cat in specmap.tocharmap):
 566         msg = 'Invalid XML %s, %s: ' % (self.__col_num, self.__line_num)
 567         msg += "Attribute spec/@cat unknown: '%s'" % cat
 568         self.invalid_xml_other(msg)
 569       ch = specmap.tocharmap[cat]
 570       if '\n' == ch:
 571         self.writer.stack_emptylines(1)
 572       self.writer.write(ch, 0)
 573       if '\n' == ch:
 574         self.writer.unstack_emptylines()
 575     #
 576     # Content of this element is empty
 577     #
 578     self.stack_model({})
 579     self.no_text_content = 1
 580
 581   def on_spec_end(self):
 582     self.no_text_content = 0
 583
 584   # -----------------------------------------------------------------
 585
 586   def on_math(self, attrs):
 587     self.stack_model(self.model_nomath)
 588     self.writer.writech('$', 0)
 589     self.writer.stack_mode(texmlwr.MATH)
 590
 591   def on_math_end(self):
 592     self.writer.unstack_mode()
 593     self.writer.writech('$', 0)
 594
 595   def on_dmath(self, attrs):
 596     self.writer.writech('$', 0)
 597     self.on_math(attrs)
 598
 599   def on_dmath_end(self):
 600     self.on_math_end()
 601     self.writer.writech('$', 0)
 602
 603   # -----------------------------------------------------------------
 604
 605   def on_pdf(self, attrs):
 606     self.stack_model({})
 607     self.writer.stack_mode(texmlwr.PDF)
 608
 609   def on_pdf_end(self):
 610     self.writer.unstack_mode()