lib/scripts/layout2layout.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 # file layout2layout.py
   5 # This file is part of LyX, the document processor.
   6 # Licence details can be found in the file COPYING.
   7
   8 # author Georg Baum
   9
  10 # Full author contact details are available in file CREDITS
  11
  12 # This script will update a .layout file to current format
  13
  14
  15 import os, re, string, sys
  16
  17 # Incremented to format 4, 6 April 2007, lasgouttes
  18 # Introduction of generic "Provides" declaration
  19
  20 # Incremented to format 5, 22 August 2007 by vermeer
  21 # InsetLayout material
  22
  23 # Incremented to format 6, 7 January 2008 by spitz
  24 # Requires tag added to layout files
  25
  26 # Incremented to format 7, 24 March 2008 by rgh
  27 # AddToPreamble tag added to layout files
  28
  29 # Incremented to format 8, 25 July 2008 by rgh
  30 # UseModule tag added to layout files
  31 # CopyStyle added to InsetLayout
  32
  33 # Incremented to format 9, 5 October 2008 by rgh
  34 # ForcePlain and CustomPars tags added to InsetLayout
  35
  36 # Incremented to format 10, 6 October 2008 by rgh
  37 # Change format of counters
  38
  39 # Incremented to format 11, 14 October 2008 by rgh
  40 # Add ProvidesModule, ExcludesModule tags
  41
  42 # Incremented to format 12, 10 January 2009 by gb
  43 # Add I18NPreamble tag
  44
  45 # Incremented to format 13, 5 February 2009 by rgh
  46 # Add InToc tag for InsetLayout
  47
  48 # Incremented to format 14, 14 February 2009 by gb
  49 # Rename I18NPreamble to BabelPreamble and add LangPreamble
  50
  51 # Incremented to format 15, 28 May 2009 by lasgouttes
  52 # Add new tag OutputFormat; modules can be conditioned on feature
  53 # "from->to".
  54
  55 # Incremented to format 16, 5 June 2009 by rgh
  56 # Add new tags for Text Class:
  57 #   HTMLPreamble, HTMLAddToPreamble
  58 # For Layout:
  59 #   HTMLTag, HTMLAttr, HTMLLabel, HTMLLabelAttr, HTMLItem, HTMLItemAttr
  60 #   HTMLStyle, and HTMLPreamble
  61 # For InsetLayout:
  62 #   HTMLTag, HTMLAttr, HTMLStyle, and HTMLPreamble
  63 # For Floats:
  64 #   HTMLType, HTMLClass, HTMLStyle
  65
  66 # Incremented to format 17, 12 August 2009 by rgh
  67 # Add IfStyle and IfCounter tags for layout.
  68
  69 # Incremented to format 18, 27 October 2009 by rgh
  70 # Added some new tags for HTML output.
  71
  72 # Incremented to format 19, 17 November 2009 by rgh
  73 # Added InPreamble tag.
  74
  75 # Incremented to format 20, 17 December 2009 by rgh
  76 # Added ContentAsLabel tag.
  77
  78 # Incremented to format 21, 12 January 2010 by rgh
  79 # Added HTMLTocLayout and HTMLTitle tags.
  80
  81 # Incremented to format 22, 20 January 2010 by rgh
  82 # Added HTMLFormat tag to Counters.
  83
  84 # Incremented to format 23, 13 February 2010 by spitz
  85 # Added Spellcheck tag.
  86
  87 # Incremented to format 24, 5 March 2010 by rgh
  88 # Changed LaTeXBuiltin tag to NeedsFloatPkg and
  89 # added new tag ListCommand.
  90
  91 # Incremented to format 25, 12 March 2010 by rgh
  92 # Added RefPrefix tag for layouts and floats.
  93
  94 # Incremented to format 26, 29 March 2010 by rgh
  95 # Added CiteFormat.
  96
  97 # Incremented to format 27, 4 June 2010 by rgh
  98 # Added RequiredArgs tag.
  99
 100 # Incremented to format 28, 6 August 2010 by lasgouttes
 101 # Added ParbreakIsNewline tag for Layout and InsetLayout.
 102
 103 # Incremented to format 29, 10 August 2010 by rgh
 104 # Changed Custom:Style, CharStyle:Style, and Element:Style
 105 # uniformly to Flex:Style.
 106
 107 # Incremented to format 30, 13 August 2010 by rgh
 108 # Introduced ResetsFont tag for InsetLayout.
 109
 110 # Incremented to format 31, 12 January 2011 by rgh
 111 # Introducted NoCounter tag.
 112
 113 # Incremented to format 32, 30 January 2011 by forenr
 114 # Added Display tag for InsetLayout
 115
 116 # Incremented to format 33, 2 February 2011 by rgh
 117 # Changed NeedsFloatPkg to UsesFloatPkg
 118
 119 # Do not forget to document format change in Customization
 120 # Manual (section "Declaring a new text class").
 121
 122 # You might also want to consider running the
 123 # development/tools/updatelayouts.sh script to update all
 124 # layout files to the new format.
 125
 126 currentFormat = 33
 127
 128
 129 def usage(prog_name):
 130     return ("Usage: %s inputfile outputfile\n" % prog_name +
 131             "or     %s <inputfile >outputfile" % prog_name)
 132
 133
 134 def error(message):
 135     sys.stderr.write(message + '\n')
 136     sys.exit(1)
 137
 138
 139 def trim_bom(line):
 140     " Remove byte order mark."
 141     if line[0:3] == "\357\273\277":
 142         return line[3:]
 143     else:
 144         return line
 145
 146
 147 def read(source):
 148     " Read input file and strip lineendings."
 149     lines = source.read().splitlines()
 150     lines[0] = trim_bom(lines[0])
 151     return lines
 152
 153
 154 def write(output, lines):
 155     " Write output file with native lineendings."
 156     output.write(os.linesep.join(lines) + os.linesep)
 157
 158
 159 # Concatenates old and new in an intelligent way:
 160 # If old is wrapped in ", they are stripped. The result is wrapped in ".
 161 def concatenate_label(old, new):
 162     # Don't use strip as long as we support python 1.5.2
 163     if old[0] == '"':
 164         return old[0:-1] + new + '"'
 165     else:
 166         return '"' + old + new + '"'
 167
 168 # appends a string to a list unless it's already there
 169 def addstring(s, l):
 170     if l.count(s) > 0:
 171         return
 172     l.append(s)
 173
 174
 175 def convert(lines):
 176     " Convert to new format."
 177     re_Comment = re.compile(r'^(\s*)#')
 178     re_Counter = re.compile(r'\s*Counter\s*', re.IGNORECASE)
 179     re_Name = re.compile(r'\s*Name\s+(\S+)\s*', re.IGNORECASE)
 180     re_UseMod = re.compile(r'^\s*UseModule\s+(.*)', re.IGNORECASE)
 181     re_Empty = re.compile(r'^(\s*)$')
 182     re_Format = re.compile(r'^(\s*)(Format)(\s+)(\S+)', re.IGNORECASE)
 183     re_Preamble = re.compile(r'^(\s*)Preamble', re.IGNORECASE)
 184     re_EndPreamble = re.compile(r'^(\s*)EndPreamble', re.IGNORECASE)
 185     re_LangPreamble = re.compile(r'^(\s*)LangPreamble', re.IGNORECASE)
 186     re_EndLangPreamble = re.compile(r'^(\s*)EndLangPreamble', re.IGNORECASE)
 187     re_BabelPreamble = re.compile(r'^(\s*)BabelPreamble', re.IGNORECASE)
 188     re_EndBabelPreamble = re.compile(r'^(\s*)EndBabelPreamble', re.IGNORECASE)
 189     re_MaxCounter = re.compile(r'^(\s*)(MaxCounter)(\s+)(\S+)', re.IGNORECASE)
 190     re_LabelType = re.compile(r'^(\s*)(LabelType)(\s+)(\S+)', re.IGNORECASE)
 191     re_LabelString = re.compile(r'^(\s*)(LabelString)(\s+)(("[^"]+")|(\S+))', re.IGNORECASE)
 192     re_LabelStringAppendix = re.compile(r'^(\s*)(LabelStringAppendix)(\s+)(("[^"]+")|(\S+))', re.IGNORECASE)
 193     re_LatexType = re.compile(r'^(\s*)(LatexType)(\s+)(\S+)', re.IGNORECASE)
 194     re_Style = re.compile(r'^(\s*)(Style)(\s+)(\S+)', re.IGNORECASE)
 195     re_CopyStyle = re.compile(r'^(\s*)(CopyStyle)(\s+)(\S+)', re.IGNORECASE)
 196     re_NoStyle = re.compile(r'^(\s*)(NoStyle)(\s+)(\S+)', re.IGNORECASE)
 197     re_End = re.compile(r'^(\s*)(End)(\s*)$', re.IGNORECASE)
 198     re_Provides = re.compile(r'^(\s*)Provides(\S+)(\s+)(\S+)', re.IGNORECASE)
 199     re_CharStyle = re.compile(r'^(\s*)CharStyle(\s+)(\S+)$', re.IGNORECASE)
 200     re_AMSMaths = re.compile(r'^\s*Input ams(?:math|def)s.inc\s*')
 201     re_AMSMathsPlain = re.compile(r'^\s*Input amsmaths-plain.inc\s*')
 202     re_AMSMathsSeq = re.compile(r'^\s*Input amsmaths-seq.inc\s*')
 203     re_TocLevel = re.compile(r'^(\s*)(TocLevel)(\s+)(\S+)', re.IGNORECASE)
 204     re_I18nPreamble = re.compile(r'^(\s*)I18nPreamble', re.IGNORECASE)
 205     re_EndI18nPreamble = re.compile(r'^(\s*)EndI18nPreamble', re.IGNORECASE)
 206     re_Float = re.compile(r'^\s*Float\s*$', re.IGNORECASE)
 207     re_Type = re.compile(r'\s*Type\s+(\w+)', re.IGNORECASE)
 208     re_Builtin = re.compile(r'^(\s*)LaTeXBuiltin\s+(\w*)', re.IGNORECASE)
 209     re_True = re.compile(r'^\s*(?:true|1)\s*$', re.IGNORECASE)
 210     re_InsetLayout = re.compile(r'^\s*InsetLayout\s+(?:Custom|CharStyle|Element):(\S+)\s*$')
 211     # with quotes
 212     re_QInsetLayout = re.compile(r'^\s*InsetLayout\s+"(?:Custom|CharStyle|Element):([^"]+)"\s*$')
 213     re_InsetLayout_CopyStyle = re.compile(r'^\s*CopyStyle\s+(?:Custom|CharStyle|Element):(\S+)\s*$')
 214     re_QInsetLayout_CopyStyle = re.compile(r'^\s*CopyStyle\s+"(?:Custom|CharStyle|Element):([^"]+)"\s*$')
 215     re_NeedsFloatPkg = re.compile(r'^(\s*)NeedsFloatPkg\s+(\w+)\s*$')
 216
 217     # counters for sectioning styles (hardcoded in 1.3)
 218     counters = {"part"          : "\\Roman{part}",
 219                 "chapter"       : "\\arabic{chapter}",
 220                 "section"       : "\\arabic{section}",
 221                 "subsection"    : "\\arabic{section}.\\arabic{subsection}",
 222                 "subsubsection" : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}",
 223                 "paragraph"     : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}.\\arabic{paragraph}",
 224                 "subparagraph"  : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}.\\arabic{paragraph}.\\arabic{subparagraph}"}
 225
 226     # counters for sectioning styles in appendix (hardcoded in 1.3)
 227     appendixcounters = {"chapter"       : "\\Alph{chapter}",
 228                         "section"       : "\\Alph{section}",
 229                         "subsection"    : "\\arabic{section}.\\arabic{subsection}",
 230                         "subsubsection" : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}",
 231                         "paragraph"     : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}.\\arabic{paragraph}",
 232                         "subparagraph"  : "\\arabic{section}.\\arabic{subsection}.\\arabic{subsubsection}.\\arabic{paragraph}.\\arabic{subparagraph}"}
 233
 234     # Value of TocLevel for sectioning styles
 235     toclevels = {"part"          : 0,
 236                  "chapter"       : 0,
 237                  "section"       : 1,
 238                  "subsection"    : 2,
 239                  "subsubsection" : 3,
 240                  "paragraph"     : 4,
 241                  "subparagraph"  : 5}
 242
 243     i = 0
 244     only_comment = 1
 245     counter = ""
 246     toclevel = ""
 247     label = ""
 248     labelstring = ""
 249     labelstringappendix = ""
 250     space1 = ""
 251     labelstring_line = -1
 252     labelstringappendix_line = -1
 253     labeltype_line = -1
 254     latextype = ""
 255     latextype_line = -1
 256     style = ""
 257     maxcounter = 0
 258     format = 1
 259     formatline = 0
 260     usemodules = []
 261
 262     while i < len(lines):
 263         # Skip comments and empty lines
 264         if re_Comment.match(lines[i]) or re_Empty.match(lines[i]):
 265             i += 1
 266             continue
 267
 268         # insert file format if not already there
 269         if (only_comment):
 270             match = re_Format.match(lines[i])
 271             if match:
 272                 formatline = i
 273                 format = int(match.group(4))
 274                 if format > 1 and format < currentFormat:
 275                     lines[i] = "Format %d" % (format + 1)
 276                     only_comment = 0
 277                 elif format == currentFormat:
 278                     # nothing to do
 279                     return format
 280                 else:
 281                     error('Cannot convert file format %s' % format)
 282             else:
 283                 lines.insert(i, "Format 2")
 284                 only_comment = 0
 285                 continue
 286
 287         # Don't get confused by LaTeX code
 288         if re_Preamble.match(lines[i]):
 289             i += 1
 290             while i < len(lines) and not re_EndPreamble.match(lines[i]):
 291                 i += 1
 292             continue
 293         if re_LangPreamble.match(lines[i]):
 294             i += 1
 295             while i < len(lines) and not re_EndLangPreamble.match(lines[i]):
 296                 i += 1
 297             continue
 298         if re_BabelPreamble.match(lines[i]):
 299             i += 1
 300             while i < len(lines) and not re_EndBabelPreamble.match(lines[i]):
 301                 i += 1
 302             continue
 303
 304         if format == 32:
 305           match = re_NeedsFloatPkg.match(lines[i])
 306           if match:
 307             space = match.group(1)
 308             val = match.group(2)
 309             lines[i] = space + "UsesFloatPkg " + val
 310             newval = 'true'
 311             if val == '1' or val.lower() == 'true':
 312               newval = 'false'
 313             lines.insert(i, space + "IsPredefined " + newval)
 314             i += 1
 315           i += 1
 316           continue
 317
 318         # Only new features
 319         if format >= 29 and format <= 31:
 320           i += 1
 321           continue
 322
 323         if format == 28:
 324           match = re_InsetLayout.match(lines[i])
 325           if match:
 326             lines[i] = "InsetLayout Flex:" + match.group(1)
 327           else:
 328             match = re_QInsetLayout.match(lines[i])
 329             if match:
 330               lines[i] = "InsetLayout \"Flex:" + match.group(1) + "\""
 331             else:
 332               match = re_InsetLayout_CopyStyle.match(lines[i])
 333               if match:
 334                 lines[i] = "\tCopyStyle Flex:" + match.group(1)
 335               else:
 336                 match = re_QInsetLayout_CopyStyle.match(lines[i])
 337                 if match:
 338                   lines[i] = "\tCopyStyle \"Flex:" + match.group(1) + "\""
 339           i += 1
 340           continue
 341
 342         # Only new features
 343         if format >= 24 and format <= 27:
 344           i += 1
 345           continue
 346
 347         if format == 23:
 348           match = re_Float.match(lines[i])
 349           i += 1
 350           if not match:
 351             continue
 352           # we need to do two things:
 353           # (i)  Convert Builtin to NeedsFloatPkg
 354           # (ii) Write ListCommand lines for the builtin floats table and figure
 355           builtin = False
 356           cmd = ""
 357           while True and i < len(lines):
 358             m1 = re_End.match(lines[i])
 359             if m1:
 360               if builtin and cmd:
 361                 line = "    ListCommand " + cmd
 362                 lines.insert(i, line)
 363                 i += 1
 364               break
 365             m2 = re_Builtin.match(lines[i])
 366             if m2:
 367               builtin = True
 368               ws1 = m2.group(1)
 369               arg = m2.group(2)
 370               newarg = ""
 371               if re_True.match(arg):
 372                 newarg = "false"
 373               else:
 374                 newarg = "true"
 375               lines[i] = ws1 + "NeedsFloatPkg " + newarg
 376             m3 = re_Type.match(lines[i])
 377             if m3:
 378               fltype = m3.group(1)
 379               fltype = fltype.lower()
 380               if fltype == "table":
 381                 cmd = "listoftables"
 382               elif fltype == "figure":
 383                 cmd = "listoffigures"
 384               # else unknown, which is why we're doing this
 385             i += 1
 386           continue
 387
 388         # This just involved new features, not any changes to old ones
 389         if format >= 14 and format <= 22:
 390           i += 1
 391           continue
 392
 393         # Rename I18NPreamble to BabelPreamble
 394         if format == 13:
 395             match = re_I18nPreamble.match(lines[i])
 396             if match:
 397                 lines[i] = match.group(1) + "BabelPreamble"
 398                 i += 1
 399                 match = re_EndI18nPreamble.match(lines[i])
 400                 while i < len(lines) and not match:
 401                     i += 1
 402                     match = re_EndI18nPreamble.match(lines[i])
 403                 lines[i] = match.group(1) + "EndBabelPreamble"
 404                 i += 1
 405                 continue
 406
 407         # These just involved new features, not any changes to old ones
 408         if format == 11 or format == 12:
 409           i += 1
 410           continue
 411
 412         if format == 10:
 413             match = re_UseMod.match(lines[i])
 414             if match:
 415                 module = match.group(1)
 416                 lines[i] = "DefaultModule " + module
 417             i += 1
 418             continue
 419
 420         if format == 9:
 421             match = re_Counter.match(lines[i])
 422             if match:
 423                 counterline = i
 424                 i += 1
 425                 while i < len(lines):
 426                     namem = re_Name.match(lines[i])
 427                     if namem:
 428                         name = namem.group(1)
 429                         lines.pop(i)
 430                         lines[counterline] = "Counter %s" % name
 431                         # we don't need to increment i
 432                         continue
 433                     endem = re_End.match(lines[i])
 434                     if endem:
 435                         i += 1
 436                         break
 437                     i += 1
 438             i += 1
 439             continue
 440
 441         if format == 8:
 442             # We want to scan for ams-type includes and, if we find them,
 443             # add corresponding UseModule tags to the layout.
 444             match = re_AMSMaths.match(lines[i])
 445             if match:
 446                 addstring("theorems-ams", usemodules)
 447                 addstring("theorems-ams-extended", usemodules)
 448                 addstring("theorems-sec", usemodules)
 449                 lines.pop(i)
 450                 continue
 451             match = re_AMSMathsPlain.match(lines[i])
 452             if match:
 453                 addstring("theorems-starred", usemodules)
 454                 lines.pop(i)
 455                 continue
 456             match = re_AMSMathsSeq.match(lines[i])
 457             if match:
 458                 addstring("theorems-ams", usemodules)
 459                 addstring("theorems-ams-extended", usemodules)
 460                 lines.pop(i)
 461                 continue
 462             i += 1
 463             continue
 464
 465         # These just involved new features, not any changes to old ones
 466         if format >= 5 and format <= 7:
 467           i += 1
 468           continue
 469
 470         if format == 4:
 471             # Handle conversion to long CharStyle names
 472             match = re_CharStyle.match(lines[i])
 473             if match:
 474                 lines[i] = "InsetLayout CharStyle:%s" % (match.group(3))
 475                 i += 1
 476                 lines.insert(i, "\tLyXType charstyle")
 477                 i += 1
 478                 lines.insert(i, "")
 479                 lines[i] = "\tLabelString %s" % (match.group(3))
 480             i += 1
 481             continue
 482
 483         if format == 3:
 484             # convert 'providesamsmath x',  'providesmakeidx x',  'providesnatbib x',  'providesurl x' to
 485             #         'provides amsmath x', 'provides makeidx x', 'provides natbib x', 'provides url x'
 486             # x is either 0 or 1
 487             match = re_Provides.match(lines[i])
 488             if match:
 489                 lines[i] = "%sProvides %s%s%s" % (match.group(1), match.group(2).lower(),
 490                                                   match.group(3), match.group(4))
 491             i += 1
 492             continue
 493
 494         if format == 2:
 495             caption = []
 496
 497             # delete caption styles
 498             match = re_Style.match(lines[i])
 499             if match:
 500                 style = string.lower(match.group(4))
 501                 if style == "caption":
 502                     del lines[i]
 503                     while i < len(lines) and not re_End.match(lines[i]):
 504                         caption.append(lines[i])
 505                         del lines[i]
 506                     if i == len(lines):
 507                         error('Incomplete caption style.')
 508                     else:
 509                         del lines[i]
 510                         continue
 511
 512             # delete undefinition of caption styles
 513             match = re_NoStyle.match(lines[i])
 514             if match:
 515                 style = string.lower(match.group(4))
 516                 if style == "caption":
 517                     del lines[i]
 518                     continue
 519
 520             # replace the CopyStyle statement with the definition of the real
 521             # style. This may result in duplicate statements, but that is OK
 522             # since the second one will overwrite the first one.
 523             match = re_CopyStyle.match(lines[i])
 524             if match:
 525                 style = string.lower(match.group(4))
 526                 if style == "caption":
 527                     if len(caption) > 0:
 528                         lines[i:i+1] = caption
 529                     else:
 530                         # FIXME: This style comes from an include file, we
 531                         # should replace the real style and not this default.
 532                         lines[i:i+1] = ['       Margin                First_Dynamic',
 533                                         '       LatexType             Command',
 534                                         '       LatexName             caption',
 535                                         '       NeedProtect           1',
 536                                         '       LabelSep              xx',
 537                                         '       ParSkip               0.4',
 538                                         '       TopSep                0.5',
 539                                         '       Align                 Center',
 540                                         '       AlignPossible         Center',
 541                                         '       LabelType             Sensitive',
 542                                         '       LabelString           "Senseless!"',
 543                                         '       OptionalArgs          1',
 544                                         '       LabelFont',
 545                                         '         Series              Bold',
 546                                         '       EndFont']
 547
 548             i += 1
 549             continue
 550
 551         # Delete MaxCounter and remember the value of it
 552         match = re_MaxCounter.match(lines[i])
 553         if match:
 554             level = match.group(4)
 555             if string.lower(level) == "counter_chapter":
 556                 maxcounter = 0
 557             elif string.lower(level) == "counter_section":
 558                 maxcounter = 1
 559             elif string.lower(level) == "counter_subsection":
 560                 maxcounter = 2
 561             elif string.lower(level) == "counter_subsubsection":
 562                 maxcounter = 3
 563             elif string.lower(level) == "counter_paragraph":
 564                 maxcounter = 4
 565             elif string.lower(level) == "counter_subparagraph":
 566                 maxcounter = 5
 567             elif string.lower(level) == "counter_enumi":
 568                 maxcounter = 6
 569             elif string.lower(level) == "counter_enumii":
 570                 maxcounter = 7
 571             elif string.lower(level) == "counter_enumiii":
 572                 maxcounter = 8
 573             del lines[i]
 574             continue
 575
 576         # Replace line
 577         #
 578         # LabelType Counter_EnumI
 579         #
 580         # with two lines
 581         #
 582         # LabelType Counter
 583         # LabelCounter EnumI
 584         #
 585         match = re_LabelType.match(lines[i])
 586         if match:
 587             label = match.group(4)
 588             # Remember indenting space for later reuse in added lines
 589             space1 = match.group(1)
 590             # Remember the line for adding the LabelCounter later.
 591             # We can't do it here because it could shift latextype_line etc.
 592             labeltype_line = i
 593             if string.lower(label[:8]) == "counter_":
 594                 counter = string.lower(label[8:])
 595                 lines[i] = re_LabelType.sub(r'\1\2\3Counter', lines[i])
 596
 597         # Remember the LabelString line
 598         match = re_LabelString.match(lines[i])
 599         if match:
 600             labelstring = match.group(4)
 601             labelstring_line = i
 602
 603         # Remember the LabelStringAppendix line
 604         match = re_LabelStringAppendix.match(lines[i])
 605         if match:
 606             labelstringappendix = match.group(4)
 607             labelstringappendix_line = i
 608
 609         # Remember the LatexType line
 610         match = re_LatexType.match(lines[i])
 611         if match:
 612             latextype = string.lower(match.group(4))
 613             latextype_line = i
 614
 615         # Remember the TocLevel line
 616         match = re_TocLevel.match(lines[i])
 617         if match:
 618             toclevel = string.lower(match.group(4))
 619
 620         # Reset variables at the beginning of a style definition
 621         match = re_Style.match(lines[i])
 622         if match:
 623             style = string.lower(match.group(4))
 624             counter = ""
 625             toclevel = ""
 626             label = ""
 627             space1 = ""
 628             labelstring = ""
 629             labelstringappendix = ""
 630             labelstring_line = -1
 631             labelstringappendix_line = -1
 632             labeltype_line = -1
 633             latextype = ""
 634             latextype_line = -1
 635
 636         if re_End.match(lines[i]):
 637
 638             # Add a line "LatexType Bib_Environment" if LabelType is Bibliography
 639             # (or change the existing LatexType)
 640             if string.lower(label) == "bibliography":
 641                 if (latextype_line < 0):
 642                     lines.insert(i, "%sLatexType Bib_Environment" % space1)
 643                     i += 1
 644                 else:
 645                     lines[latextype_line] = re_LatexType.sub(r'\1\2\3Bib_Environment', lines[latextype_line])
 646
 647             # Change "LabelType Static" to "LabelType Itemize" for itemize environments
 648             if latextype == "item_environment" and string.lower(label) == "static":
 649                 lines[labeltype_line] = re_LabelType.sub(r'\1\2\3Itemize', lines[labeltype_line])
 650
 651             # Change "LabelType Counter_EnumI" to "LabelType Enumerate" for enumerate environments
 652             if latextype == "item_environment" and string.lower(label) == "counter_enumi":
 653                 lines[labeltype_line] = re_LabelType.sub(r'\1\2\3Enumerate', lines[labeltype_line])
 654                 # Don't add the LabelCounter line later
 655                 counter = ""
 656
 657             # Replace
 658             #
 659             # LabelString "Chapter"
 660             #
 661             # with
 662             #
 663             # LabelString "Chapter \arabic{chapter}"
 664             #
 665             # if this style has a counter. Ditto for LabelStringAppendix.
 666             # This emulates the hardcoded article style numbering of 1.3
 667             #
 668             if counter != "":
 669                 if style in counters:
 670                     if labelstring_line < 0:
 671                         lines.insert(i, '%sLabelString "%s"' % (space1, counters[style]))
 672                         i += 1
 673                     else:
 674                         new_labelstring = concatenate_label(labelstring, counters[style])
 675                         lines[labelstring_line] = re_LabelString.sub(
 676                                 r'\1\2\3%s' % new_labelstring.replace("\\", "\\\\"),
 677                                 lines[labelstring_line])
 678                 if style in appendixcounters:
 679                     if labelstringappendix_line < 0:
 680                         lines.insert(i, '%sLabelStringAppendix "%s"' % (space1, appendixcounters[style]))
 681                         i += 1
 682                     else:
 683                         new_labelstring = concatenate_label(labelstring, appendixcounters[style])
 684                         lines[labelstringappendix_line] = re_LabelStringAppendix.sub(
 685                                 r'\1\2\3%s' % new_labelstring.replace("\\", "\\\\"),
 686                                 lines[labelstringappendix_line])
 687
 688                 # Now we can safely add the LabelCounter line
 689                 lines.insert(labeltype_line + 1, "%sLabelCounter %s" % (space1, counter))
 690                 i += 1
 691
 692             # Add the TocLevel setting for sectioning styles
 693             if toclevel == "" and style in toclevels and maxcounter <= toclevels[style]:
 694                 lines.insert(i, '%s\tTocLevel %d' % (space1, toclevels[style]))
 695                 i += 1
 696
 697         i += 1
 698
 699     if usemodules:
 700         i = formatline + 1
 701         for mod in usemodules:
 702             lines.insert(i, "UseModule " + mod)
 703             i += 1
 704
 705     return format + 1
 706
 707
 708 def main(argv):
 709
 710     # Open files
 711     if len(argv) == 1:
 712         source = sys.stdin
 713         output = sys.stdout
 714     elif len(argv) == 3:
 715         source = open(argv[1], 'rb')
 716         output = open(argv[2], 'wb')
 717     else:
 718         error(usage(argv[0]))
 719
 720     # Do the real work
 721     lines = read(source)
 722     format = 1
 723     while (format < currentFormat):
 724         format = convert(lines)
 725     write(output, lines)
 726
 727     # Close files
 728     if len(argv) == 3:
 729         source.close()
 730         output.close()
 731
 732     return 0
 733
 734
 735 if __name__ == "__main__":
 736     main(sys.argv)