PageRenderTime 37ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 1ms

/old/txt2tags-2.3.py

http://txt2tags.googlecode.com/
Python | 4622 lines | 4158 code | 173 blank | 291 comment | 176 complexity | fc3d524e614abd0cb77e8397f28b69ff MD5 | raw file
Possible License(s): GPL-2.0, GPL-3.0, WTFPL 
    

  1. #!/usr/bin/env python
    2. 

  2. # txt2tags - generic text conversion tool
    3. 

  3. # http://txt2tags.sf.net
    4. 

  4. #
    5. 

  5. # Copyright 2001, 2002, 2003, 2004, 2005 Aurelio Marinho Jargas
    6. 

  6. #
    7. 

  7. #   This program is free software; you can redistribute it and/or modify
    8. 

  8. #   it under the terms of the GNU General Public License as published by
    9. 

  9. #   the Free Software Foundation, version 2.
    10. 

  10. #
    11. 

  11. #   This program is distributed in the hope that it will be useful,
    12. 

  12. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    14. 

  14. #   GNU General Public License for more details.
    15. 

  15. #
    16. 

  16. #   You have received a copy of the GNU General Public License along
    17. 

  17. #   with this program, on the COPYING file.
    18. 

  18. #
    19. 

  19. #
    20. 

  20. #
    21. 

  21. #   +-------------------------------------------------------------+
    22. 

  22. #   |               IMPORTANT MESSAGES, PLEASE READ               |
    23. 

  23. #   +-------------------------------------------------------------+
    24. 

  24. #   |                                                             |
    25. 

  25. #   |                                                             |
    26. 

  26. #   |                     v1.x COMPATIBILITY                      |
    27. 

  27. #   |                     ------------------                      |
    28. 

  28. #   |                                                             |
    29. 

  29. #   |      Due the major syntax changes, the new 2.x series       |
    30. 

  30. #   |      BREAKS backwards compatibility.                        |
    31. 

  31. #   |                                                             |
    32. 

  32. #   |      Use the 't2tconv' script to upgrade your existing      |
    33. 

  33. #   |      v1.x files to conform the new v2.x syntax.             |
    34. 

  34. #   |                                                             |
    35. 

  35. #   |      Do a visual inspection on the new converted file.      |
    36. 

  36. #   |      Specially Pre & Post proc filters can break.           |
    37. 

  37. #   |      Check them!                                            |
    38. 

  38. #   |                                                             |
    39. 

  39. #   |                                                             |
    40. 

  40. #   +-------------------------------------------------------------+
    41. 

  41. #
    42. 

  42. #
    43. 

  43. ########################################################################
    44. 

  44. #
    45. 

  45. #   BORING CODE EXPLANATION AHEAD
    46. 

  46. #
    47. 

  47. # Just read if you wish to understand how the txt2tags code works
    48. 

  48. #
    49. 

  49. ########################################################################
    50. 

  50. #
    51. 

  51. # Version 2.0 was a complete rewrite for the program 'core'.
    52. 

  52. #
    53. 

  53. # Now the code that [1] parses the marked text is separated from the
    54. 

  54. # code that [2] insert the target tags.
    55. 

  55. #
    56. 

  56. #   [1] made by: def convert()
    57. 

  57. #   [2] made by: class BlockMaster
    58. 

  58. #
    59. 

  59. # The structures of the marked text are identifyed and its contents are
    60. 

  60. # extracted into a data holder (Python lists and dictionaries).
    61. 

  61. #
    62. 

  62. # When parsing the source file, the blocks (para, lists, quote, table)
    63. 

  63. # are opened with BlockMaster, right when found. Then its contents,
    64. 

  64. # which spans on several lines, are feeded into a special holder on the
    65. 

  65. # BlockMaster instance. Just when the block is closed, the target tags
    66. 

  66. # are inserted for the full block as a whole, in one pass. This way, we
    67. 

  67. # have a better control on blocks. Much better than the previous line by
    68. 

  68. # line approach.
    69. 

  69. #
    70. 

  70. # In other words, whenever inside a block, the parser *holds* the tag
    71. 

  71. # insertion process, waiting until the full block is readed. That was
    72. 

  72. # needed primary to close paragraphs for the new XHTML target, but
    73. 

  73. # proved to be a very good adding, improving many other processings.
    74. 

  74. #
    75. 

  75. # -------------------------------------------------------------------
    76. 

  76. #
    77. 

  77. # There is also a brand new code for the Configuration schema, 100%
    78. 

  78. # rewritten. There are new classes, all self documented: CommandLine,
    79. 

  79. # SourceDocument, ConfigMaster and ConfigLines. In short, a new RAW
    80. 

  80. # Config format was created, and all kind of configuration is first
    81. 

  81. # converted to this format, and then a generic method parses it.
    82. 

  82. #
    83. 

  83. # The init processing was changed also, and now the functions which
    84. 

  84. # gets informations about the input files are: get_infiles_config(),
    85. 

  85. #  process_source_file() and convert_this_files()
    86. 

  86. #
    87. 

  87. # Other parts are untouched, and remains the same as in v1.7, as the
    88. 

  88. # marks regexes, target Headers and target Tags&Rules.
    89. 

  89. #
    90. 

  90. ########################################################################
    91. 

  91. 

  92. # Now I think the code is nice, easier to read and understand
    93. 

  93. 

  94. #XXX Python coding warning
    95. 

  95. # Avoid common mistakes:
    96. 

  96. # - do NOT use newlist=list instead newlist=list[:]
    97. 

  97. # - do NOT use newdic=dic   instead newdic=dic.copy()
    98. 

  98. # - do NOT use dic[key]     instead dic.get(key)
    99. 

  99. # - do NOT use del dic[key] without has_key() before
    100. 

  100. 

  101. #XXX Smart Image Align don't work if the image is a link
    102. 

  102. # Can't fix that because the image is expanded together with the
    103. 

  103. # link, at the linkbank filling moment. Only the image is passed
    104. 

  104. # to parse_images(), not the full line, so it is always 'middle'.
    105. 

  105. 

  106. #XXX Paragraph separation not valid inside Quote
    107. 

  107. # Quote will not have <p></p> inside, instead will close and open
    108. 

  108. # again the <blockquote>. This really sux in CSS, when defining a
    109. 

  109. # diferent background color. Still don't know how to fix it.
    110. 

    111. 

  111. #XXX TODO (maybe)
    112. 

  112. # New mark or macro which expands to an anchor full title.
    113. 

  113. # It is necessary to parse the full document in this order:
    114. 

  114. #  DONE  1st scan: HEAD: get all settings, including %!includeconf
    115. 

  115. #  DONE  2nd scan: BODY: expand includes & apply %!preproc
    116. 

  116. #        3rd scan: BODY: read titles and compose TOC info
    117. 

  117. #        4th scan: BODY: full parsing, expanding [#anchor] 1st
    118. 

  118. # Steps 2 and 3 can be made together, with no tag adding.
    119. 

  119. # Two complete body scans will be *slow*, don't know if it worths.
    120. 

  120. # One solution may be add the titles as postproc rules
    121. 

  121. 

  122. 

  123. ##############################################################################
    124. 

  124. 

  125. # User config (1=ON, 0=OFF)
    126. 

  126. 

  127. USE_I18N    = 1   # use gettext for i18ned messages?        (default is 1)
    128. 

  128. COLOR_DEBUG = 1   # show debug messages in colors?          (default is 1)
    129. 

  129. BG_LIGHT    = 0   # your terminal background color is light (default is 0)
    130. 

  130. HTML_LOWER  = 0   # use lowercased HTML tags instead upper? (default is 0)
    131. 

  131. 

  132. ##############################################################################
    133. 

  133. 

  134. 

  135. # these are all the core Python modules used by txt2tags (KISS!)
    136. 

  136. import re, string, os, sys, time, getopt
    137. 

  137. 

  138. # program information
    139. 

  139. my_url = 'http://txt2tags.sf.net'
    140. 

  140. my_name = 'txt2tags'
    141. 

  141. my_email = 'verde@aurelio.net'
    142. 

  142. my_version = '2.3'
    143. 

  143. 

  144. # i18n - just use if available
    145. 

  145. if USE_I18N:
    146. 

  146. 	try:
    147. 

  147. 		import gettext
    148. 

  148. 		# if your locale dir is different, change it here
    149. 

  149. 		cat = gettext.Catalog('txt2tags',localedir='/usr/share/locale/')
    150. 

  150. 		_ = cat.gettext
    151. 

  151. 	except:
    152. 

  152. 		_ = lambda x:x
    153. 

  153. else:
    154. 

  154. 	_ = lambda x:x
    155. 

  155. 

  156. # FLAGS   : the conversion related flags  , may be used in %!options
    157. 

  157. # OPTIONS : the conversion related options, may be used in %!options
    158. 

  158. # ACTIONS : the other behaviour modifiers, valid on command line only
    159. 

  159. # MACROS  : the valid macros with their default values for formatting
    160. 

  160. # SETTINGS: global miscelaneous settings, valid on RC file only
    161. 

  161. # NO_TARGET: actions that don't require a target specification
    162. 

  162. # NO_MULTI_INPUT: actions that don't accept more than one input file
    163. 

  163. # CONFIG_KEYWORDS: the valid %!key:val keywords
    164. 

  164. #
    165. 

  165. # FLAGS and OPTIONS are configs that affect the converted document.
    166. 

  166. # They usually have also a --no-<option> to turn them OFF.
    167. 

  167. # ACTIONS are needed because when doing multiple input files, strange
    168. 

  168. # behaviour would be found, as use command line interface for the
    169. 

  169. # first file and gui for the second. There is no --no-<action>.
    170. 

  170. # --version and --help inside %!options are also odd
    171. 

  171. #
    172. 

  172. TARGETS  = ['html', 'xhtml', 'sgml', 'tex', 'lout', 'man', 'mgp',
    173. 

  173.             'moin', 'pm6'  , 'txt']
    174. 

  174. FLAGS    = {'headers'    :1 , 'enum-title' :0 , 'mask-email' :0 ,
    175. 

  175.             'toc-only'   :0 , 'toc'        :0 , 'rc'         :1 ,
    176. 

  176.             'css-sugar'  :0 , 'css-suggar' :0 , 'css-inside' :0 ,
    177. 

  177.             'quiet'      :0 }
    178. 

  178. OPTIONS  = {'target'     :'', 'toc-level'  :3 , 'style'      :'',
    179. 

  179.             'infile'     :'', 'outfile'    :'', 'encoding'   :'',
    180. 

  180.             'config-file':'', 'split'      :0 , 'lang'       :''} 
    181. 

  181. ACTIONS  = {'help'       :0 , 'version'    :0 , 'gui'        :0 ,
    182. 

  182.             'verbose'    :0 , 'debug'      :0 , 'dump-config':0 ,
    183. 

  183.             'dump-source':0 }
    184. 

  184. MACROS   = {'date' : '%Y%m%d',  'infile': '%f',
    185. 

  185.             'mtime': '%Y%m%d', 'outfile': '%f'}
    186. 

  186. SETTINGS = {}         # for future use
    187. 

  187. NO_TARGET = ['help', 'version', 'gui', 'toc-only', 'dump-config', 'dump-source']
    188. 

  188. NO_MULTI_INPUT = ['gui','dump-config','dump-source']
    189. 

  189. CONFIG_KEYWORDS = [
    190. 

  190.             'target', 'encoding', 'style', 'options', 'preproc','postproc',
    191. 

  191.             'guicolors']
    192. 

  192. TARGET_NAMES = {
    193. 

  193.   'html' : _('HTML page'),
    194. 

  194.   'xhtml': _('XHTML page'),
    195. 

  195.   'sgml' : _('SGML document'),
    196. 

  196.   'tex'  : _('LaTeX document'),
    197. 

  197.   'lout' : _('Lout document'),
    198. 

  198.   'man'  : _('UNIX Manual page'),
    199. 

  199.   'mgp'  : _('Magic Point presentation'),
    200. 

  200.   'moin' : _('MoinMoin page'),
    201. 

  201.   'pm6'  : _('PageMaker 6.0 document'),
    202. 

  202.   'txt'  : _('Plain Text'),
    203. 

  203. }
    204. 

  204. 

  205. DEBUG = 0     # do not edit here, please use --debug
    206. 

  206. VERBOSE = 0   # do not edit here, please use -v, -vv or -vvv
    207. 

  207. QUIET = 0     # do not edit here, please use --quiet
    208. 

  208. GUI = 0       # do not edit here, please use --gui
    209. 

  209. AUTOTOC = 1   # do not edit here, please use --no-toc or %%toc
    210. 

  210. 

  211. RC_RAW = []
    212. 

  212. CMDLINE_RAW = []
    213. 

  213. CONF = {}
    214. 

  214. BLOCK = None
    215. 

  215. regex = {}
    216. 

  216. TAGS = {}
    217. 

  217. rules = {}
    218. 

  218. 

  219. lang = 'english'
    220. 

  220. TARGET = ''
    221. 

  221. 

  222. STDIN = STDOUT = '-'
    223. 

  223. MODULEIN = MODULEOUT = '-module-'
    224. 

  224. ESCCHAR   = '\x00'
    225. 

  225. SEPARATOR = '\x01'
    226. 

  226. LISTNAMES = {'-':'list', '+':'numlist', ':':'deflist'}
    227. 

  227. LINEBREAK = {'default':'\n', 'win':'\r\n', 'mac':'\r'}
    228. 

  228. 

  229. # plataform specific settings
    230. 

  230. LB = LINEBREAK.get(sys.platform[:3]) or LINEBREAK['default']
    231. 

  231. 

  232. # identify a development version
    233. 

  233. #dev_suffix = '-dev'+time.strftime('%m%d',time.localtime(time.time()))
    234. 

  234. #my_version = my_version + dev_suffix
    235. 

  235. 

  236. VERSIONSTR = _("%s version %s <%s>")%(my_name,my_version,my_url)
    237. 

  237. 

  238. USAGE = string.join([
    239. 

  239. '',
    240. 

  240. _("Usage: %s [OPTIONS] [infile.t2t ...]") % my_name,
    241. 

  241. '',
    242. 

  242. _("  -t, --target=TYPE   set target document type. currently supported:"),
    243. 

  243. '                      %s' % re.sub(r"[]'[]",'',repr(TARGETS)),
    244. 

  244. _("  -i, --infile=FILE   set FILE as the input file name ('-' for STDIN)"),
    245. 

  245. _("  -o, --outfile=FILE  set FILE as the output file name ('-' for STDOUT)"),
    246. 

  246. _("  -n, --enum-title    enumerate all title lines as 1, 1.1, 1.1.1, etc"),
    247. 

  247. _("  -H, --no-headers    suppress header, title and footer contents"),
    248. 

  248. _("      --headers       show header, title and footer contents (default ON)"),
    249. 

  249. _("      --encoding=ENC  set target file encoding (utf-8, iso-8859-1, etc)"),
    250. 

  250. _("      --style=FILE    use FILE as the document style (like HTML CSS)"),
    251. 

  251. _("      --css-sugar     insert CSS-friendly tags for HTML and XHTML targets"),
    252. 

  252. _("      --css-inside    insert CSS file contents inside HTML/XHTML headers"),
    253. 

  253. _("      --mask-email    hide email from spam robots. x@y.z turns <x (a) y z>"),
    254. 

  254. _("      --toc           add TOC (Table of Contents) to target document"),
    255. 

  255. _("      --toc-only      print document TOC and exit"),
    256. 

  256. _("      --toc-level=N   set maximum TOC level (depth) to N"),
    257. 

  257. _("  -C, --config-file=F read config from file F"),
    258. 

  258. _("      --rc            read user config file ~/.txt2tagsrc (default ON)"),
    259. 

  259. _("      --gui           invoke Graphical Tk Interface"),
    260. 

  260. _("  -q, --quiet         quiet mode, suppress all output (except errors)"),
    261. 

  261. _("  -v, --verbose       print informative messages during conversion"),
    262. 

  262. _("  -h, --help          print this help information and exit"),
    263. 

  263. _("  -V, --version       print program version and exit"),
    264. 

  264. _("      --dump-config   print all the config found and exit"),
    265. 

  265. _("      --dump-source   print the document source, with includes expanded"),
    266. 

  266. '',
    267. 

  267. _("Turn OFF options:"),
    268. 

  268. "     --no-outfile, --no-infile, --no-style, --no-encoding, --no-headers",
    269. 

  269. "     --no-toc, --no-toc-only, --no-mask-email, --no-enum-title, --no-rc",
    270. 

  270. "     --no-css-sugar, --no-css-inside, --no-quiet, --no-dump-config",
    271. 

  271. "     --no-dump-source",
    272. 

  272. '',
    273. 

  273. _("Example:\n     %s -t html --toc myfile.t2t") % my_name,
    274. 

  274. '',
    275. 

  275. _("By default, converted output is saved to 'infile.<target>'."),
    276. 

  276. _("Use --outfile to force an output file name."),
    277. 

  277. _("If  input file is '-', reads from STDIN."),
    278. 

  278. _("If output file is '-', dumps output to STDOUT."),
    279. 

  279. ''
    280. 

  280. ], '\n')
    281. 

  281. 

  282. 

  283. ##############################################################################
    284. 

  284. 

  285. 

  286. # here is all the target's templates
    287. 

  287. # you may edit them to fit your needs
    288. 

  288. #  - the %(HEADERn)s strings represent the Header lines
    289. 

  289. #  - the %(STYLE)s string is changed by --style contents
    290. 

  290. #  - the %(ENCODING)s string is changed by --encoding contents
    291. 

  291. #  - if any of the above is empty, the full line is removed
    292. 

  292. #  - use %% to represent a literal %
    293. 

  293. #
    294. 

  294. HEADER_TEMPLATE = {
    295. 

  295.   'txt': """\
    296. 

  296. %(HEADER1)s
    297. 

  297. %(HEADER2)s
    298. 

  298. %(HEADER3)s
    299. 

  299. """,
    300. 

    301. 

  301.   'sgml': """\
    302. 

  302. <!doctype linuxdoc system>
    303. 

  303. <article>
    304. 

  304. <title>%(HEADER1)s
    305. 

  305. <author>%(HEADER2)s
    306. 

  306. <date>%(HEADER3)s
    307. 

  307. """,
    308. 

    309. 

  309.   'html': """\
    310. 

  310. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    311. 

  311. <HTML>
    312. 

  312. <HEAD>
    313. 

  313. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    314. 

  314. <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=%(ENCODING)s">
    315. 

  315. <LINK REL="stylesheet" TYPE="text/css" HREF="%(STYLE)s">
    316. 

  316. <TITLE>%(HEADER1)s</TITLE>
    317. 

  317. </HEAD><BODY BGCOLOR="white" TEXT="black">
    318. 

  318. <P ALIGN="center"><CENTER><H1>%(HEADER1)s</H1>
    319. 

  319. <FONT SIZE="4">
    320. 

  320. <I>%(HEADER2)s</I><BR>
    321. 

  321. %(HEADER3)s
    322. 

  322. </FONT></CENTER>
    323. 

  323. """,
    324. 

    325. 

  325.   'htmlcss': """\
    326. 

  326. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    327. 

  327. <HTML>
    328. 

  328. <HEAD>
    329. 

  329. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    330. 

  330. <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=%(ENCODING)s">
    331. 

  331. <LINK REL="stylesheet" TYPE="text/css" HREF="%(STYLE)s">
    332. 

  332. <TITLE>%(HEADER1)s</TITLE>
    333. 

  333. </HEAD>
    334. 

  334. <BODY>
    335. 

  335. 

  336. <DIV CLASS="header" ID="header">
    337. 

  337. <H1>%(HEADER1)s</H1>
    338. 

  338. <H2>%(HEADER2)s</H2>
    339. 

  339. <H3>%(HEADER3)s</H3>
    340. 

  340. </DIV>
    341. 

  341. """,
    342. 

    343. 

  343.   'xhtml': """\
    344. 

  344. <?xml version="1.0"
    345. 

  345.       encoding="%(ENCODING)s"
    346. 

  346. ?>
    347. 

  347. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"\
    348. 

  348.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    349. 

  349. <html xmlns="http://www.w3.org/1999/xhtml">
    350. 

  350. <head>
    351. 

  351. <title>%(HEADER1)s</title>
    352. 

  352. <meta name="generator" content="http://txt2tags.sf.net" />
    353. 

  353. <link rel="stylesheet" type="text/css" href="%(STYLE)s" />
    354. 

  354. </head>
    355. 

  355. <body bgcolor="white" text="black">
    356. 

  356. <div align="center">
    357. 

  357. <h1>%(HEADER1)s</h1>
    358. 

  358. <h2>%(HEADER2)s</h2>
    359. 

  359. <h3>%(HEADER3)s</h3>
    360. 

  360. </div>
    361. 

  361. """,
    362. 

    363. 

  363.   'xhtmlcss': """\
    364. 

  364. <?xml version="1.0"?>
    365. 

  365. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"\
    366. 

  366.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    367. 

  367. <html xmlns="http://www.w3.org/1999/xhtml">
    368. 

  368. <head>
    369. 

  369. <title>%(HEADER1)s</title>
    370. 

  370. <meta name="generator" content="http://txt2tags.sf.net" />
    371. 

  371. <meta http-equiv="Content-Type" content="text/html; charset=%(ENCODING)s" />
    372. 

  372. <link rel="stylesheet" type="text/css" href="%(STYLE)s" />
    373. 

  373. </head>
    374. 

  374. <body>
    375. 

  375. 

  376. <div class="header" id="header">
    377. 

  377. <h1>%(HEADER1)s</h1>
    378. 

  378. <h2>%(HEADER2)s</h2>
    379. 

  379. <h3>%(HEADER3)s</h3>
    380. 

  380. </div>
    381. 

  381. """,
    382. 

    383. 

  383.   'man': """\
    384. 

  384. .TH "%(HEADER1)s" 1 "%(HEADER3)s" "%(HEADER2)s"
    385. 

  385. """,
    386. 

    387. 

  387. # TODO style to <HR>
    388. 

  388.   'pm6': """\
    389. 

  389. <PMTags1.0 win><C-COLORTABLE ("Preto" 1 0 0 0)
    390. 

  390. ><@Normal=
    391. 

  391.   <FONT "Times New Roman"><CCOLOR "Preto"><SIZE 11>
    392. 

  392.   <HORIZONTAL 100><LETTERSPACE 0><CTRACK 127><CSSIZE 70><C+SIZE 58.3>
    393. 

  393.   <C-POSITION 33.3><C+POSITION 33.3><P><CBASELINE 0><CNOBREAK 0><CLEADING -0.05>
    394. 

  394.   <GGRID 0><GLEFT 7.2><GRIGHT 0><GFIRST 0><G+BEFORE 7.2><G+AFTER 0>
    395. 

  395.   <GALIGNMENT "justify"><GMETHOD "proportional"><G& "ENGLISH">
    396. 

  396.   <GPAIRS 12><G%% 120><GKNEXT 0><GKWIDOW 0><GKORPHAN 0><GTABS $>
    397. 

  397.   <GHYPHENATION 2 34 0><GWORDSPACE 75 100 150><GSPACE -5 0 25>
    398. 

  398. ><@Bullet=<@-PARENT "Normal"><FONT "Abadi MT Condensed Light">
    399. 

  399.   <GLEFT 14.4><G+BEFORE 2.15><G%% 110><GTABS(25.2 l "")>
    400. 

  400. ><@PreFormat=<@-PARENT "Normal"><FONT "Lucida Console"><SIZE 8><CTRACK 0>
    401. 

  401.   <GLEFT 0><G+BEFORE 0><GALIGNMENT "left"><GWORDSPACE 100 100 100><GSPACE 0 0 0>
    402. 

  402. ><@Title1=<@-PARENT "Normal"><FONT "Arial"><SIZE 14><B>
    403. 

  403.   <GCONTENTS><GLEFT 0><G+BEFORE 0><GALIGNMENT "left">
    404. 

  404. ><@Title2=<@-PARENT "Title1"><SIZE 12><G+BEFORE 3.6>
    405. 

  405. ><@Title3=<@-PARENT "Title1"><SIZE 10><GLEFT 7.2><G+BEFORE 7.2>
    406. 

  406. ><@Title4=<@-PARENT "Title3">
    407. 

  407. ><@Title5=<@-PARENT "Title3">
    408. 

  408. ><@Quote=<@-PARENT "Normal"><SIZE 10><I>>
    409. 

  409. 

  410. %(HEADER1)s
    411. 

  411. %(HEADER2)s
    412. 

  412. %(HEADER3)s
    413. 

  413. """,
    414. 

    415. 

  415.   'mgp': """\
    416. 

  416. #!/usr/X11R6/bin/mgp -t 90
    417. 

  417. %%deffont "normal"    xfont  "utopia-medium-r", charset "iso8859-1"
    418. 

  418. %%deffont "normal-i"  xfont  "utopia-medium-i", charset "iso8859-1"
    419. 

  419. %%deffont "normal-b"  xfont  "utopia-bold-r"  , charset "iso8859-1"
    420. 

  420. %%deffont "normal-bi" xfont  "utopia-bold-i"  , charset "iso8859-1"
    421. 

  421. %%deffont "mono"      xfont "courier-medium-r", charset "iso8859-1"
    422. 

  422. %%default 1 size 5
    423. 

  423. %%default 2 size 8, fore "yellow", font "normal-b", center
    424. 

  424. %%default 3 size 5, fore "white",  font "normal", left, prefix "  "
    425. 

  425. %%tab 1 size 4, vgap 30, prefix "     ", icon arc "red" 40, leftfill
    426. 

  426. %%tab 2 prefix "            ", icon arc "orange" 40, leftfill
    427. 

  427. %%tab 3 prefix "                   ", icon arc "brown" 40, leftfill
    428. 

  428. %%tab 4 prefix "                          ", icon arc "darkmagenta" 40, leftfill
    429. 

  429. %%tab 5 prefix "                                ", icon arc "magenta" 40, leftfill
    430. 

  430. %%%%------------------------- end of headers -----------------------------
    431. 

  431. %%page
    432. 

  432. 

  433. 

  434. 

  435. 

  436. 

  437. %%size 10, center, fore "yellow"
    438. 

  438. %(HEADER1)s
    439. 

  439. 

  440. %%font "normal-i", size 6, fore "white", center
    441. 

  441. %(HEADER2)s
    442. 

  442. 

  443. %%font "mono", size 7, center
    444. 

  444. %(HEADER3)s
    445. 

  445. """,
    446. 

    447. 

  447.   'moin': """\
    448. 

  448. '''%(HEADER1)s'''
    449. 

  449. 

  450. ''%(HEADER2)s''
    451. 

  451. 

  452. %(HEADER3)s
    453. 

  453. """,
    454. 

    455. 

  455.   'tex': \
    456. 

  456. r"""\documentclass[11pt,a4paper]{article}
    457. 

  457. \usepackage{amsfonts,graphicx}
    458. 

  458. \usepackage[pdfstartview=FitH,urlcolor=blue,colorlinks=true,bookmarks=true]{hyperref}
    459. 

  459. \usepackage[%(ENCODING)s]{inputenc}  %% char encoding
    460. 

  460. \usepackage{%(STYLE)s}  %% user defined package
    461. 

  461. \pagestyle{plain}   %% do page numbering ('empty' turns off)
    462. 

  462. \frenchspacing      %% no aditional spaces after periods
    463. 

  463. \setlength{\parskip}{8pt}\parindent=0pt  %% no paragraph indentation
    464. 

  464. 

  465. \title{%(HEADER1)s}
    466. 

  466. \author{%(HEADER2)s}
    467. 

  467. \begin{document}
    468. 

  468. \date{%(HEADER3)s}
    469. 

  469. \maketitle
    470. 

  470. \clearpage
    471. 

  471. """,
    472. 

    473. 

  473.   'lout': """\
    474. 

  474. @SysInclude { doc }
    475. 

  475. @Document
    476. 

  476.   @InitialFont { Times Base 12p }	# Times, Courier, Helvetica, ...
    477. 

  477.   @PageOrientation { Portrait }		# Portrait, Landscape
    478. 

  478.   @ColumnNumber { 1 }			# Number of columns (2, 3, ...)
    479. 

  479.   @PageHeaders { Simple }		# None, Simple, Titles, NoTitles
    480. 

  480.   @InitialLanguage { English }		# German, French, Portuguese, ...
    481. 

  481.   @OptimizePages { Yes }                # Yes/No smart page break feature
    482. 

  482. //
    483. 

  483. @Text @Begin
    484. 

  484. @Display @Heading { %(HEADER1)s }
    485. 

  485. @Display @I { %(HEADER2)s }
    486. 

  486. @Display { %(HEADER3)s }
    487. 

  487. #@NP                                    # Break page after Headers
    488. 

  488. """
    489. 

  489. # @SysInclude { tbl }			# Tables support
    490. 

  490. # setup: @MakeContents { Yes }          # show TOC
    491. 

  491. # setup: @SectionGap                    # break page at each section
    492. 

  492. }
    493. 

  493. 

  494. 

  495. ##############################################################################
    496. 

  496. 

  497. 

  498. def getTags(config):
    499. 

  499. 	"Returns all the known tags for the specified target"
    500. 

  500. 	
    501. 

  501. 	keys = [
    502. 

  502. 	'paragraphOpen','paragraphClose',
    503. 

  503. 	'title1','title2','title3','title4','title5',
    504. 

  504. 	'title1Open','title1Close','title2Open','title2Close',
    505. 

  505. 	'blocktitle1Open','title1Close','title2Open','title2Close',
    506. 

  506. 	'title3Open','title3Close','title4Open','title4Close',
    507. 

  507. 	'title5Open','title5Close',
    508. 

  508. 	'numtitle1','numtitle2','numtitle3','numtitle4','numtitle5',
    509. 

  509. 	'blockVerbOpen','blockVerbClose',
    510. 

  510. 	'blockQuoteOpen','blockQuoteClose','blockQuoteLine',
    511. 

  511. 	'fontMonoOpen','fontMonoClose',
    512. 

  512. 	'fontBoldOpen','fontBoldClose',
    513. 

  513. 	'fontItalicOpen','fontItalicClose',
    514. 

  514. 	'fontUnderlineOpen','fontUnderlineClose',
    515. 

  515. 	'listOpen','listClose',
    516. 

  516. 	'listItemOpen','listItemClose','listItemLine',
    517. 

  517. 	'numlistOpen','numlistClose',
    518. 

  518. 	'numlistItemOpen','numlistItemClose','numlistItemLine',
    519. 

  519. 	'deflistOpen','deflistClose',
    520. 

  520. 	'deflistItem1Open','deflistItem1Close',
    521. 

  521. 	'deflistItem2Open','deflistItem2Close',
    522. 

  522. 	'bar1','bar2',
    523. 

  523. 	'url','urlMark','email','emailMark',
    524. 

  524. 	'img','imgAlignLeft','imgAlignRight','imgAlignCenter',
    525. 

  525. 	'tableOpen','tableClose',
    526. 

  526. 	'tableRowOpen','tableRowClose','tableRowSep',
    527. 

  527. 	'tableCellOpen','tableCellClose','tableCellSep',
    528. 

  528. 	'tableTitleCellOpen','tableTitleCellClose','tableTitleCellSep',
    529. 

  529. 	'tableTitleRowOpen','tableTitleRowClose',
    530. 

  530. 	'tableBorder', 'tableAlignLeft', 'tableAlignCenter',
    531. 

  531. 	'tableCellAlignLeft','tableCellAlignRight','tableCellAlignCenter',
    532. 

  532. 	'tableColAlignLeft','tableColAlignRight','tableColAlignCenter',
    533. 

  533. 	'tableColAlignSep', 'tableCellColSpan',
    534. 

  534. 	'anchor','comment','pageBreak',
    535. 

  535. 	'TOC','tocOpen','tocClose',
    536. 

  536. 	'cssOpen', 'cssClose',
    537. 

  537. 	'bodyOpen','bodyClose',
    538. 

  538. 	'EOD'
    539. 

  539. 	]
    540. 

  540. 	
    541. 

  541. 	# TIP: \a represents the current text on the mark
    542. 

  542. 	# TIP: ~A~, ~B~ and ~C~ are expanded to other tags parts
    543. 

  543. 	
    544. 

  544. 	alltags = {
    545. 

  545. 	
    546. 

  546. 	'txt': {
    547. 

  547. 	   'title1'              : '  \a'      ,
    548. 

  548. 	   'title2'              : '\t\a'      ,
    549. 

  549. 	   'title3'              : '\t\t\a'    ,
    550. 

  550. 	   'title4'              : '\t\t\t\a'  ,
    551. 

  551. 	   'title5'              : '\t\t\t\t\a',
    552. 

  552. 	   'blockQuoteLine'      : '\t'        ,
    553. 

  553. 	   'listItemOpen'        : '- '        ,
    554. 

  554. 	   'numlistItemOpen'     : '\a. '      ,
    555. 

  555. 	   'bar1'                : '\a'        ,
    556. 

  556. 	   'url'                 : '\a'        ,
    557. 

  557. 	   'urlMark'             : '\a (\a)'   ,
    558. 

  558. 	   'email'               : '\a'        ,
    559. 

  559. 	   'emailMark'           : '\a (\a)'   ,
    560. 

  560. 	   'img'                 : '[\a]'      ,
    561. 

  561. 	},
    562. 

  562. 	
    563. 

  563. 	'html': {
    564. 

  564. 	   'paragraphOpen'       : '<P>'            ,
    565. 

  565. 	   'paragraphClose'      : '</P>'           ,
    566. 

  566. 	   'title1'              : '~A~<H1>\a</H1>' ,
    567. 

  567. 	   'title2'              : '~A~<H2>\a</H2>' ,
    568. 

  568. 	   'title3'              : '~A~<H3>\a</H3>' ,
    569. 

  569. 	   'title4'              : '~A~<H4>\a</H4>' ,
    570. 

  570. 	   'title5'              : '~A~<H5>\a</H5>' ,
    571. 

  571. 	   'blockVerbOpen'       : '<PRE>'          ,
    572. 

  572. 	   'blockVerbClose'      : '</PRE>'         ,
    573. 

  573. 	   'blockQuoteOpen'      : '<BLOCKQUOTE>'   ,
    574. 

  574. 	   'blockQuoteClose'     : '</BLOCKQUOTE>'  ,
    575. 

  575. 	   'fontMonoOpen'        : '<CODE>'         ,
    576. 

  576. 	   'fontMonoClose'       : '</CODE>'        ,
    577. 

  577. 	   'fontBoldOpen'        : '<B>'            ,
    578. 

  578. 	   'fontBoldClose'       : '</B>'           ,
    579. 

  579. 	   'fontItalicOpen'      : '<I>'            ,
    580. 

  580. 	   'fontItalicClose'     : '</I>'           ,
    581. 

  581. 	   'fontUnderlineOpen'   : '<U>'            ,
    582. 

  582. 	   'fontUnderlineClose'  : '</U>'           ,
    583. 

  583. 	   'listOpen'            : '<UL>'           ,
    584. 

  584. 	   'listClose'           : '</UL>'          ,
    585. 

  585. 	   'listItemOpen'        : '<LI>'           ,
    586. 

  586. 	   'numlistOpen'         : '<OL>'           ,
    587. 

  587. 	   'numlistClose'        : '</OL>'          ,
    588. 

  588. 	   'numlistItemOpen'     : '<LI>'           ,
    589. 

  589. 	   'deflistOpen'         : '<DL>'           ,
    590. 

  590. 	   'deflistClose'        : '</DL>'          ,
    591. 

  591. 	   'deflistItem1Open'    : '<DT>'           ,
    592. 

  592. 	   'deflistItem1Close'   : '</DT>'          ,
    593. 

  593. 	   'deflistItem2Open'    : '<DD>'           ,
    594. 

  594. 	   'bar1'                : '<HR NOSHADE SIZE=1>'        ,
    595. 

  595. 	   'bar2'                : '<HR NOSHADE SIZE=5>'        ,
    596. 

  596. 	   'url'                 : '<A HREF="\a">\a</A>'        ,
    597. 

  597. 	   'urlMark'             : '<A HREF="\a">\a</A>'        ,
    598. 

  598. 	   'email'               : '<A HREF="mailto:\a">\a</A>' ,
    599. 

  599. 	   'emailMark'           : '<A HREF="mailto:\a">\a</A>' ,
    600. 

  600. 	   'img'                 : '<IMG~A~ SRC="\a" BORDER="0" ALT="">',
    601. 

  601. 	   'imgAlignLeft'        : ' ALIGN="left"'  ,
    602. 

  602. 	   'imgAlignCenter'      : ' ALIGN="middle"',
    603. 

  603. 	   'imgAlignRight'       : ' ALIGN="right"' ,
    604. 

  604. 	   'tableOpen'           : '<TABLE~A~ CELLPADDING="4"~B~>',
    605. 

  605. 	   'tableClose'          : '</TABLE>'       ,
    606. 

  606. 	   'tableRowOpen'        : '<TR>'           ,
    607. 

  607. 	   'tableRowClose'       : '</TR>'          ,
    608. 

  608. 	   'tableCellOpen'       : '<TD~A~~S~>'      ,
    609. 

  609. 	   'tableCellClose'      : '</TD>'          ,
    610. 

  610. 	   'tableTitleCellOpen'  : '<TH~S~>'        ,
    611. 

  611. 	   'tableTitleCellClose' : '</TH>'          ,
    612. 

  612. 	   'tableBorder'         : ' BORDER="1"'    ,
    613. 

  613. 	   'tableAlignCenter'    : ' ALIGN="center"',
    614. 

  614. 	   'tableCellAlignRight' : ' ALIGN="right"' ,
    615. 

  615. 	   'tableCellAlignCenter': ' ALIGN="center"',
    616. 

  616. 	   'tableCellColSpan'    : ' COLSPAN="\a"'  ,
    617. 

  617. 	   'anchor'              : '<A NAME="\a"></A>\n',
    618. 

  618. 	   'cssOpen'             : '<STYLE TYPE="text/css">',
    619. 

  619. 	   'cssClose'            : '</STYLE>'       ,
    620. 

  620. 	   'comment'             : '<!-- \a -->'    ,
    621. 

  621. 	   'EOD'                 : '</BODY></HTML>'
    622. 

  622. 	},
    623. 

  623. 	
    624. 

  624. 	#TIP xhtml inherits all HTML definitions (lowercased)
    625. 

  625. 	#TIP http://www.w3.org/TR/xhtml1/#guidelines
    626. 

  626. 	#TIP http://www.htmlref.com/samples/Chapt17/17_08.htm
    627. 

  627. 	'xhtml': {
    628. 

  628. 	   'listItemClose'       : '</li>'          ,
    629. 

  629. 	   'numlistItemClose'    : '</li>'          ,
    630. 

  630. 	   'deflistItem2Close'   : '</dd>'          ,
    631. 

  631. 	   'bar1'                : '<hr class="light" />',
    632. 

  632. 	   'bar2'                : '<hr class="heavy" />',
    633. 

  633. 	   'anchor'              : '<a id="\a" name="\a"></a>\n',
    634. 

  634. 	   'img'                 : '<img~A~ src="\a" border="0" alt=""/>',
    635. 

  635. 	},
    636. 

  636. 	
    637. 

  637. 	'sgml': {
    638. 

  638. 	   'paragraphOpen'       : '<p>'                ,
    639. 

  639. 	   'title1'              : '<sect>\a~A~<p>'     ,
    640. 

  640. 	   'title2'              : '<sect1>\a~A~<p>'    ,
    641. 

  641. 	   'title3'              : '<sect2>\a~A~<p>'    ,
    642. 

  642. 	   'title4'              : '<sect3>\a~A~<p>'    ,
    643. 

  643. 	   'title5'              : '<sect4>\a~A~<p>'    ,
    644. 

  644. 	   'blockVerbOpen'       : '<tscreen><verb>'    ,
    645. 

  645. 	   'blockVerbClose'      : '</verb></tscreen>'  ,
    646. 

  646. 	   'blockQuoteOpen'      : '<quote>'            ,
    647. 

  647. 	   'blockQuoteClose'     : '</quote>'           ,
    648. 

  648. 	   'fontMonoOpen'        : '<tt>'               ,
    649. 

  649. 	   'fontMonoClose'       : '</tt>'              ,
    650. 

  650. 	   'fontBoldOpen'        : '<bf>'               ,
    651. 

  651. 	   'fontBoldClose'       : '</bf>'              ,
    652. 

  652. 	   'fontItalicOpen'      : '<em>'               ,
    653. 

  653. 	   'fontItalicClose'     : '</em>'              ,
    654. 

  654. 	   'fontUnderlineOpen'   : '<bf><em>'           ,
    655. 

  655. 	   'fontUnderlineClose'  : '</em></bf>'         ,
    656. 

  656. 	   'listOpen'            : '<itemize>'          ,
    657. 

  657. 	   'listClose'           : '</itemize>'         ,
    658. 

  658. 	   'listItemOpen'        : '<item>'             ,
    659. 

  659. 	   'numlistOpen'         : '<enum>'             ,
    660. 

  660. 	   'numlistClose'        : '</enum>'            ,
    661. 

  661. 	   'numlistItemOpen'     : '<item>'             ,
    662. 

  662. 	   'deflistOpen'         : '<descrip>'          ,
    663. 

  663. 	   'deflistClose'        : '</descrip>'         ,
    664. 

  664. 	   'deflistItem1Open'    : '<tag>'              ,
    665. 

  665. 	   'deflistItem1Close'   : '</tag>'             ,
    666. 

  666. 	   'bar1'                : '<!-- \a -->'        ,
    667. 

  667. 	   'url'                 : '<htmlurl url="\a" name="\a">'        ,
    668. 

  668. 	   'urlMark'             : '<htmlurl url="\a" name="\a">'        ,
    669. 

  669. 	   'email'               : '<htmlurl url="mailto:\a" name="\a">' ,
    670. 

  670. 	   'emailMark'           : '<htmlurl url="mailto:\a" name="\a">' ,
    671. 

  671. 	   'img'                 : '<figure><ph vspace=""><img src="\a">'+\
    672. 

  672. 	                           '</figure>'                           ,
    673. 

  673. 	   'tableOpen'           : '<table><tabular ca="~C~">'           ,
    674. 

  674. 	   'tableClose'          : '</tabular></table>' ,
    675. 

  675. 	   'tableRowSep'         : '<rowsep>'           ,
    676. 

  676. 	   'tableCellSep'        : '<colsep>'           ,
    677. 

  677. 	   'tableColAlignLeft'   : 'l'                  ,
    678. 

  678. 	   'tableColAlignRight'  : 'r'                  ,
    679. 

  679. 	   'tableColAlignCenter' : 'c'                  ,
    680. 

  680. 	   'comment'             : '<!-- \a -->'        ,
    681. 

  681. 	   'anchor'              : '<label id="\a">'    ,
    682. 

  682. 	   'TOC'                 : '<toc>'              ,
    683. 

  683. 	   'EOD'                 : '</article>'
    684. 

  684. 	},
    685. 

  685. 	
    686. 

  686. 	'tex': {
    687. 

  687. 	   'title1'              : '\n\section*{\a}'     ,
    688. 

  688. 	   'title2'              : '\\subsection*{\a}'   ,
    689. 

  689. 	   'title3'              : '\\subsubsection*{\a}',
    690. 

  690. 	   # title 4/5: DIRTY: para+BF+\\+\n
    691. 

  691. 	   'title4'              : '\\paragraph{}\\textbf{\a}\\\\\n',
    692. 

  692. 	   'title5'              : '\\paragraph{}\\textbf{\a}\\\\\n',
    693. 

  693. 	   'numtitle1'           : '\n\section{\a}'      ,
    694. 

  694. 	   'numtitle2'           : '\\subsection{\a}'    ,
    695. 

  695. 	   'numtitle3'           : '\\subsubsection{\a}' ,
    696. 

  696. 	   'blockVerbOpen'       : '\\begin{verbatim}'   ,
    697. 

  697. 	   'blockVerbClose'      : '\\end{verbatim}'     ,
    698. 

  698. 	   'blockQuoteOpen'      : '\\begin{quotation}'  ,
    699. 

  699. 	   'blockQuoteClose'     : '\\end{quotation}'    ,
    700. 

  700. 	   'fontMonoOpen'        : '\\texttt{'           ,
    701. 

  701. 	   'fontMonoClose'       : '}'                   ,
    702. 

  702. 	   'fontBoldOpen'        : '\\textbf{'           ,
    703. 

  703. 	   'fontBoldClose'       : '}'                   ,
    704. 

  704. 	   'fontItalicOpen'      : '\\textit{'           ,
    705. 

  705. 	   'fontItalicClose'     : '}'                   ,
    706. 

  706. 	   'fontUnderlineOpen'   : '\\underline{'        ,
    707. 

  707. 	   'fontUnderlineClose'  : '}'                   ,
    708. 

  708. 	   'listOpen'            : '\\begin{itemize}'    ,
    709. 

  709. 	   'listClose'           : '\\end{itemize}'      ,
    710. 

  710. 	   'listItemOpen'        : '\\item '             ,
    711. 

  711. 	   'numlistOpen'         : '\\begin{enumerate}'  ,
    712. 

  712. 	   'numlistClose'        : '\\end{enumerate}'    ,
    713. 

  713. 	   'numlistItemOpen'     : '\\item '             ,
    714. 

  714. 	   'deflistOpen'         : '\\begin{description}',
    715. 

  715. 	   'deflistClose'        : '\\end{description}'  ,
    716. 

  716. 	   'deflistItem1Open'    : '\\item['             ,
    717. 

  717. 	   'deflistItem1Close'   : ']'                   ,
    718. 

  718. 	   'bar1'                : '\n\\hrulefill{}\n'   ,
    719. 

  719. 	   'bar2'                : '\n\\rule{\linewidth}{1mm}\n',
    720. 

  720. 	   'url'                 : '\\htmladdnormallink{\a}{\a}',
    721. 

  721. 	   'urlMark'             : '\\htmladdnormallink{\a}{\a}',
    722. 

  722. 	   'email'               : '\\htmladdnormallink{\a}{mailto:\a}',
    723. 

  723. 	   'emailMark'           : '\\htmladdnormallink{\a}{mailto:\a}',
    724. 

  724. 	   'img'                 : '\\includegraphics{\a}',
    725. 

  725. 	   'tableOpen'           : '\\begin{center}\\begin{tabular}{|~C~|}',
    726. 

  726. 	   'tableClose'          : '\\end{tabular}\\end{center}',
    727. 

  727. 	   'tableRowOpen'        : '\\hline ' ,
    728. 

  728. 	   'tableRowClose'       : ' \\\\'    ,
    729. 

  729. 	   'tableCellSep'        : ' & '      ,
    730. 

  730. 	   'tableColAlignLeft'   : 'l'        ,
    731. 

  731. 	   'tableColAlignRight'  : 'r'        ,
    732. 

  732. 	   'tableColAlignCenter' : 'c'        ,
    733. 

  733. 	   'tableColAlignSep'    : '|'        ,
    734. 

  734. 	   'comment'             : '% \a'     ,
    735. 

  735. 	   'TOC'                 : '\\tableofcontents',
    736. 

  736. 	   'pageBreak'           : '\\clearpage',
    737. 

  737. 	   'EOD'                 : '\\end{document}'
    738. 

  738. 	},
    739. 

  739. 	
    740. 

  740. 	'lout': {
    741. 

  741. 	   'paragraphOpen'       : '@LP'                     ,
    742. 

  742. 	   'blockTitle1Open'     : '@BeginSections'          ,
    743. 

  743. 	   'blockTitle1Close'    : '@EndSections'            ,
    744. 

  744. 	   'blockTitle2Open'     : ' @BeginSubSections'      ,
    745. 

  745. 	   'blockTitle2Close'    : ' @EndSubSections'        ,
    746. 

  746. 	   'blockTitle3Open'     : '  @BeginSubSubSections'  ,
    747. 

  747. 	   'blockTitle3Close'    : '  @EndSubSubSections'    ,
    748. 

  748. 	   'title1Open'          : '\n@Section @Title { \a } @Begin',
    749. 

  749. 	   'title1Close'         : '@End @Section'           ,
    750. 

  750. 	   'title2Open'          : '\n @SubSection @Title { \a } @Begin',
    751. 

  751. 	   'title2Close'         : ' @End @SubSection'       ,
    752. 

  752. 	   'title3Open'          : '\n  @SubSubSection @Title { \a } @Begin',
    753. 

  753. 	   'title3Close'         : '  @End @SubSubSection'   ,
    754. 

  754. 	   'title4Open'          : '\n@LP @LeftDisplay @B { \a }',
    755. 

  755. 	   'title5Open'          : '\n@LP @LeftDisplay @B { \a }',
    756. 

  756. 	   'anchor'              : '@Tag { \a }'             ,
    757. 

  757. 	   'blockVerbOpen'       : '@LP @ID @F @RawVerbatim @Begin',
    758. 

  758. 	   'blockVerbClose'      : '@End @RawVerbatim'   ,
    759. 

  759. 	   'blockQuoteOpen'      : '@QD {'               ,
    760. 

  760. 	   'blockQuoteClose'     : '}'                   ,
    761. 

  761. 	   # enclosed inside {} to deal with joined**words**
    762. 

  762. 	   'fontMonoOpen'        : '{@F {'               ,
    763. 

  763. 	   'fontMonoClose'       : '}}'                  ,
    764. 

  764. 	   'fontBoldOpen'        : '{@B {'               ,
    765. 

  765. 	   'fontBoldClose'       : '}}'                  ,
    766. 

  766. 	   'fontItalicOpen'      : '{@II {'              ,
    767. 

  767. 	   'fontItalicClose'     : '}}'                  ,
    768. 

  768. 	   'fontUnderlineOpen'   : '{@Underline{'        ,
    769. 

  769. 	   'fontUnderlineClose'  : '}}'                  ,
    770. 

  770. 	   # the full form is more readable, but could be BL EL LI NL TL DTI
    771. 

  771. 	   'listOpen'            : '@BulletList'         ,
    772. 

  772. 	   'listClose'           : '@EndList'            ,
    773. 

  773. 	   'listItemOpen'        : '@ListItem{'          ,
    774. 

  774. 	   'listItemClose'       : '}'                   ,
    775. 

  775. 	   'numlistOpen'         : '@NumberedList'       ,
    776. 

  776. 	   'numlistClose'        : '@EndList'            ,
    777. 

  777. 	   'numlistItemOpen'     : '@ListItem{'          ,
    778. 

  778. 	   'numlistItemClose'    : '}'                   ,
    779. 

  779. 	   'deflistOpen'         : '@TaggedList'         ,
    780. 

  780. 	   'deflistClose'        : '@EndList'            ,
    781. 

  781. 	   'deflistItem1Open'    : '@DropTagItem {'      ,
    782. 

  782. 	   'deflistItem1Close'   : '}'                   ,
    783. 

  783. 	   'deflistItem2Open'    : '{'                   ,
    784. 

  784. 	   'deflistItem2Close'   : '}'                   ,
    785. 

  785. 	   'bar1'                : '\n@DP @FullWidthRule\n'     ,
    786. 

  786. 	   'url'                 : '{blue @Colour { \a }}'      ,
    787. 

  787. 	   'urlMark'             : '\a ({blue @Colour { \a }})' ,
    788. 

  788. 	   'email'               : '{blue @Colour { \a }}'      ,
    789. 

  789. 	   'emailMark'           : '\a ({blue Colour{ \a }})'   ,
    790. 

  790. 	   'img'                 : '~A~@IncludeGraphic { \a }'  ,  # eps only!
    791. 

  791. 	   'imgAlignLeft'        : '@LeftDisplay '              ,
    792. 

  792. 	   'imgAlignRight'       : '@RightDisplay '             ,
    793. 

  793. 	   'imgAlignCenter'      : '@CentredDisplay '           ,
    794. 

  794. 	   # lout tables are *way* complicated, no support for now
    795. 

  795. 	   #'tableOpen'          : '~A~@Tbl~B~\naformat{ @Cell A | @Cell B } {',
    796. 

  796. 	   #'tableClose'         : '}'     ,
    797. 

  797. 	   #'tableRowOpen'       : '@Rowa\n'       ,
    798. 

  798. 	   #'tableTitleRowOpen'  : '@HeaderRowa'       ,
    799. 

  799. 	   #'tableCenterAlign'   : '@CentredDisplay '         ,
    800. 

  800. 	   #'tableCellOpen'      : '\a {'                     ,  # A, B, ...
    801. 

  801. 	   #'tableCellClose'     : '}'                        ,
    802. 

  802. 	   #'tableBorder'        : '\nrule {yes}'             ,
    803. 

  803. 	   'comment'             : '# \a'                     ,
    804. 

  804. 	   # @MakeContents must be on the config file
    805. 

  805. 	   'TOC'                 : '@DP @ContentsGoesHere @DP',
    806. 

  806. 	   'pageBreak'           : '\n@NP\n'                  ,
    807. 

  807. 	   'EOD'                 : '@End @Text'
    808. 

  808. 	},
    809. 

  809. 	
    810. 

  810. 	'moin': {
    811. 

  811. 	   'title1'              : '= \a ='        ,
    812. 

  812. 	   'title2'              : '== \a =='      ,
    813. 

  813. 	   'title3'              : '=== \a ==='    ,
    814. 

  814. 	   'title4'              : '==== \a ===='  ,
    815. 

  815. 	   'title5'              : '===== \a =====',
    816. 

  816. 	   'blockVerbOpen'       : '{{{'           ,
    817. 

  817. 	   'blockVerbClose'      : '}}}'           ,
    818. 

  818. 	   'blockQuoteLine'      : '  '            ,
    819. 

  819. 	   'fontMonoOpen'        : '{{{'           ,
    820. 

  820. 	   'fontMonoClose'       : '}}}'           ,
    821. 

  821. 	   'fontBoldOpen'        : "'''"           ,
    822. 

  822. 	   'fontBoldClose'       : "'''"           ,
    823. 

  823. 	   'fontItalicOpen'      : "''"            ,
    824. 

  824. 	   'fontItalicClose'     : "''"            ,
    825. 

  825. 	   'fontUnderlineOpen'   : "__"            ,
    826. 

  826. 	   'fontUnderlineClose'  : "__"            ,
    827. 

  827. 	   'listItemOpen'        : ' * '           ,
    828. 

  828. 	   'numlistItemOpen'     : ' \a. '         ,
    829. 

  829. 	   'bar1'                : '----'          ,
    830. 

  830. 	   'url'                 : '[\a]'          ,
    831. 

  831. 	   'urlMark'             : '[\a \a]'       ,
    832. 

  832. 	   'email'               : '[\a]'          ,
    833. 

  833. 	   'emailMark'           : '[\a \a]'       ,
    834. 

  834. 	   'img'                 : '[\a]'          ,
    835. 

  835. 	   'tableRowOpen'        : '||'            ,
    836. 

  836. 	   'tableCellOpen'       : '~A~'           ,
    837. 

  837. 	   'tableCellClose'      : '||'            ,
    838. 

  838. 	   'tableTitleCellClose' : '||'            ,
    839. 

  839. 	   'tableCellAlignRight' : '<)>'           ,
    840. 

  840. 	   'tableCellAlignCenter': '<:>'           ,
    841. 

  841. 	   'comment'             : '## \a'         ,
    842. 

  842. 	   'TOC'                 : '[[TableOfContents]]'
    843. 

  843. 	},
    844. 

  844. 	
    845. 

  845. 	'mgp': {
    846. 

  846. 	   'paragraphOpen'       : '%font "normal", size 5'     ,
    847. 

  847. 	   'title1'              : '%page\n\n\a\n'              ,
    848. 

  848. 	   'title2'              : '%page\n\n\a\n'              ,
    849. 

  849. 	   'title3'              : '%page\n\n\a\n'              ,
    850. 

  850. 	   'title4'              : '%page\n\n\a\n'              ,
    851. 

  851. 	   'title5'              : '%page\n\n\a\n'              ,
    852. 

  852. 	   'blockVerbOpen'       : '%font "mono"'               ,
    853. 

  853. 	   'blockVerbClose'      : '%font "normal"'             ,
    854. 

  854. 	   'blockQuoteOpen'      : '%prefix "       "'          ,
    855. 

  855. 	   'blockQuoteClose'     : '%prefix "  "'               ,
    856. 

  856. 	   'fontMonoOpen'        : '\n%cont, font "mono"\n'     ,
    857. 

  857. 	   'fontMonoClose'       : '\n%cont, font "normal"\n'   ,
    858. 

  858. 	   'fontBoldOpen'        : '\n%cont, font "normal-b"\n' ,
    859. 

  859. 	   'fontBoldClose'       : '\n%cont, font "normal"\n'   ,
    860. 

  860. 	   'fontItalicOpen'      : '\n%cont, font "normal-i"\n' ,
    861. 

  861. 	   'fontItalicClose'     : '\n%cont, font "normal"\n'   ,
    862. 

  862. 	   'fontUnderlineOpen'   : '\n%cont, fore "cyan"\n'     ,
    863. 

  863. 	   'fontUnderlineClose'  : '\n%cont, fore "white"\n'    ,
    864. 

  864. 	   'listItemLine'        : '\t'                         ,
    865. 

  865. 	   'numlistItemLine'     : '\t'                         ,
    866. 

  866. 	   'deflistItem1Open'    : '\t\n%cont, font "normal-b"\n',
    867. 

  867. 	   'deflistItem1Close'   : '\n%cont, font "normal"\n'   ,
    868. 

  868. 	   'bar1'                : '%bar "white" 5'             ,
    869. 

  869. 	   'bar2'                : '%pause'                     ,
    870. 

  870. 	   'url'                 : '\n%cont, fore "cyan"\n\a'   +\
    871. 

  871. 	                           '\n%cont, fore "white"\n'    ,
    872. 

  872. 	   'urlMark'             : '\a \n%cont, fore "cyan"\n\a'+\
    873. 

  873. 	                           '\n%cont, fore "white"\n'    ,
    874. 

  874. 	   'email'               : '\n%cont, fore "cyan"\n\a'   +\
    875. 

  875. 	                           '\n%cont, fore "white"\n'    ,
    876. 

  876. 	   'emailMark'           : '\a \n%cont, fore "cyan"\n\a'+\
    877. 

  877. 	                           '\n%cont, fore "white"\n'    ,
    878. 

  878. 	   'img'                 : '~A~\n%newimage "\a"\n%left\n',
    879. 

  879. 	   'imgAlignLeft'        : '\n%left'                    ,
    880. 

  880. 	   'imgAlignRight'       : '\n%right'                   ,
    881. 

  881. 	   'imgAlignCenter'      : '\n%center'                  ,
    882. 

  882. 	   'comment'             : '%% \a'                      ,
    883. 

  883. 	   'pageBreak'           : '%page\n\n\n'                ,
    884. 

  884. 	   'EOD'                 : '%%EOD'
    885. 

  885. 	},
    886. 

  886. 	
    887. 

  887. 	# man groff_man ; man 7 groff
    888. 

  888. 	'man': {
    889. 

  889. 	   'paragraphOpen'       : '.P'     ,
    890. 

  890. 	   'title1'              : '.SH \a' ,
    891. 

  891. 	   'title2'              : '.SS \a' ,
    892. 

  892. 	   'title3'              : '.SS \a' ,
    893. 

  893. 	   'title4'              : '.SS \a' ,
    894. 

  894. 	   'title5'              : '.SS \a' ,
    895. 

  895. 	   'blockVerbOpen'       : '.nf'    ,
    896. 

  896. 	   'blockVerbClose'      : '.fi\n'  ,
    897. 

  897. 	   'blockQuoteOpen'      : '.RS'    ,
    898. 

  898. 	   'blockQuoteClose'     : '.RE'    ,
    899. 

  899. 	   'fontBoldOpen'        : '\\fB'   ,
    900. 

  900. 	   'fontBoldClose'       : '\\fR'   ,
    901. 

  901. 	   'fontItalicOpen'      : '\\fI'   ,
    902. 

  902. 	   'fontItalicClose'     : '\\fR'   ,
    903. 

  903. 	   'listOpen'            : '.RS'    ,
    904. 

  904. 	   'listItemOpen'        : '.IP \(bu 3\n',
    905. 

  905. 	   'listClose'           : '.RE'    ,
    906. 

  906. 	   'numlistOpen'         : '.RS'    ,
    907. 

  907. 	   'numlistItemOpen'     : '.IP \a. 3\n',
    908. 

  908. 	   'numlistClose'        : '.RE'    ,
    909. 

  909. 	   'deflistItem1Open'    : '.TP\n'  ,
    910. 

  910. 	   'bar1'                : '\n\n'   ,
    911. 

  911. 	   'url'                 : '\a'     ,
    912. 

  912. 	   'urlMark'             : '\a (\a)',
    913. 

  913. 	   'email'               : '\a'     ,
    914. 

  914. 	   'emailMark'           : '\a (\a)',
    915. 

  915. 	   'img'                 : '\a'     ,
    916. 

  916. 	   'tableOpen'           : '.TS\n~A~~B~tab(^); ~C~.',
    917. 

  917. 	   'tableClose'          : '.TE'     ,
    918. 

  918. 	   'tableRowOpen'        : ' '       ,
    919. 

  919. 	   'tableCellSep'        : '^'       ,
    920. 

  920. 	   'tableAlignCenter'    : 'center, ',
    921. 

  921. 	   'tableBorder'         : 'allbox, ',
    922. 

  922. 	   'tableColAlignLeft'   : 'l'       ,
    923. 

  923. 	   'tableColAlignRight'  : 'r'       ,
    924. 

  924. 	   'tableColAlignCenter' : 'c'       ,
    925. 

  925. 	   'comment'             : '.\\" \a'
    926. 

  926. 	},
    927. 

  927. 	
    928. 

  928. 	'pm6': {
    929. 

  929. 	   'paragraphOpen'       : '<@Normal:>'    ,
    930. 

  930. 	   'title1'              : '\n<@Title1:>\a',
    931. 

  931. 	   'title2'              : '\n<@Title2:>\a',
    932. 

  932. 	   'title3'              : '\n<@Title3:>\a',
    933. 

  933. 	   'title4'              : '\n<@Title4:>\a',
    934. 

  934. 	   'title5'              : '\n<@Title5:>\a',
    935. 

  935. 	   'blockVerbOpen'       : '<@PreFormat:>' ,
    936. 

  936. 	   'blockQuoteLine'      : '<@Quote:>'     ,
    937. 

  937. 	   'fontMonoOpen'        : '<FONT "Lucida Console"><SIZE 9>' ,
    938. 

  938. 	   'fontMonoClose'       : '<SIZE$><FONT$>',
    939. 

  939. 	   'fontBoldOpen'        : '<B>'           ,
    940. 

  940. 	   'fontBoldClose'       : '<P>'           ,
    941. 

  941. 	   'fontItalicOpen'      : '<I>'           ,
    942. 

  942. 	   'fontItalicClose'     : '<P>'           ,
    943. 

  943. 	   'fontUnderlineOpen'   : '<U>'           ,
    944. 

  944. 	   'fontUnderlineClose'  : '<P>'           ,
    945. 

  945. 	   'listOpen'            : '<@Bullet:>'    ,
    946. 

  946. 	   'listItemOpen'        : '\x95\t'        ,  # \x95 == ~U
    947. 

  947. 	   'numlistOpen'         : '<@Bullet:>'    ,
    948. 

  948. 	   'numlistItemOpen'     : '\x95\t'        ,
    949. 

  949. 	   'bar1'                : '\a'            ,
    950. 

  950. 	   'url'                 : '<U>\a<P>'      ,  # underline
    951. 

  951. 	   'urlMark'             : '\a <U>\a<P>'   ,
    952. 

  952. 	   'email'               : '\a'            ,
    953. 

  953. 	   'emailMark'           : '\a \a'         ,
    954. 

  954. 	   'img'                 : '\a'
    955. 

  955. 	}
    956. 

  956. 	}
    957. 

  957. 	
    958. 

  958. 	# exceptions for --css-sugar
    959. 

  959. 	if config['css-sugar'] and config['target'] in ('html','xhtml'):
    960. 

  960. 		# change just HTML because XHTML inherits it
    961. 

  961. 		htmltags = alltags['html']
    962. 

  962. 		# table with no cellpadding
    963. 

  963. 		htmltags['tableOpen'] = string.replace(
    964. 

  964. 			htmltags['tableOpen'], ' CELLPADDING="4"', '')
    965. 

  965. 		# DIVs
    966. 

  966. 		htmltags['tocOpen' ] = '<DIV CLASS="toc" ID="toc">'
    967. 

  967. 		htmltags['tocClose'] = '</DIV>'
    968. 

  968. 		htmltags['bodyOpen'] = '<DIV CLASS="body" ID="body">'
    969. 

  969. 		htmltags['bodyClose']= '</DIV>'
    970. 

  970. 	
    971. 

  971. 	# make the HTML -> XHTML inheritance
    972. 

  972. 	xhtml = alltags['html'].copy()
    973. 

  973. 	for key in xhtml.keys(): xhtml[key] = string.lower(xhtml[key])
    974. 

  974. 	# some like HTML tags as lowercase, some don't... (headers out)
    975. 

  975. 	if HTML_LOWER: alltags['html'] = xhtml.copy()
    976. 

  976. 	xhtml.update(alltags['xhtml'])
    977. 

  977. 	alltags['xhtml'] = xhtml.copy()
    978. 

  978. 	
    979. 

  979. 	# compose the target tags dictionary
    980. 

  980. 	tags = {}
    981. 

  981. 	target_tags = alltags[config['target']].copy()
    982. 

  982. 	
    983. 

  983. 	for key in keys: tags[key] = ''     # create empty keys
    984. 

  984. 	for key in target_tags.keys():
    985. 

  985. 		tags[key] = maskEscapeChar(target_tags[key]) # populate
    986. 

  986. 	
    987. 

  987. 	# map strong line to separator if not defined
    988. 

  988. 	if not tags['bar2'] and tags['bar1']:
    989. 

  989. 		tags['bar2'] = tags['bar1']
    990. 

  990. 	
    991. 

  991. 	return tags
    992. 

  992. 

  993. 

  994. ##############################################################################
    995. 

  995. 

  996. 

  997. def getRules(config):
    998. 

  998. 	"Returns all the target-specific syntax rules"
    999. 

  999. 	
    1000. 

  1000. 	ret = {}
    1001. 

  1001. 	allrules = [
    1002. 

  1002. 	
    1003. 

  1003. 	 # target rules (ON/OFF)
    1004. 

  1004. 	  'linkable',             # target supports external links
    1005. 

  1005. 	  'tableable',            # target supports tables
    1006. 

  1006. 	  'imglinkable',          # target supports images as links
    1007. 

  1007. 	  'imgalignable',         # target supports image alignment
    1008. 

  1008. 	  'imgasdefterm',         # target supports image as definition term
    1009. 

  1009. 	  'autonumberlist',       # target supports numbered lists natively
    1010. 

  1010. 	  'autonumbertitle',      # target supports numbered titles natively
    1011. 

  1011. 	  'parainsidelist',       # lists items supports paragraph
    1012. 

  1012. 	  'spacedlistitem',       # lists support blank lines between items
    1013. 

  1013. 	  'listnotnested',        # lists cannot be nested
    1014. 

  1014. 	  'quotenotnested',       # quotes cannot be nested
    1015. 

  1015. 	  'verbblocknotescaped',  # don't escape specials in verb block
    1016. 

  1016. 	  'verbblockfinalescape', # do final escapes in verb block
    1017. 

  1017. 	  'escapeurl',            # escape special in link URL
    1018. 

  1018. 	  'onelinepara',          # dump paragraph as a single long line
    1019. 

  1019. 	  'tabletitlerowinbold',  # manually bold any cell on table titles
    1020. 

  1020. 	  'tablecellstrip',       # strip extra spaces from each table cell
    1021. 

  1021. 	  'tablecellspannable',   # the table cells can have span attribute
    1022. 

  1022. 	  'barinsidequote',       # bars are allowed inside quote blocks
    1023. 

  1023. 	  'finalescapetitle',     # perform final escapes on title lines
    1024. 

  1024. 	  'autotocnewpagebefore', # break page before automatic TOC
    1025. 

  1025. 	  'autotocnewpageafter',  # break page after automatic TOC
    1026. 

  1026. 	  'autotocwithbars',      # automatic TOC surrounded by bars
    1027. 

  1027. 	  'mapbar2pagebreak',     # map the strong bar to a page break
    1028. 

  1028. 	  'titleblocks',          # titles must be on open/close section blocks
    1029. 

  1029. 	
    1030. 

  1030. 	# target code beautify (ON/OFF)
    1031. 

  1031. 	  'indentverbblock',      # add leading spaces to verb block lines
    1032. 

  1032. 	  'breaktablecell',       # break lines after any table cell
    1033. 

  1033. 	  'breaktablelineopen',   # break line after opening table line
    1034. 

  1034. 	  'notbreaklistopen',     # don't break line after opening a new list
    1035. 

  1035. 	  'notbreakparaopen',     # don't break line after opening a new para
    1036. 

  1036. 	  'keepquoteindent',      # don't remove the leading TABs on quotes
    1037. 

  1037. 	  'keeplistindent',       # don't remove the leading spaces on lists
    1038. 

  1038. 	  'blankendmotherlist',   # append a blank line at the mother list end
    1039. 

  1039. 	  'blankendtable',        # append a blank line at the table end
    1040. 

  1040. 	  'blankendautotoc',      # append a blank line at the auto TOC end
    1041. 

  1041. 	  'tagnotindentable',     # tags must be placed at the line begining
    1042. 

  1042. 	
    1043. 

  1043. 	# value settings
    1044. 

  1044. 	  'listmaxdepth',         # maximum depth for lists
    1045. 

  1045. 	  'tablecellaligntype'    # type of table cell align: cell, column
    1046. 

  1046. 	]
    1047. 

  1047. 	
    1048. 

  1048. 	rules_bank = {
    1049. 

  1049. 	  'txt' : {
    1050. 

  1050. 	    'indentverbblock':1,
    1051. 

  1051. 	    'spacedlistitem':1,
    1052. 

  1052. 	    'parainsidelist':1,
    1053. 

  1053. 	    'keeplistindent':1,
    1054. 

  1054. 	    'barinsidequote':1,
    1055. 

  1055. 	    'autotocwithbars':1,
    1056. 

  1056. 	    'blankendmotherlist':1
    1057. 

  1057. 	    },
    1058. 

  1058. 	  'html': {
    1059. 

  1059. 	    'indentverbblock':1,
    1060. 

  1060. 	    'linkable':1,
    1061. 

  1061. 	    'escapeurl':1,
    1062. 

  1062. 	    'imglinkable':1,
    1063. 

  1063. 	    'imgalignable':1,
    1064. 

  1064. 	    'imgasdefterm':1,
    1065. 

  1065. 	    'autonumberlist':1,
    1066. 

  1066. 	    'spacedlistitem':1,
    1067. 

  1067. 	    'parainsidelist':1,
    1068. 

  1068. 	    'blankendmotherlist':1,
    1069. 

  1069. 	    'tableable':1,
    1070. 

  1070. 	    'tablecellstrip':1,
    1071. 

  1071. 	    'blankendtable':1,
    1072. 

  1072. 	    'breaktablecell':1,
    1073. 

  1073. 	    'breaktablelineopen':1,
    1074. 

  1074. 	    'keeplistindent':1,
    1075. 

  1075. 	    'keepquoteindent':1,
    1076. 

  1076. 	    'barinsidequote':1,
    1077. 

  1077. 	    'autotocwithbars':1,
    1078. 

  1078. 	    'tablecellspannable':1,
    1079. 

  1079. 	    'tablecellaligntype':'cell'
    1080. 

  1080. 	    },
    1081. 

  1081. 	  #TIP xhtml inherits all HTML rules
    1082. 

  1082. 	  'xhtml': {
    1083. 

  1083. 	    },
    1084. 

  1084. 	  'sgml': {
    1085. 

  1085. 	    'linkable':1,
    1086. 

  1086. 	    'escapeurl':1,
    1087. 

  1087. 	    'autonumberlist':1,
    1088. 

  1088. 	    'spacedlistitem':1,
    1089. 

  1089. 	    'blankendmotherlist':1,
    1090. 

  1090. 	    'tableable':1,
    1091. 

  1091. 	    'tablecellstrip':1,
    1092. 

  1092. 	    'blankendtable':1,
    1093. 

  1093. 	    'blankendautotoc':1,
    1094. 

  1094. 	    'quotenotnested':1,
    1095. 

  1095. 	    'keeplistindent':1,
    1096. 

  1096. 	    'keepquoteindent':1,
    1097. 

  1097. 	    'barinsidequote':1,
    1098. 

  1098. 	    'finalescapetitle':1,
    1099. 

  1099. 	    'tablecellaligntype':'column'
    1100. 

  1100. 	    },
    1101. 

  1101. 	  'mgp' : {
    1102. 

  1102. 	    'blankendmotherlist':1,
    1103. 

  1103. 	    'tagnotindentable':1,
    1104. 

  1104. 	    'spacedlistitem':1,
    1105. 

  1105. 	    'imgalignable':1,
    1106. 

  1106. 	    'autotocnewpagebefore':1,
    1107. 

  1107. 	    },
    1108. 

  1108. 	  'tex' : {
    1109. 

  1109. 	    'autonumberlist':1,
    1110. 

  1110. 	    'autonumbertitle':1,
    1111. 

  1111. 	    'spacedlistitem':1,
    1112. 

  1112. 	    'blankendmotherlist':1,
    1113. 

  1113. 	    'tableable':1,
    1114. 

  1114. 	    'tablecellstrip':1,
    1115. 

  1115. 	    'tabletitlerowinbold':1,
    1116. 

  1116. 	    'blankendtable':1,
    1117. 

  1117. 	    'verbblocknotescaped':1,
    1118. 

  1118. 	    'keeplistindent':1,
    1119. 

  1119. 	    'listmaxdepth':4,
    1120. 

  1120. 	    'barinsidequote':1,
    1121. 

  1121. 	    'finalescapetitle':1,
    1122. 

  1122. 	    'autotocnewpageafter':1,
    1123. 

  1123. 	    'mapbar2pagebreak':1,
    1124. 

  1124. 	    'tablecellaligntype':'column'
    1125. 

  1125. 	    },
    1126. 

  1126. 	  'lout': {
    1127. 

  1127. 	    'keepquoteindent':1,
    1128. 

  1128. 	    'escapeurl':1,
    1129. 

  1129. 	    'verbblocknotescaped':1,
    1130. 

  1130. 	    'tableable':0,
    1131. 

  1131. 	    'imgalignable':1,
    1132. 

  1132. 	    'mapbar2pagebreak':1,
    1133. 

  1133. 	    'titleblocks':1,
    1134. 

  1134. 	    'notbreakparaopen':1
    1135. 

  1135. 	    },
    1136. 

  1136. 	  'moin': {
    1137. 

  1137. 	    'spacedlistitem':1,
    1138. 

  1138. 	    'linkable':1,
    1139. 

  1139. 	    'blankendmotherlist':1,
    1140. 

  1140. 	    'keeplistindent':1,
    1141. 

  1141. 	    'tableable':1,
    1142. 

  1142. 	    'barinsidequote':1,
    1143. 

  1143. 	    'blankendtable':1,
    1144. 

  1144. 	    'tabletitlerowinbold':1,
    1145. 

  1145. 	    'tablecellstrip':1,
    1146. 

  1146. 	    'autotocwithbars':1,
    1147. 

  1147. 	    'tablecellaligntype':'cell'
    1148. 

  1148. 	    },
    1149. 

  1149. 	  'man' : {
    1150. 

  1150. 	    'spacedlistitem':1,
    1151. 

  1151. 	    'indentverbblock':1,
    1152. 

  1152. 	    'blankendmotherlist':1,
    1153. 

  1153. 	    'tagnotindentable':1,
    1154. 

  1154. 	    'tableable':1,
    1155. 

  1155. 	    'tablecellaligntype':'column',
    1156. 

  1156. 	    'tabletitlerowinbold':1,
    1157. 

  1157. 	    'tablecellstrip':1,
    1158. 

  1158. 	    'blankendtable':1,
    1159. 

  1159. 	    'keeplistindent':0,
    1160. 

  1160. 	    'barinsidequote':1,
    1161. 

  1161. 	    'parainsidelist':0,
    1162. 

  1162. 	    },
    1163. 

  1163. 	  'pm6' : {
    1164. 

  1164. 	    'keeplistindent':1,
    1165. 

  1165. 	    'verbblockfinalescape':1,
    1166. 

  1166. 	    #TODO add support for these - maybe set a JOINNEXT char and
    1167. 

  1167. 	    #     do it on addLineBreaks()
    1168. 

  1168. 	    'notbreaklistopen':1,
    1169. 

  1169. 	    'notbreakparaopen':1,
    1170. 

  1170. 	    'barinsidequote':1,
    1171. 

  1171. 	    'autotocwithbars':1,
    1172. 

  1172. 	    'onelinepara':1,
    1173. 

  1173. 	    }
    1174. 

  1174. 	}
    1175. 

  1175. 	
    1176. 

  1176. 	# exceptions for --css-sugar
    1177. 

  1177. 	if config['css-sugar'] and config['target'] in ('html','xhtml'):
    1178. 

  1178. 		rules_bank['html']['indentverbblock'] = 0
    1179. 

  1179. 		rules_bank['html']['autotocwithbars'] = 0
    1180. 

  1180. 	
    1181. 

  1181. 	# get the target specific rules
    1182. 

  1182. 	if config['target'] == 'xhtml':
    1183. 

  1183. 		myrules = rules_bank['html'].copy()   # inheritance
    1184. 

  1184. 		myrules.update(rules_bank['xhtml'])   # get XHTML specific
    1185. 

  1185. 	else:
    1186. 

  1186. 		myrules = rules_bank[config['target']].copy()
    1187. 

  1187. 	
    1188. 

  1188. 	# populate return dictionary
    1189. 

  1189. 	for key in allrules: ret[key] = 0        # reset all
    1190. 

  1190. 	ret.update(myrules)                      # get rules
    1191. 

  1191. 	
    1192. 

  1192. 	return ret
    1193. 

  1193. 

  1194. 

  1195. ##############################################################################
    1196. 

  1196. 

  1197. 

  1198. def getRegexes():
    1199. 

  1199. 	"Returns all the regexes used to find the t2t marks"
    1200. 

  1200. 	
    1201. 

  1201. 	bank = {
    1202. 

  1202. 	'blockVerbOpen':
    1203. 

  1203. 		re.compile(r'^```\s*$'),
    1204. 

  1204. 	'blockVerbClose':
    1205. 

  1205. 		re.compile(r'^```\s*$'),
    1206. 

  1206. 	'blockRawOpen':
    1207. 

  1207. 		re.compile(r'^"""\s*$'),
    1208. 

  1208. 	'blockRawClose':
    1209. 

  1209. 		re.compile(r'^"""\s*$'),
    1210. 

  1210. 	'quote':
    1211. 

  1211. 		re.compile(r'^\t+'),
    1212. 

  1212. 	'1lineVerb':
    1213. 

  1213. 		re.compile(r'^``` (?=.)'),
    1214. 

  1214. 	'1lineRaw':
    1215. 

  1215. 		re.compile(r'^""" (?=.)'),
    1216. 

  1216. 	# mono, raw, bold, italic, underline:
    1217. 

  1217. 	# - marks must be glued with the contents, no boundary spaces
    1218. 

  1218. 	# - they are greedy, so in ****bold****, turns to <b>**bold**</b>
    1219. 

  1219. 	'fontMono':
    1220. 

  1220. 		re.compile(  r'``([^\s](|.*?[^\s])`*)``'),
    1221. 

  1221. 	'raw':
    1222. 

  1222. 		re.compile(  r'""([^\s](|.*?[^\s])"*)""'),
    1223. 

  1223. 	'fontBold':
    1224. 

  1224. 		re.compile(r'\*\*([^\s](|.*?[^\s])\**)\*\*'),
    1225. 

  1225. 	'fontItalic':
    1226. 

  1226. 		re.compile(  r'//([^\s](|.*?[^\s])/*)//'),
    1227. 

  1227. 	'fontUnderline':
    1228. 

  1228. 		re.compile(  r'__([^\s](|.*?[^\s])_*)__'),
    1229. 

  1229. 	'list':
    1230. 

  1230. 		re.compile(r'^( *)(-) (?=[^ ])'),
    1231. 

  1231. 	'numlist':
    1232. 

  1232. 		re.compile(r'^( *)(\+) (?=[^ ])'),
    1233. 

  1233. 	'deflist':
    1234. 

  1234. 		re.compile(r'^( *)(:) (.*)$'),
    1235. 

  1235. 	'listclose':
    1236. 

  1236. 		re.compile(r'^( *)([-+:])\s*$'),
    1237. 

  1237. 	'bar':
    1238. 

  1238. 		re.compile(r'^(\s*)([_=-]{20,})\s*$'),
    1239. 

  1239. 	'table':
    1240. 

  1240. 		re.compile(r'^ *\|\|? '),
    1241. 

  1241. 	'blankline':
    1242. 

  1242. 		re.compile(r'^\s*$'),
    1243. 

  1243. 	'comment':
    1244. 

  1244. 		re.compile(r'^%'),
    1245. 

  1245. 	
    1246. 

  1246. 	# auxiliar tag regexes
    1247. 

  1247. 	'_imgAlign'        : re.compile(r'~A~', re.I),
    1248. 

  1248. 	'_tableAlign'      : re.compile(r'~A~', re.I),
    1249. 

  1249. 	'_anchor'          : re.compile(r'~A~', re.I),
    1250. 

  1250. 	'_tableBorder'     : re.compile(r'~B~', re.I),
    1251. 

  1251. 	'_tableColAlign'   : re.compile(r'~C~', re.I),
    1252. 

  1252. 	'_tableCellColSpan': re.compile(r'~S~', re.I),
    1253. 

  1253. 	'_tableCellAlign'  : re.compile(r'~A~', re.I),
    1254. 

  1254. 	}
    1255. 

  1255. 	
    1256. 

  1256. 	# special char to place data on TAGs contents  (\a == bell)
    1257. 

  1257. 	bank['x'] = re.compile('\a')
    1258. 

  1258. 	
    1259. 

  1259. 	# %%macroname [ (formatting) ]
    1260. 

  1260. 	bank['macros'] = re.compile(r'%%%%(?P<name>%s)\b(\((?P<fmt>.*?)\))?'%(
    1261. 

  1261. 	                            string.join(MACROS.keys(), '|')), re.I)
    1262. 

  1262. 	
    1263. 

  1263. 	# %%TOC special macro for TOC positioning
    1264. 

  1264. 	bank['toc'] = re.compile(r'^ *%%toc\s*$', re.I)
    1265. 

  1265. 	
    1266. 

  1266. 	# almost complicated title regexes ;)
    1267. 

  1267. 	titskel = r'^ *(?P<id>%s)(?P<txt>%s)\1(\[(?P<label>[\w-]*)\])?\s*$'
    1268. 

  1268. 	bank[   'title'] = re.compile(titskel%('[=]{1,5}','[^=](|.*[^=])'))
    1269. 

  1269. 	bank['numtitle'] = re.compile(titskel%('[+]{1,5}','[^+](|.*[^+])'))
    1270. 

  1270. 	
    1271. 

  1271. 	### complicated regexes begin here ;)
    1272. 

  1272. 	#
    1273. 

  1273. 	# textual descriptions on --help's style: [...] is optional, | is OR
    1274. 

  1274. 	
    1275. 

  1275. 	
    1276. 

  1276. 	### first, some auxiliar variables
    1277. 

  1277. 	#
    1278. 

  1278. 	
    1279. 

  1279. 	# [image.EXT]
    1280. 

  1280. 	patt_img = r'\[([\w_,.+%$#@!?+~/-]+\.(png|jpe?g|gif|eps|bmp))\]'
    1281. 

  1281. 	
    1282. 

  1282. 	# link things
    1283. 

  1283. 	urlskel = {
    1284. 

  1284. 	  'proto' : r'(https?|ftp|news|telnet|gopher|wais)://',
    1285. 

  1285. 	  'guess' : r'(www[23]?|ftp)\.',         # w/out proto, try to guess
    1286. 

  1286. 	  'login' : r'A-Za-z0-9_.-',             # for ftp://login@domain.com
    1287. 

  1287. 	  'pass'  : r'[^ @]*',                   # for ftp://login:pass@dom.com
    1288. 

  1288. 	  'chars' : r'A-Za-z0-9%._/~:,=$@&+-',   # %20(space), :80(port), D&D
    1289. 

  1289. 	  'anchor': r'A-Za-z0-9%._-',            # %nn(encoded)
    1290. 

  1290. 	  'form'  : r'A-Za-z0-9/%&=+;.,$@*_-',   # .,@*_-(as is)
    1291. 

  1291. 	  'punct' : r'.,;:!?'
    1292. 

  1292. 	}
    1293. 

  1293. 	
    1294. 

  1294. 	# username [ :password ] @
    1295. 

  1295. 	patt_url_login = r'([%s]+(:%s)?@)?'%(urlskel['login'],urlskel['pass'])
    1296. 

  1296. 	
    1297. 

  1297. 	# [ http:// ] [ username:password@ ] domain.com [ / ]
    1298. 

  1298. 	#     [ #anchor | ?form=data ]
    1299. 

  1299. 	retxt_url = r'\b(%s%s|%s)[%s]+\b/*(\?[%s]+)?(#[%s]+)?'%(
    1300. 

  1300. 	             urlskel['proto'],patt_url_login, urlskel['guess'],
    1301. 

  1301. 	             urlskel['chars'],urlskel['form'],urlskel['anchor'])
    1302. 

  1302. 	
    1303. 

  1303. 	# filename | [ filename ] #anchor
    1304. 

  1304. 	retxt_url_local = r'[%s]+|[%s]*(#[%s]+)'%(
    1305. 

  1305. 	             urlskel['chars'],urlskel['chars'],urlskel['anchor'])
    1306. 

  1306. 	
    1307. 

  1307. 	# user@domain [ ?form=data ]
    1308. 

  1308. 	patt_email = r'\b[%s]+@([A-Za-z0-9_-]+\.)+[A-Za-z]{2,4}\b(\?[%s]+)?'%(
    1309. 

  1309. 	             urlskel['login'],urlskel['form'])
    1310. 

  1310. 	
    1311. 

  1311. 	# saving for future use
    1312. 

  1312. 	bank['_urlskel'] = urlskel
    1313. 

  1313. 	
    1314. 

  1314. 	### and now the real regexes
    1315. 

  1315. 	#
    1316. 

  1316. 	
    1317. 

  1317. 	bank['email'] = re.compile(patt_email,re.I)
    1318. 

  1318. 	
    1319. 

  1319. 	# email | url
    1320. 

  1320. 	bank['link'] = re.compile(r'%s|%s'%(retxt_url,patt_email), re.I)
    1321. 

  1321. 	
    1322. 

  1322. 	# \[ label | imagetag    url | email | filename \]
    1323. 

  1323. 	bank['linkmark'] = re.compile(
    1324. 

  1324. 		r'\[(?P<label>%s|[^]]+) (?P<link>%s|%s|%s)\]'%(
    1325. 

  1325. 		  patt_img, retxt_url, patt_email, retxt_url_local),
    1326. 

  1326. 		re.L+re.I)
    1327. 

  1327. 	
    1328. 

  1328. 	# image
    1329. 

  1329. 	bank['img'] = re.compile(patt_img, re.L+re.I)
    1330. 

  1330. 	
    1331. 

  1331. 	# special things
    1332. 

  1332. 	bank['special'] = re.compile(r'^%!\s*')
    1333. 

  1333. 	return bank
    1334. 

  1334. ### END OF regex nightmares
    1335. 

  1335. 

  1336. 

  1337. ##############################################################################
    1338. 

  1338. 

  1339. class error(Exception):
    1340. 

  1340. 	pass
    1341. 

  1341. def echo(msg):   # for quick debug
    1342. 

  1342. 	print '\033[32;1m%s\033[m'%msg
    1343. 

  1343. def Quit(msg=''):
    1344. 

  1344. 	if msg: print msg
    1345. 

  1345. 	sys.exit(0)
    1346. 

  1346. def Error(msg):
    1347. 

  1347. 	msg = _("%s: Error: ")%my_name + msg
    1348. 

  1348. 	raise error, msg
    1349. 

  1349. def getTraceback():
    1350. 

  1350. 	try:
    1351. 

  1351. 		from traceback import format_exception
    1352. 

  1352. 		etype, value, tb = sys.exc_info()
    1353. 

  1353. 		return string.join(format_exception(etype, value, tb), '')
    1354. 

  1354. 	except: pass
    1355. 

  1355. def getUnknownErrorMessage():
    1356. 

  1356. 	msg = '%s\n%s (%s):\n\n%s'%(
    1357. 

  1357. 	  _('Sorry! Txt2tags aborted by an unknow error.'),
    1358. 

  1358. 	  _('Please send the following Error Traceback to the author'),
    1359. 

  1359. 	  my_email, getTraceback())
    1360. 

  1360. 	return msg
    1361. 

  1361. def Message(msg,level):
    1362. 

  1362. 	if level <= VERBOSE and not QUIET:
    1363. 

  1363. 		prefix = '-'*5
    1364. 

  1364. 		print "%s %s"%(prefix*level, msg)
    1365. 

  1365. def Debug(msg,id=0,linenr=None):
    1366. 

  1366. 	"Show debug messages, categorized (colored or not)"
    1367. 

  1367. 	if QUIET or not DEBUG: return
    1368. 

  1368. 	if int(id) not in range(8): id = 0
    1369. 

  1369. 	# 0:black 1:red 2:green 3:yellow 4:blue 5:pink 6:cyan 7:white ;1:light
    1370. 

  1370. 	ids            = ['INI','CFG','SRC','BLK','HLD','GUI','OUT','DET']
    1371. 

  1371. 	colors_bgdark  = ['7;1','1;1','3;1','6;1','4;1','5;1','2;1','7;1']
    1372. 

  1372. 	colors_bglight = ['0'  ,'1'  ,'3'  ,'6'  ,'4'  ,'5'  ,'2'  ,'0'  ]
    1373. 

  1373. 	if linenr is not None: msg = "LINE %04d: %s"%(linenr,msg)
    1374. 

  1374. 	if COLOR_DEBUG:
    1375. 

  1375. 		if BG_LIGHT: color = colors_bglight[id]
    1376. 

  1376. 		else       : color = colors_bgdark[id]
    1377. 

  1377. 		msg = '\033[3%sm%s\033[m'%(color,msg)
    1378. 

  1378. 	print "++ %s: %s"%(ids[id],msg)
    1379. 

  1379. def Readfile(file, remove_linebreaks=0, ignore_error=0):
    1380. 

  1380. 	data = []
    1381. 

  1381. 	if file == '-':
    1382. 

  1382. 		try: data = sys.stdin.readlines()
    1383. 

  1383. 		except:
    1384. 

  1384. 			if not ignore_error:
    1385. 

  1385. 				Error(_('You must feed me with data on STDIN!'))
    1386. 

  1386. 	else:
    1387. 

  1387. 		try: f = open(file); data = f.readlines() ; f.close()
    1388. 

  1388. 		except:
    1389. 

  1389. 			if not ignore_error:
    1390. 

  1390. 				Error(_("Cannot read file:")+" %s"%file)
    1391. 

  1391. 	if remove_linebreaks:
    1392. 

  1392. 		data = map(lambda x:re.sub('[\n\r]+$','',x), data)
    1393. 

  1393. 	Message(_("Readed file (%d lines): %s")%(len(data),file),2)
    1394. 

  1394. 	return data
    1395. 

  1395. def Savefile(file, contents):
    1396. 

  1396. 	try: f = open(file, 'wb')
    1397. 

  1397. 	except: Error(_("Cannot open file for writing:")+" %s"%file)
    1398. 

  1398. 	if type(contents) == type([]): doit = f.writelines
    1399. 

  1399. 	else: doit = f.write
    1400. 

  1400. 	doit(contents) ; f.close()
    1401. 

  1401. 

  1402. def showdic(dic):
    1403. 

  1403. 	for k in dic.keys(): print "%15s : %s" % (k,dic[k])
    1404. 

  1404. def dotted_spaces(txt=''):
    1405. 

  1405. 	return string.replace(txt,' ','.')
    1406. 

  1406. 

  1407. # TIP: win env vars http://www.winnetmag.com/Article/ArticleID/23873/23873.html
    1408. 

  1408. def get_rc_path():
    1409. 

  1409. 	"Return the full path for the users' RC file"
    1410. 

  1410. 	# try to get the path from an env var. if yes, we're done
    1411. 

  1411. 	user_defined = os.environ.get('T2TCONFIG')
    1412. 

  1412. 	if user_defined: return user_defined
    1413. 

  1413. 	# env var not found, so perform automatic path composing
    1414. 

  1414. 	# set default filename according system platform
    1415. 

  1415. 	rc_names = {'default':'.txt2tagsrc', 'win':'_t2trc'}
    1416. 

  1416. 	rc_file = rc_names.get(sys.platform[:3]) or rc_names['default']
    1417. 

  1417. 	# the file must be on the user directory, but where is this dir?
    1418. 

  1418. 	rc_dir_search = ['HOME', 'HOMEPATH']
    1419. 

  1419. 	for var in rc_dir_search:
    1420. 

  1420. 		rc_dir = os.environ.get(var)
    1421. 

  1421. 		if rc_dir: break
    1422. 

  1422. 	# rc dir found, now we must join dir+file to compose the full path
    1423. 

  1423. 	if rc_dir:
    1424. 

  1424. 		# compose path and return it if the file exists
    1425. 

  1425. 		rc_path = os.path.join(rc_dir, rc_file)
    1426. 

  1426. 		# on windows, prefix with the drive (%homedrive%: 2k/XP/NT)
    1427. 

  1427. 		if sys.platform[:3] == 'win':
    1428. 

  1428. 			rc_drive = os.environ.get('HOMEDRIVE')
    1429. 

  1429. 			rc_path = os.path.join(rc_drive,rc_path)
    1430. 

  1430. 		return rc_path
    1431. 

  1431. 	# sorry, not found
    1432. 

  1432. 	return ''
    1433. 

  1433. 

  1434. 

  1435. 

  1436. ##############################################################################
    1437. 

  1437. 

  1438. class CommandLine:
    1439. 

  1439. 	"""
    1440. 

  1440. 	Command Line class - Masters command line
    1441. 

  1441. 

  1442. 	This class checks and extract data from the provided command line.
    1443. 

  1443. 	The --long options and flags are taken from the global OPTIONS,
    1444. 

  1444. 	FLAGS and ACTIONS dictionaries. The short options are registered
    1445. 

  1445. 	here, and also their equivalence to the long ones.
    1446. 

  1446. 

  1447. 	METHODS:
    1448. 

  1448. 	  _compose_short_opts() -> str
    1449. 

  1449. 	  _compose_long_opts() -> list
    1450. 

  1450. 	      Compose the valid short and long options list, on the
    1451. 

  1451. 	      'getopt' format.
    1452. 

  1452. 	  
    1453. 

  1453. 	  parse() -> (opts, args)
    1454. 

  1454. 	      Call getopt to check and parse the command line.
    1455. 

  1455. 	      It expects to receive the command line as a list, and
    1456. 

  1456. 	      without the program name (sys.argv[1:]).
    1457. 

  1457. 	  
    1458. 

  1458. 	  get_raw_config() -> [RAW config]
    1459. 

  1459. 	      Scans command line and convert the data to the RAW config
    1460. 

  1460. 	      format. See ConfigMaster class to the RAW format description.
    1461. 

  1461. 	      Optional 'ignore' and 'filter' arguments are used to filter
    1462. 

  1462. 	      in or out specified keys.
    1463. 

  1463. 	  
    1464. 

  1464. 	  compose_cmdline(dict) -> [Command line]
    1465. 

  1465. 	      Compose a command line list from an already parsed config
    1466. 

  1466. 	      dictionary, generated from RAW by ConfigMaster(). Use
    1467. 

  1467. 	      this to compose an optimal command line for a group of
    1468. 

  1468. 	      options.
    1469. 

  1469. 	
    1470. 

  1470. 	The get_raw_config() calls parse(), so the tipical use of this
    1471. 

  1471. 	class is:
    1472. 

  1472. 	
    1473. 

  1473.             raw = CommandLine().get_raw_config(sys.argv[1:])
    1474. 

  1474. 	"""
    1475. 

  1475. 	def __init__(self):
    1476. 

  1476. 		self.all_options = OPTIONS.keys()
    1477. 

  1477. 		self.all_flags   = FLAGS.keys()
    1478. 

  1478. 		self.all_actions = ACTIONS.keys()
    1479. 

  1479. 		
    1480. 

  1480. 		# short:long options equivalence
    1481. 

  1481. 		self.short_long = {
    1482. 

  1482. 		  'h':'help'     ,   'V':'version',
    1483. 

  1483. 		  'n':'enum-title',  'i':'infile' ,
    1484. 

  1484. 		  'H':'no-headers',  'o':'outfile',
    1485. 

  1485. 		  'v':'verbose'   ,  't':'target' ,
    1486. 

  1486. 		  'q':'quiet'     ,  'C':'config-file'
    1487. 

  1487. 		}
    1488. 

  1488. 		
    1489. 

  1489. 		# compose valid short and long options data for getopt
    1490. 

  1490. 		self.short_opts = self._compose_short_opts()
    1491. 

  1491. 		self.long_opts  = self._compose_long_opts()
    1492. 

  1492. 	
    1493. 

  1493. 	def _compose_short_opts(self):
    1494. 

  1494. 		"Returns a string like 'hVt:o' with all short options/flags"
    1495. 

  1495. 		ret = []
    1496. 

  1496. 		for opt in self.short_long.keys():
    1497. 

  1497. 			long = self.short_long[opt]
    1498. 

  1498. 			if long in self.all_options: # is flag or option?
    1499. 

  1499. 				opt = opt+':'        # option: have param
    1500. 

  1500. 			ret.append(opt)
    1501. 

  1501. 		#Debug('Valid SHORT options: %s'%ret)
    1502. 

  1502. 		return string.join(ret, '')
    1503. 

  1503. 	
    1504. 

  1504. 	def _compose_long_opts(self):
    1505. 

  1505. 		"Returns a list with all the valid long options/flags"
    1506. 

  1506. 		ret = map(lambda x:x+'=', self.all_options)          # add =
    1507. 

  1507. 		ret.extend(self.all_flags)                           # flag ON
    1508. 

  1508. 		ret.extend(self.all_actions)                         # acts
    1509. 

  1509. 		ret.extend(map(lambda x:'no-'+x, self.all_flags))    # add no-*
    1510. 

  1510. 		ret.extend(['no-style','no-encoding'])               # turn OFF
    1511. 

  1511. 		ret.extend(['no-outfile','no-infile'])               # turn OFF
    1512. 

  1512. 		ret.extend(['no-dump-config', 'no-dump-source'])     # turn OFF
    1513. 

  1513. 		#Debug('Valid LONG options: %s'%ret)
    1514. 

  1514. 		return ret
    1515. 

  1515. 	
    1516. 

  1516. 	def _tokenize(self, cmd_string=''):
    1517. 

  1517. 		"Convert a command line string to a list"
    1518. 

  1518. 		#TODO protect quotes contents
    1519. 

  1519. 		return string.split(cmd_string)
    1520. 

  1520. 	
    1521. 

  1521. 	def parse(self, cmdline=[]):
    1522. 

  1522. 		"Check/Parse a command line list     TIP: no program name!"
    1523. 

  1523. 		# get the valid options
    1524. 

  1524. 		short, long = self.short_opts, self.long_opts
    1525. 

  1525. 		# parse it!
    1526. 

  1526. 		try:
    1527. 

  1527. 			opts, args = getopt.getopt(cmdline, short, long)
    1528. 

  1528. 		except getopt.error, errmsg:
    1529. 

  1529. 			Error(_("%s (try --help)")%errmsg)
    1530. 

  1530. 		return (opts, args)
    1531. 

  1531. 	
    1532. 

  1532. 	def get_raw_config(self, cmdline=[], ignore=[], filter=[], relative=0):
    1533. 

  1533. 		"Returns the options/arguments found as RAW config"
    1534. 

  1534. 		if not cmdline: return []
    1535. 

  1535. 		ret = []
    1536. 

  1536. 		# we need lists, not strings
    1537. 

  1537. 		if type(cmdline) == type(''): cmdline = self._tokenize(cmdline)
    1538. 

  1538. 		opts, args = self.parse(cmdline[:])
    1539. 

  1539. 		# parse all options
    1540. 

  1540. 		for name,value in opts:
    1541. 

  1541. 			# remove leading - and --
    1542. 

  1542. 			name = re.sub('^--?', '', name)
    1543. 

  1543. 			# alias to old mispelled 'suGGar'
    1544. 

  1544. 			if   name ==    'css-suggar': name =    'css-sugar'
    1545. 

  1545. 			elif name == 'no-css-suggar': name = 'no-css-sugar'
    1546. 

  1546. 			# translate short opt to long
    1547. 

  1547. 			if len(name) == 1: name = self.short_long.get(name)
    1548. 

  1548. 			# outfile exception: path relative to PWD
    1549. 

  1549. 			if name == 'outfile' and relative \
    1550. 

  1550. 			   and value not in [STDOUT, MODULEOUT]:
    1551. 

  1551. 				value = os.path.abspath(value)
    1552. 

  1552. 			# config-file inclusion, path relative to PWD
    1553. 

  1553. 			if name == 'config-file':
    1554. 

  1554. 				configs = ConfigLines().include_config_file(
    1555. 

  1555. 				          value)
    1556. 

  1556. 				# remove the 'target' item of all configs
    1557. 

  1557. 				configs = map(lambda c: [c[1],c[2]], configs)
    1558. 

  1558. 				ret.extend(configs)
    1559. 

  1559. 				continue
    1560. 

  1560. 			# save it
    1561. 

  1561. 			ret.append([name, value])
    1562. 

  1562. 		# get infile, if any
    1563. 

  1563. 		while args:
    1564. 

  1564. 			infile = args.pop(0)
    1565. 

  1565. 			ret.append(['infile', infile])
    1566. 

  1566. 		# apply 'ignore' and 'filter' rules (filter is stronger)
    1567. 

  1567. 		temp = ret[:] ; ret = []
    1568. 

  1568. 		for name,value in temp:
    1569. 

  1569. 			if (not filter and not ignore) or \
    1570. 

  1570. 			   (filter and name in filter) or \
    1571. 

  1571. 			   (ignore and name not in ignore):
    1572. 

  1572. 				ret.append( ['all', name, value] )
    1573. 

  1573. 		# add the original command line string as 'realcmdline'
    1574. 

  1574. 		ret.append( ['all', 'realcmdline', cmdline] )
    1575. 

  1575. 		return ret
    1576. 

  1576. 	
    1577. 

  1577. 	def compose_cmdline(self, conf={}, no_check=0):
    1578. 

  1578. 		"compose a full (and diet) command line from CONF dict"
    1579. 

  1579. 		if not conf: return []
    1580. 

  1580. 		args = []
    1581. 

  1581. 		dft_options = OPTIONS.copy()
    1582. 

  1582. 		cfg = conf.copy()
    1583. 

  1583. 		valid_opts = self.all_options + self.all_flags
    1584. 

  1584. 		use_short = {'no-headers':'H', 'enum-title':'n'}
    1585. 

  1585. 		# remove useless options
    1586. 

  1586. 		if not no_check and cfg.get('toc-only'):
    1587. 

  1587. 			if cfg.has_key('no-headers'):
    1588. 

  1588. 				del cfg['no-headers']
    1589. 

  1589. 			if cfg.has_key('outfile'):
    1590. 

  1590. 				del cfg['outfile']      # defaults to STDOUT
    1591. 

  1591. 			if cfg.get('target') == 'txt':
    1592. 

  1592. 				del cfg['target']       # already default
    1593. 

  1593. 			args.append('--toc-only')  # must be the first
    1594. 

  1594. 			del cfg['toc-only']
    1595. 

  1595. 		# add target type
    1596. 

  1596. 		if cfg.has_key('target'):
    1597. 

  1597. 			args.append('-t '+cfg['target'])
    1598. 

  1598. 			del cfg['target']
    1599. 

  1599. 		# add other options
    1600. 

  1600. 		for key in cfg.keys():
    1601. 

  1601. 			if key not in valid_opts: continue  # may be a %!setting
    1602. 

  1602. 			if key in ['outfile','infile']: continue   # later
    1603. 

  1603. 			val = cfg[key]
    1604. 

  1604. 			if not val: continue
    1605. 

  1605. 			# default values are useless on cmdline
    1606. 

  1606. 			if val == dft_options.get(key): continue
    1607. 

  1607. 			# -short format
    1608. 

  1608. 			if key in use_short.keys():
    1609. 

  1609. 				args.append('-'+use_short[key])
    1610. 

  1610. 				continue
    1611. 

  1611. 			# --long format
    1612. 

  1612. 			if key in self.all_flags: # add --option
    1613. 

  1613. 				args.append('--'+key)
    1614. 

  1614. 			else:                     # add --option=value
    1615. 

  1615. 				args.append('--%s=%s'%(key,val))
    1616. 

  1616. 		# the outfile using -o
    1617. 

  1617. 		if cfg.has_key('outfile') and \
    1618. 

  1618. 		   cfg['outfile'] != dft_options.get('outfile'):
    1619. 

  1619. 			args.append('-o '+cfg['outfile'])
    1620. 

  1620. 		# place input file(s) always at the end
    1621. 

  1621. 		if cfg.has_key('infile'):
    1622. 

  1622. 			args.append(string.join(cfg['infile'],' '))
    1623. 

  1623. 		# return as a nice list
    1624. 

  1624. 		Debug("Diet command line: %s"%string.join(args,' '), 1)
    1625. 

  1625. 		return args
    1626. 

  1626. 

  1627. ##############################################################################
    1628. 

  1628. 

  1629. class SourceDocument:
    1630. 

  1630. 	"""
    1631. 

  1631. 	SourceDocument class - scan document structure, extract data
    1632. 

  1632. 	
    1633. 

  1633. 	It knows about full files. It reads a file and identify all
    1634. 

  1634. 	the areas begining (Head,Conf,Body). With this info it can
    1635. 

  1635. 	extract each area contents.
    1636. 

  1636. 	Note: the original line break is removed.
    1637. 

  1637. 	
    1638. 

  1638. 	DATA:
    1639. 

  1639. 	  self.arearef - Save Head, Conf, Body init line number
    1640. 

  1640. 	  self.areas   - Store the area names which are not empty
    1641. 

  1641. 	  self.buffer  - The full file contents (with NO \\r, \\n)
    1642. 

  1642. 

  1643. 	METHODS:
    1644. 

  1644. 	  get()   - Access the contents of an Area. Example:
    1645. 

  1645. 	            config = SourceDocument(file).get('conf')
    1646. 

  1646. 	
    1647. 

  1647. 	  split() - Get all the document Areas at once. Example:
    1648. 

  1648. 	            head, conf, body = SourceDocument(file).split()
    1649. 

  1649. 	
    1650. 

  1650. 	RULES:
    1651. 

  1651. 	    * The document parts are sequential: Head, Conf and Body.
    1652. 

  1652. 	    * One ends when the next begins.
    1653. 

  1653. 	    * The Conf Area is optional, so a document can have just
    1654. 

  1654. 	      Head and Body Areas.
    1655. 

  1655. 	
    1656. 

  1656. 	    These are the Areas limits:
    1657. 

  1657. 	      - Head Area: the first three lines
    1658. 

  1658. 	      - Body Area: from the first valid text line to the end
    1659. 

  1659. 	      - Conf Area: the comments between Head and Body Areas
    1660. 

  1660. 

  1661. 	    Exception: If the first line is blank, this means no
    1662. 

  1662. 	    header info, so the Head Area is just the first line.
    1663. 

  1663. 	"""
    1664. 

  1664. 	def __init__(self, filename='', contents=[]):
    1665. 

  1665. 		self.areas = ['head','conf','body']
    1666. 

  1666. 		self.arearef = []
    1667. 

  1667. 		self.areas_fancy = ''
    1668. 

  1668. 		self.filename = filename
    1669. 

  1669. 		self.buffer = []
    1670. 

  1670. 		if filename:
    1671. 

  1671. 			self.scan_file(filename)
    1672. 

  1672. 		elif contents:
    1673. 

  1673. 			self.scan(contents)
    1674. 

  1674. 	
    1675. 

  1675. 	def split(self):
    1676. 

  1676. 		"Returns all document parts, splitted into lists."
    1677. 

  1677. 		return self.get('head'), self.get('conf'), self.get('body')
    1678. 

  1678. 	
    1679. 

  1679. 	def get(self, areaname):
    1680. 

  1680. 		"Returns head|conf|body contents from self.buffer"
    1681. 

  1681. 		# sanity
    1682. 

  1682. 		if areaname not in self.areas: return []
    1683. 

  1683. 		if not self.buffer           : return []
    1684. 

  1684. 		# go get it
    1685. 

  1685. 		bufini = 1
    1686. 

  1686. 		bufend = len(self.buffer)
    1687. 

  1687. 		if   areaname == 'head':
    1688. 

  1688. 			ini = bufini
    1689. 

  1689. 			end = self.arearef[1] or self.arearef[2] or bufend
    1690. 

  1690. 		elif areaname == 'conf':
    1691. 

  1691. 			ini = self.arearef[1]
    1692. 

  1692. 			end = self.arearef[2] or bufend
    1693. 

  1693. 		elif areaname == 'body':
    1694. 

  1694. 			ini = self.arearef[2]
    1695. 

  1695. 			end = bufend
    1696. 

  1696. 		else:
    1697. 

  1697. 			Error("Unknown Area name '%s'"%areaname)
    1698. 

  1698. 		lines = self.buffer[ini:end]
    1699. 

  1699. 		# make sure head will always have 3 lines
    1700. 

  1700. 		while areaname == 'head' and len(lines) < 3:
    1701. 

  1701. 			lines.append('')
    1702. 

  1702. 		return lines
    1703. 

  1703. 	
    1704. 

  1704. 	def scan_file(self, filename):
    1705. 

  1705. 		Debug("source file: %s"%filename)
    1706. 

  1706. 		Message(_("Loading source document"),1)
    1707. 

  1707. 		buf = Readfile(filename, remove_linebreaks=1)
    1708. 

  1708. 		self.scan(buf)
    1709. 

  1709. 	
    1710. 

  1710. 	def scan(self, lines):
    1711. 

  1711. 		"Run through source file and identify head/conf/body areas"
    1712. 

  1712. 		buf = lines
    1713. 

  1713. 		if len(buf) == 0:
    1714. 

  1714. 			Error(_('The input file is empty: %s')%self.filename)
    1715. 

  1715. 		cfg_parser = ConfigLines().parse_line
    1716. 

  1716. 		buf.insert(0, '')                         # text start at pos 1
    1717. 

  1717. 		ref = [1,4,0]
    1718. 

  1718. 		if not string.strip(buf[1]):              # no header
    1719. 

  1719. 			ref[0] = 0 ; ref[1] = 2
    1720. 

  1720. 		rgx = getRegexes()
    1721. 

  1721. 		for i in range(ref[1],len(buf)):          # find body init:
    1722. 

  1722. 			if string.strip(buf[i]) and (     # ... not blank and
    1723. 

  1723. 			   buf[i][0] != '%' or            # ... not comment or
    1724. 

  1724. 			   rgx['macros'].match(buf[i]) or # ... %%macro
    1725. 

  1725. 			   rgx['toc'].match(buf[i])    or # ... %%toc
    1726. 

  1726. 			   cfg_parser(buf[i],'include')[1]): # ... %!include
    1727. 

  1727. 				ref[2] = i ; break
    1728. 

  1728. 		if ref[1] == ref[2]: ref[1] = 0           # no conf area
    1729. 

  1729. 		for i in 0,1,2:                           # del !existent
    1730. 

  1730. 			if ref[i] >= len(buf): ref[i] = 0 # title-only
    1731. 

  1731. 			if not ref[i]: self.areas[i] = ''
    1732. 

  1732. 		Debug('Head,Conf,Body start line: %s'%ref)
    1733. 

  1733. 		self.arearef = ref                        # save results
    1734. 

  1734. 		self.buffer  = buf
    1735. 

  1735. 		# fancyness sample: head conf body (1 4 8)
    1736. 

  1736. 		self.areas_fancy = "%s (%s)"%(
    1737. 

  1737. 		     string.join(self.areas),
    1738. 

  1738. 		     string.join(map(str, map(lambda x:x or '', ref))))
    1739. 

  1739. 		Message(_("Areas found: %s")%self.areas_fancy, 2)
    1740. 

  1740. 	
    1741. 

  1741. 	def get_raw_config(self):
    1742. 

  1742. 		"Handy method to get the CONF area RAW config (if any)"
    1743. 

  1743. 		if not self.areas.count('conf'): return []
    1744. 

  1744. 		Message(_("Scanning source document CONF area"),1)
    1745. 

  1745. 		raw = ConfigLines(
    1746. 

  1746. 		      file=self.filename, lines=self.get('conf'),
    1747. 

  1747. 		      first_line=self.arearef[1]).get_raw_config()
    1748. 

  1748. 		Debug("document raw config: %s"%raw, 1)
    1749. 

  1749. 		return raw
    1750. 

  1750. 

  1751. ##############################################################################
    1752. 

  1752. 

  1753. class ConfigMaster:
    1754. 

  1754. 	"""
    1755. 

  1755. 	ConfigMaster class - the configuration wizard
    1756. 

  1756. 	
    1757. 

  1757. 	This class is the configuration master. It knows how to handle
    1758. 

  1758. 	the RAW and PARSED config format. It also performs the sanity
    1759. 

  1759. 	checkings for a given configuration.
    1760. 

  1760. 	
    1761. 

  1761. 	DATA:
    1762. 

  1762. 	  self.raw         - Stores the config on the RAW format
    1763. 

  1763. 	  self.parsed      - Stores the config on the PARSED format
    1764. 

  1764. 	  self.defaults    - Stores the default values for all keys
    1765. 

  1765. 	  self.off         - Stores the OFF values for all keys
    1766. 

  1766. 	  self.multi       - List of keys which can have multiple values
    1767. 

  1767. 	  self.numeric     - List of keys which value must be a number
    1768. 

  1768. 	  self.incremental - List of keys which are incremental
    1769. 

  1769. 	
    1770. 

  1770.         RAW FORMAT:
    1771. 

  1771. 	  The RAW format is a list of lists, being each mother list item
    1772. 

  1772. 	  a full configuration entry. Any entry is a 3 item list, on
    1773. 

  1773. 	  the following format: [ TARGET, KEY, VALUE ]
    1774. 

  1774. 	  Being a list, the order is preserved, so it's easy to use
    1775. 

  1775. 	  different kinds of configs, as CONF area and command line,
    1776. 

  1776. 	  respecting the precedence.
    1777. 

  1777. 	  The special target 'all' is used when no specific target was
    1778. 

  1778. 	  defined on the original config.
    1779. 

  1779. 	
    1780. 

  1780. 	PARSED FORMAT:
    1781. 

  1781. 	  The PARSED format is a dictionary, with all the 'key : value'
    1782. 

  1782. 	  found by reading the RAW config. The self.target contents
    1783. 

  1783. 	  matters, so this dictionary only contains the target's
    1784. 

  1784. 	  config. The configs of other targets are ignored.
    1785. 

  1785. 	
    1786. 

  1786. 	The CommandLine and ConfigLines classes have the get_raw_config()
    1787. 

  1787. 	method which convert the configuration found to the RAW format.
    1788. 

  1788. 	Just feed it to parse() and get a brand-new ready-to-use config
    1789. 

  1789. 	dictionary. Example:
    1790. 

  1790. 	
    1791. 

  1791. 	    >>> raw = CommandLine().get_raw_config(['-n', '-H'])
    1792. 

  1792. 	    >>> print raw
    1793. 

  1793. 	    [['all', 'enum-title', ''], ['all', 'no-headers', '']]
    1794. 

  1794. 	    >>> parsed = ConfigMaster(raw).parse()
    1795. 

  1795. 	    >>> print parsed
    1796. 

  1796. 	    {'enum-title': 1, 'headers': 0}
    1797. 

  1797. 	"""
    1798. 

  1798. 	def __init__(self, raw=[], target=''):
    1799. 

  1799. 		self.raw          = raw
    1800. 

  1800. 		self.target       = target
    1801. 

  1801. 		self.parsed       = {}
    1802. 

  1802. 		self.dft_options  = OPTIONS.copy()
    1803. 

  1803. 		self.dft_flags    = FLAGS.copy()
    1804. 

  1804. 		self.dft_actions  = ACTIONS.copy()
    1805. 

  1805. 		self.dft_settings = SETTINGS.copy()
    1806. 

  1806. 		self.defaults     = self._get_defaults()
    1807. 

  1807. 		self.off          = self._get_off()
    1808. 

  1808. 		self.multi        = ['infile', 'options','preproc','postproc']
    1809. 

  1809. 		self.incremental  = ['verbose']
    1810. 

  1810. 		self.numeric      = ['toc-level','split']
    1811. 

  1811. 	
    1812. 

  1812. 	def _get_defaults(self):
    1813. 

  1813. 		"Get the default values for all config/options/flags"
    1814. 

  1814. 		empty = {}
    1815. 

  1815. 		for kw in CONFIG_KEYWORDS: empty[kw] = ''
    1816. 

  1816. 		empty.update(self.dft_options)
    1817. 

  1817. 		empty.update(self.dft_flags)
    1818. 

  1818. 		empty.update(self.dft_actions)
    1819. 

  1819. 		empty.update(self.dft_settings)
    1820. 

  1820. 		empty['realcmdline'] = ''  # internal use only
    1821. 

  1821. 		empty['sourcefile']  = ''  # internal use only
    1822. 

  1822. 		return empty
    1823. 

  1823. 	
    1824. 

  1824. 	def _get_off(self):
    1825. 

  1825. 		"Turns OFF all the config/options/flags"
    1826. 

  1826. 		off = {}
    1827. 

  1827. 		for key in self.defaults.keys():
    1828. 

  1828. 			kind = type(self.defaults[key])
    1829. 

  1829. 			if kind == type(9):
    1830. 

  1830. 				off[key] = 0
    1831. 

  1831. 			elif kind == type(''):
    1832. 

  1832. 				off[key] = ''
    1833. 

  1833. 			elif kind == type([]):
    1834. 

  1834. 				off[key] = []
    1835. 

  1835. 			else:
    1836. 

  1836. 				Error('ConfigMaster: %s: Unknown type'+key)
    1837. 

  1837. 		return off
    1838. 

  1838. 	
    1839. 

  1839. 	def _check_target(self):
    1840. 

  1840. 		"Checks if the target is already defined. If not, do it"
    1841. 

  1841. 		if not self.target:
    1842. 

  1842. 			self.target = self.find_value('target')
    1843. 

  1843. 	
    1844. 

  1844. 	def get_target_raw(self):
    1845. 

  1845. 		"Returns the raw config for self.target or 'all'"
    1846. 

  1846. 		ret = []
    1847. 

  1847. 		self._check_target()
    1848. 

  1848. 		for entry in self.raw:
    1849. 

  1849. 			if entry[0] in [self.target, 'all']:
    1850. 

  1850. 				ret.append(entry)
    1851. 

  1851. 		return ret
    1852. 

  1852. 	
    1853. 

  1853. 	def add(self, key, val):
    1854. 

  1854. 		"Adds the key:value pair to the config dictionary (if needed)"
    1855. 

  1855. 		# %!options
    1856. 

  1856. 		if key == 'options':
    1857. 

  1857. 			ignoreme = self.dft_actions.keys() + ['target']
    1858. 

  1858. 			ignoreme.remove('dump-config')
    1859. 

  1859. 			ignoreme.remove('dump-source')
    1860. 

  1860. 			raw_opts = CommandLine().get_raw_config(
    1861. 

  1861. 			             val, ignore=ignoreme)
    1862. 

  1862. 			for target, key, val in raw_opts:
    1863. 

  1863. 				self.add(key, val)
    1864. 

  1864. 			return
    1865. 

  1865. 		# the no- prefix turns OFF this key
    1866. 

  1866. 		if key[:3] == 'no-':
    1867. 

  1867. 			key = key[3:]              # remove prefix
    1868. 

  1868. 			val = self.off.get(key)    # turn key OFF
    1869. 

  1869. 		# is this key valid?
    1870. 

  1870. 		if key not in self.defaults.keys():
    1871. 

  1871. 			Debug('Bogus Config %s:%s'%(key,val),1)
    1872. 

  1872. 			return
    1873. 

  1873. 		# is this value the default one?
    1874. 

  1874. 		if val == self.defaults.get(key):
    1875. 

  1875. 			# if default value, remove previous key:val
    1876. 

  1876. 			if self.parsed.has_key(key):
    1877. 

  1877. 				del self.parsed[key]
    1878. 

  1878. 			# nothing more to do
    1879. 

  1879. 			return
    1880. 

  1880. 		# flags ON comes empty. we'll add the 1 value now
    1881. 

  1881. 		if val == '' and \
    1882. 

  1882. 		   key in self.dft_flags.keys()+self.dft_actions.keys():
    1883. 

  1883. 			val = 1
    1884. 

  1884. 		# multi value or single?
    1885. 

  1885. 		if key in self.multi:
    1886. 

  1886. 			# first one? start new list
    1887. 

  1887. 			if not self.parsed.has_key(key):
    1888. 

  1888. 				self.parsed[key] = []
    1889. 

  1889. 			self.parsed[key].append(val)
    1890. 

  1890. 		# incremental value? so let's add it
    1891. 

  1891. 		elif key in self.incremental:
    1892. 

  1892. 			self.parsed[key] = (self.parsed.get(key) or 0) + val
    1893. 

  1893. 		else:
    1894. 

  1894. 			self.parsed[key] = val
    1895. 

  1895. 		fancykey = dotted_spaces("%12s"%key)
    1896. 

  1896. 		Message(_("Added config %s : %s")%(fancykey,val),3)
    1897. 

  1897. 	
    1898. 

  1898. 	def get_outfile_name(self, config={}):
    1899. 

  1899. 		"Dirname is the same for {in,out}file"
    1900. 

  1900. 		infile, outfile = config['sourcefile'], config['outfile']
    1901. 

  1901. 		if outfile and outfile not in [STDOUT, MODULEOUT] \
    1902. 

  1902. 		   and not os.path.isabs(outfile):
    1903. 

  1903. 			outfile = os.path.join(os.path.dirname(infile), outfile)
    1904. 

  1904. 		if infile == STDIN    and not outfile: outfile = STDOUT
    1905. 

  1905. 		if infile == MODULEIN and not outfile: outfile = MODULEOUT
    1906. 

  1906. 		if not outfile and (infile and config.get('target')):
    1907. 

  1907. 			basename = re.sub('\.(txt|t2t)$','',infile)
    1908. 

  1908. 			outfile = "%s.%s"%(basename, config['target'])
    1909. 

  1909. 		Debug(" infile: '%s'"%infile , 1)
    1910. 

  1910. 		Debug("outfile: '%s'"%outfile, 1)
    1911. 

  1911. 		return outfile
    1912. 

  1912. 	
    1913. 

  1913. 	def sanity(self, config, gui=0):
    1914. 

  1914. 		"Basic config sanity checkings"
    1915. 

  1915. 		if not config: return {}
    1916. 

  1916. 		target = config.get('target')
    1917. 

  1917. 		# some actions don't require target specification
    1918. 

  1918. 		if not target:
    1919. 

  1919. 			for action in NO_TARGET:
    1920. 

  1920. 				if config.get(action):
    1921. 

  1921. 					target = 'txt'
    1922. 

  1922. 					break
    1923. 

  1923. 		# on GUI, some checkings are skipped
    1924. 

  1924. 		if not gui:
    1925. 

  1925. 			# we *need* a target
    1926. 

  1926. 			if not target:
    1927. 

  1927. 				Error(_('No target specified (try --help)')+\
    1928. 

  1928. 				'\n\n'+\
    1929. 

  1929. 				_('Maybe trying to convert an old v1.x file?'))
    1930. 

  1930. 			# and of course, an infile also
    1931. 

  1931. 			if not config.get('infile'):
    1932. 

  1932. 				Error(_('Missing input file (try --help)'))
    1933. 

  1933. 			# is the target valid?
    1934. 

  1934. 			if not TARGETS.count(target):
    1935. 

  1935. 				Error(_("Invalid target '%s' (try --help)")%\
    1936. 

  1936. 				     target)
    1937. 

  1937. 		# ensure all keys are present
    1938. 

  1938. 		empty = self.defaults.copy() ; empty.update(config)
    1939. 

  1939. 		config = empty.copy()
    1940. 

  1940. 		# check integers options
    1941. 

  1941. 		for key in config.keys():
    1942. 

  1942. 			if key in self.numeric:
    1943. 

  1943. 				try: config[key] = int(config[key])
    1944. 

  1944. 				except: Error(_('--%s value must be a number'
    1945. 

  1945. 				                )%key)
    1946. 

  1946. 		# check split level value
    1947. 

  1947. 		if config['split'] not in [0,1,2]:
    1948. 

  1948. 			Error(_('Option --split must be 0, 1 or 2'))
    1949. 

  1949. 		# --toc-only is stronger than others
    1950. 

  1950. 		if config['toc-only']:
    1951. 

  1951. 			config['headers'] = 0
    1952. 

  1952. 			config['toc']     = 0
    1953. 

  1953. 			config['split']   = 0
    1954. 

  1954. 			config['gui']     = 0
    1955. 

  1955. 			config['outfile'] = config['outfile'] or STDOUT
    1956. 

  1956. 		# splitting is disable for now (future: HTML only, no STDOUT)
    1957. 

  1957. 		config['split'] = 0
    1958. 

  1958. 		# restore target
    1959. 

  1959. 		config['target'] = target
    1960. 

  1960. 		# set output file name
    1961. 

  1961. 		config['outfile'] = self.get_outfile_name(config)
    1962. 

  1962. 		# checking suicide
    1963. 

  1963. 		if config['sourcefile'] == config['outfile'] and \
    1964. 

  1964. 		   config['outfile'] not in [STDOUT,MODULEOUT] and not gui:
    1965. 

  1965. 			Error(_("Input and Output files are the same: %s")%(
    1966. 

  1966. 			config['outfile']))
    1967. 

  1967. 		return config
    1968. 

  1968. 	
    1969. 

  1969. 	def parse(self):
    1970. 

  1970. 		"Returns the parsed config for the current target"
    1971. 

  1971. 		raw = self.get_target_raw()
    1972. 

  1972. 		for target, key, value in raw:
    1973. 

  1973. 			self.add(key, value)
    1974. 

  1974. 		Message(_("Added the following keys: %s")%string.join(
    1975. 

  1975. 		         self.parsed.keys(),', '),2)
    1976. 

  1976. 		return self.parsed.copy()
    1977. 

  1977. 	
    1978. 

  1978. 	def find_value(self, key='', target=''):
    1979. 

  1979. 		"Scans ALL raw config to find the desired key"
    1980. 

  1980. 		ret = []
    1981. 

  1981. 		# scan and save all values found
    1982. 

  1982. 		for targ, k, val in self.raw:
    1983. 

  1983. 			if targ in [target, 'all'] and k == key:
    1984. 

  1984. 				ret.append(val)
    1985. 

  1985. 		if not ret: return ''
    1986. 

  1986. 		# if not multi value, return only the last found
    1987. 

  1987. 		if key in self.multi: return ret
    1988. 

  1988. 		else                : return ret[-1]
    1989. 

  1989. 

  1990. ########################################################################
    1991. 

  1991. 

  1992. class ConfigLines:
    1993. 

  1993. 	"""
    1994. 

  1994. 	ConfigLines class - the config file data extractor
    1995. 

  1995. 	
    1996. 

  1996. 	This class reads and parse the config lines on the %!key:val
    1997. 

  1997. 	format, converting it to RAW config. It deals with user
    1998. 

  1998. 	config file (RC file), source document CONF area and
    1999. 

  1999. 	%!includeconf directives.
    2000. 

  2000. 

  2001. 	Call it passing a file name or feed the desired config lines.
    2002. 

  2002. 	Then just call the get_raw_config() method and wait to
    2003. 

  2003. 	receive the full config data on the RAW format. This method
    2004. 

  2004. 	also follows the possible %!includeconf directives found on
    2005. 

  2005. 	the config lines. Example:
    2006. 

  2006. 

  2007. 	    raw = ConfigLines(file=".txt2tagsrc").get_raw_config()
    2008. 

  2008. 

  2009. 	The parse_line() method is also useful to be used alone,
    2010. 

  2010. 	to identify and tokenize a single config line. For example,
    2011. 

  2011. 	to get the %!include command components, on the source
    2012. 

  2012. 	document BODY:
    2013. 

  2013. 	
    2014. 

  2014. 	    target, key, value = ConfigLines().parse_line(body_line)
    2015. 

  2015. 	"""
    2016. 

  2016. 	def __init__(self, file='', lines=[], first_line=1):
    2017. 

  2017. 		self.file = file or 'NOFILE'
    2018. 

  2018. 		self.lines = lines
    2019. 

  2019. 		self.first_line = first_line
    2020. 

  2020. 	
    2021. 

  2021. 	def load_lines(self):
    2022. 

  2022. 		"Make sure we've loaded the file contents into buffer"
    2023. 

  2023. 		if not self.lines and not self.file:
    2024. 

  2024. 			Error("ConfigLines: No file or lines provided")
    2025. 

  2025. 		if not self.lines:
    2026. 

  2026. 			self.lines = self.read_config_file(self.file)
    2027. 

  2027. 	
    2028. 

  2028. 	def read_config_file(self, filename=''):
    2029. 

  2029. 		"Read a Config File contents, aborting on invalid line"
    2030. 

  2030. 		if not filename: return []
    2031. 

  2031. 		errormsg = _("Invalid CONFIG line on %s")+"\n%03d:%s"
    2032. 

  2032. 		lines = Readfile(filename, remove_linebreaks=1)
    2033. 

  2033. 		# sanity: try to find invalid config lines
    2034. 

  2034. 		for i in range(len(lines)):
    2035. 

  2035. 			line = string.rstrip(lines[i])
    2036. 

  2036. 			if not line: continue  # empty
    2037. 

  2037. 			if line[0] != '%': Error(errormsg%(filename,i+1,line))
    2038. 

  2038. 		return lines
    2039. 

  2039. 	
    2040. 

  2040. 	def include_config_file(self, file=''):
    2041. 

  2041. 		"Perform the %!includeconf action, returning RAW config"
    2042. 

  2042. 		if not file: return []
    2043. 

  2043. 		# current dir relative to the current file (self.file)
    2044. 

  2044. 		current_dir = os.path.dirname(self.file)
    2045. 

  2045. 		file = os.path.join(current_dir, file)
    2046. 

  2046. 		# read and parse included config file contents
    2047. 

  2047. 		lines = self.read_config_file(file)
    2048. 

  2048. 		return ConfigLines(file=file, lines=lines).get_raw_config()
    2049. 

  2049. 	
    2050. 

  2050. 	def get_raw_config(self):
    2051. 

  2051. 		"Scan buffer and extract all config as RAW (including includes)"
    2052. 

  2052. 		ret = []
    2053. 

  2053. 		self.load_lines()
    2054. 

  2054. 		first = self.first_line
    2055. 

  2055. 		for i in range(len(self.lines)):
    2056. 

  2056. 			line = self.lines[i]
    2057. 

  2057. 			Message(_("Processing line %03d: %s")%(first+i,line),2)
    2058. 

  2058. 			target, key, val = self.parse_line(line)
    2059. 

  2059. 			if not key: continue    # no config on this line
    2060. 

  2060. 			if key == 'includeconf':
    2061. 

  2061. 				err = _('A file cannot include itself (loop!)')
    2062. 

  2062. 				if val == self.file:
    2063. 

  2063. 					Error("%s: %%!includeconf: %s"%(
    2064. 

  2064. 						err, self.file))
    2065. 

  2065. 				more_raw = self.include_config_file(val)
    2066. 

  2066. 				ret.extend(more_raw)
    2067. 

  2067. 				Message(_("Finished Config file inclusion: %s"
    2068. 

  2068. 				          )%(val),2)
    2069. 

  2069. 			else:
    2070. 

  2070. 				ret.append([target, key, val])
    2071. 

  2071. 				Message(_("Added %s")%key,3)
    2072. 

  2072. 		return ret
    2073. 

  2073. 	
    2074. 

  2074. 	def parse_line(self, line='', keyname='', target=''):
    2075. 

  2075. 		"Detects %!key:val config lines and extract data from it"
    2076. 

  2076. 		empty = ['', '', '']
    2077. 

  2077. 		if not line: return empty
    2078. 

  2078. 		no_target = ['target', 'includeconf']
    2079. 

  2079. 		re_name   = keyname or '[a-z]+'
    2080. 

  2080. 		re_target = target  or '[a-z]*'
    2081. 

  2081. 		cfgregex  = re.compile("""
    2082. 

  2082. 		  ^%%!\s*               # leading id with opt spaces
    2083. 

  2083. 		  (?P<name>%s)\s*       # config name
    2084. 

  2084. 		  (\((?P<target>%s)\))? # optional target spec inside ()
    2085. 

  2085. 		  \s*:\s*               # key:value delimiter with opt spaces
    2086. 

  2086. 		  (?P<value>\S.+?)      # config value
    2087. 

  2087. 		  \s*$                  # rstrip() spaces and hit EOL
    2088. 

  2088. 		  """%(re_name,re_target), re.I+re.VERBOSE)
    2089. 

  2089. 		prepostregex = re.compile("""
    2090. 

  2090. 		                        # ---[ PATTERN ]---
    2091. 

  2091. 		  ^( "([^"]*)"          # "double quoted" or
    2092. 

  2092. 		   | '([^']*)'          # 'single quoted' or
    2093. 

  2093. 		   | ([^\s]+)           # single_word
    2094. 

  2094. 		   )
    2095. 

  2095. 		    \s+                 # separated by spaces
    2096. 

  2096. 		
    2097. 

  2097. 		                        # ---[ REPLACE ]---
    2098. 

  2098. 		       ( "([^"]*)"      # "double quoted" or
    2099. 

  2099. 		       | '([^']*)'      # 'single quoted' or
    2100. 

  2100. 		       | (.*)           # anything
    2101. 

  2101. 		           )
    2102. 

  2102. 		            \s*$
    2103. 

  2103. 		  """, re.VERBOSE)
    2104. 

  2104. 		guicolors = re.compile("^([^\s]+\s+){3}[^\s]+") # 4 tokens
    2105. 

  2105. 		match = cfgregex.match(line)
    2106. 

  2106. 		if not match: return empty
    2107. 

  2107. 		
    2108. 

  2108. 		name   = string.lower(match.group('name') or '')
    2109. 

  2109. 		target = string.lower(match.group('target') or 'all')
    2110. 

  2110. 		value  = match.group('value')
    2111. 

  2111. 		
    2112. 

  2112. 		# NO target keywords: force all targets
    2113. 

  2113. 		if name in no_target: target = 'all'
    2114. 

  2114. 		
    2115. 

  2115. 		# special config for GUI colors
    2116. 

  2116. 		if name == 'guicolors':
    2117. 

  2117. 			valmatch = guicolors.search(value)
    2118. 

  2118. 			if not valmatch: return empty
    2119. 

  2119. 			value = re.split('\s+', value)
    2120. 

  2120. 		
    2121. 

  2121. 		# Special config with two quoted values (%!preproc: "foo" 'bar')
    2122. 

  2122. 		if name in ['preproc','postproc']:
    2123. 

  2123. 			valmatch = prepostregex.search(value)
    2124. 

  2124. 			if not valmatch: return empty
    2125. 

  2125. 			getval = valmatch.group
    2126. 

  2126. 			patt   = getval(2) or getval(3) or getval(4) or ''
    2127. 

  2127. 			repl   = getval(6) or getval(7) or getval(8) or ''
    2128. 

  2128. 			value  = (patt, repl)
    2129. 

  2129. 		return [target, name, value]
    2130. 

  2130. 

  2131. ##############################################################################
    2132. 

  2132. 

  2133. class MaskMaster:
    2134. 

  2134. 	"(Un)Protect important structures from escaping and formatting"
    2135. 

  2135. 	def __init__(self):
    2136. 

  2136. 		self.linkmask  = 'vvvLINKvvv'
    2137. 

  2137. 		self.monomask  = 'vvvMONOvvv'
    2138. 

  2138. 		self.macromask = 'vvvMACROvvv'
    2139. 

  2139. 		self.rawmask   = 'vvvRAWvvv'
    2140. 

  2140. 		self.tocmask   = 'vvvTOCvvv'
    2141. 

  2141. 		self.macroman  = MacroMaster()
    2142. 

  2142. 		self.reset()
    2143. 

  2143. 	
    2144. 

  2144. 	def reset(self):
    2145. 

  2145. 		self.linkbank = []
    2146. 

  2146. 		self.monobank = []
    2147. 

  2147. 		self.macrobank = []
    2148. 

  2148. 		self.rawbank = []
    2149. 

  2149. 	
    2150. 

  2150. 	def mask(self, line=''):
    2151. 

  2151. 		global AUTOTOC
    2152. 

  2152. 		
    2153. 

  2153. 		# protect raw text
    2154. 

  2154. 		while regex['raw'].search(line):
    2155. 

  2155. 			txt = regex['raw'].search(line).group(1)
    2156. 

  2156. 			txt = doEscape(TARGET,txt)
    2157. 

  2157. 			self.rawbank.append(txt)
    2158. 

  2158. 			line = regex['raw'].sub(self.rawmask,line,1)
    2159. 

  2159. 		
    2160. 

  2160. 		# protect pre-formatted font text
    2161. 

  2161. 		while regex['fontMono'].search(line):
    2162. 

  2162. 			txt = regex['fontMono'].search(line).group(1)
    2163. 

  2163. 			txt = doEscape(TARGET,txt)
    2164. 

  2164. 			self.monobank.append(txt)
    2165. 

  2165. 			line = regex['fontMono'].sub(self.monomask,line,1)
    2166. 

  2166. 		
    2167. 

  2167. 		# protect macros
    2168. 

  2168. 		while regex['macros'].search(line):
    2169. 

  2169. 			txt = regex['macros'].search(line).group()
    2170. 

  2170. 			self.macrobank.append(txt)
    2171. 

  2171. 			line = regex['macros'].sub(self.macromask,line,1)
    2172. 

  2172. 		
    2173. 

  2173. 		# protect TOC location
    2174. 

  2174. 		while regex['toc'].search(line):
    2175. 

  2175. 			line = regex['toc'].sub(self.tocmask,line)
    2176. 

  2176. 			AUTOTOC = 0
    2177. 

  2177. 		
    2178. 

  2178. 		# protect URLs and emails
    2179. 

  2179. 		while regex['linkmark'].search(line) or \
    2180. 

  2180. 		      regex['link'    ].search(line):
    2181. 

  2181. 			
    2182. 

  2182. 			# try to match plain or named links
    2183. 

  2183. 			match_link  = regex['link'].search(line)
    2184. 

  2184. 			match_named = regex['linkmark'].search(line)
    2185. 

  2185. 			
    2186. 

  2186. 			# define the current match
    2187. 

  2187. 			if match_link and match_named:
    2188. 

  2188. 				# both types found, which is the first?
    2189. 

  2189. 				m = match_link
    2190. 

  2190. 				if match_named.start() < match_link.start():
    2191. 

  2191. 					m = match_named
    2192. 

  2192. 			else:
    2193. 

  2193. 				# just one type found, we're fine
    2194. 

  2194. 				m = match_link or match_named
    2195. 

  2195. 			
    2196. 

  2196. 			# extract link data and apply mask
    2197. 

  2197. 			if m == match_link:              # plain link
    2198. 

  2198. 				link = m.group()
    2199. 

  2199. 				label = ''
    2200. 

  2200. 				link_re = regex['link']
    2201. 

  2201. 			else:                            # named link
    2202. 

  2202. 				link = m.group('link')
    2203. 

  2203. 				label = string.rstrip(m.group('label'))
    2204. 

  2204. 				link_re = regex['linkmark']
    2205. 

  2205. 			line = link_re.sub(self.linkmask,line,1)
    2206. 

  2206. 			
    2207. 

  2207. 			# save link data to the link bank
    2208. 

  2208. 			self.linkbank.append((label, link))
    2209. 

  2209. 		return line
    2210. 

  2210. 	
    2211. 

  2211. 	def undo(self, line):
    2212. 

  2212. 		
    2213. 

  2213. 		# url & email
    2214. 

  2214. 		for label,url in self.linkbank:
    2215. 

  2215. 			link = get_tagged_link(label, url)
    2216. 

  2216. 			line = string.replace(line, self.linkmask, link, 1)
    2217. 

  2217. 		
    2218. 

  2218. 		# expand macros
    2219. 

  2219. 		for macro in self.macrobank:
    2220. 

  2220. 			macro = self.macroman.expand(macro)
    2221. 

  2221. 			line = string.replace(line, self.macromask, macro,1)
    2222. 

  2222. 		
    2223. 

  2223. 		# expand verb
    2224. 

  2224. 		for mono in self.monobank:
    2225. 

  2225. 			open,close = TAGS['fontMonoOpen'],TAGS['fontMonoClose']
    2226. 

  2226. 			tagged = open+mono+close
    2227. 

  2227. 			line = string.replace(line,self.monomask,tagged,1)
    2228. 

  2228. 		
    2229. 

  2229. 		# expand raw
    2230. 

  2230. 		for raw in self.rawbank:
    2231. 

  2231. 			line = string.replace(line,self.rawmask,raw,1)
    2232. 

  2232. 		
    2233. 

  2233. 		return line
    2234. 

  2234. 

  2235. 

  2236. ##############################################################################
    2237. 

  2237. 

  2238. 

  2239. class TitleMaster:
    2240. 

  2240. 	"Title things"
    2241. 

  2241. 	def __init__(self):
    2242. 

  2242. 		self.count = ['',0,0,0,0,0]
    2243. 

  2243. 		self.toc   = []
    2244. 

  2244. 		self.level = 0
    2245. 

  2245. 		self.kind  = ''
    2246. 

  2246. 		self.txt   = ''
    2247. 

  2247. 		self.label = ''
    2248. 

  2248. 		self.tag   = ''
    2249. 

  2249. 		self.tag_hold = []
    2250. 

  2250. 		self.last_level = 0
    2251. 

  2251. 		self.count_id = ''
    2252. 

  2252. 		self.user_labels = {}
    2253. 

  2253. 		self.anchor_count = 0
    2254. 

  2254. 		self.anchor_prefix = 'toc'
    2255. 

  2255. 	
    2256. 

  2256. 	def _open_close_blocks(self):
    2257. 

  2257. 		"Open new title blocks, closing the previous (if any)"
    2258. 

  2258. 		if not rules['titleblocks']: return
    2259. 

  2259. 		tag = ''
    2260. 

  2260. 		last = self.last_level
    2261. 

  2261. 		curr = self.level
    2262. 

  2262. 		
    2263. 

  2263. 		# same level, just close the previous
    2264. 

  2264. 		if curr == last:
    2265. 

  2265. 			tag = TAGS.get('title%dClose'%last)
    2266. 

  2266. 			if tag: self.tag_hold.append(tag)
    2267. 

  2267. 		
    2268. 

  2268. 		# section -> subsection, more depth
    2269. 

  2269. 		while curr > last:
    2270. 

  2270. 			last = last + 1
    2271. 

  2271. 			
    2272. 

  2272. 			# open the new block of subsections
    2273. 

  2273. 			tag = TAGS.get('blockTitle%dOpen'%last)
    2274. 

  2274. 			if tag: self.tag_hold.append(tag)
    2275. 

  2275. 			
    2276. 

  2276. 			# jump from title1 to title3 or more
    2277. 

  2277. 			# fill the gap with an empty section
    2278. 

  2278. 			if curr - last > 0:
    2279. 

  2279. 				tag = TAGS.get('title%dOpen'%last)
    2280. 

  2280. 				tag = regex['x'].sub('', tag)      # del \a
    2281. 

  2281. 				if tag: self.tag_hold.append(tag)
    2282. 

  2282. 		
    2283. 

  2283. 		# section <- subsection, less depth
    2284. 

  2284. 		while curr < last:
    2285. 

  2285. 			# close the current opened subsection
    2286. 

  2286. 			tag = TAGS.get('title%dClose'%last)
    2287. 

  2287. 			if tag: self.tag_hold.append(tag)
    2288. 

  2288. 			
    2289. 

  2289. 			# close the current opened block of subsections
    2290. 

  2290. 			tag = TAGS.get('blockTitle%dClose'%last)
    2291. 

  2291. 			if tag: self.tag_hold.append(tag)
    2292. 

  2292. 			
    2293. 

  2293. 			last = last - 1
    2294. 

  2294. 			
    2295. 

  2295. 			# close the previous section of the same level
    2296. 

  2296. 			# the subsections were under it
    2297. 

  2297. 			if curr == last:
    2298. 

  2298. 				tag = TAGS.get('title%dClose'%last)
    2299. 

  2299. 				if tag: self.tag_hold.append(tag)
    2300. 

  2300. 	
    2301. 

  2301. 	def add(self, line):
    2302. 

  2302. 		"Parses a new title line."
    2303. 

  2303. 		if not line: return
    2304. 

  2304. 		self._set_prop(line)
    2305. 

  2305. 		self._open_close_blocks()
    2306. 

  2306. 		self._set_count_id()
    2307. 

  2307. 		self._set_label()
    2308. 

  2308. 		self._save_toc_info()
    2309. 

  2309. 	
    2310. 

  2310. 	def close_all(self):
    2311. 

  2311. 		"Closes all opened title blocks"
    2312. 

  2312. 		ret = []
    2313. 

  2313. 		ret.extend(self.tag_hold)
    2314. 

  2314. 		while self.level:
    2315. 

  2315. 			tag = TAGS.get('title%dClose'%self.level)
    2316. 

  2316. 			if tag: ret.append(tag)
    2317. 

  2317. 			tag = TAGS.get('blockTitle%dClose'%self.level)
    2318. 

  2318. 			if tag: ret.append(tag)
    2319. 

  2319. 			self.level = self.level - 1
    2320. 

  2320. 		return ret
    2321. 

  2321. 	
    2322. 

  2322. 	def _save_toc_info(self):
    2323. 

  2323. 		"Save TOC info, used by self.dump_marked_toc()"
    2324. 

  2324. 		self.toc.append((self.level, self.count_id,
    2325. 

  2325. 		                 self.txt  , self.label   ))
    2326. 

  2326. 	
    2327. 

  2327. 	def _set_prop(self, line=''):
    2328. 

  2328. 		"Extract info from original line and set data holders."
    2329. 

  2329. 		# detect title type (numbered or not)
    2330. 

  2330. 		id = string.lstrip(line)[0]
    2331. 

  2331. 		if   id == '=': kind = 'title'
    2332. 

  2332. 		elif id == '+': kind = 'numtitle'
    2333. 

  2333. 		else: Error("Unknown Title ID '%s'"%id)
    2334. 

  2334. 		# extract line info
    2335. 

  2335. 		match = regex[kind].search(line)
    2336. 

  2336. 		level = len(match.group('id'))
    2337. 

  2337. 		txt   = string.strip(match.group('txt'))
    2338. 

  2338. 		label = match.group('label')
    2339. 

  2339. 		# parse info & save
    2340. 

  2340. 		if CONF['enum-title']: kind = 'numtitle'  # force
    2341. 

  2341. 		if rules['titleblocks']:
    2342. 

  2342. 			self.tag = TAGS.get('%s%dOpen'%(kind,level)) or \
    2343. 

  2343. 			           TAGS.get('title%dOpen'%level)
    2344. 

  2344. 		else:
    2345. 

  2345. 			self.tag = TAGS.get(kind+`level`) or \
    2346. 

  2346. 			           TAGS.get('title'+`level`)
    2347. 

  2347. 		self.last_level = self.level
    2348. 

  2348. 		self.kind  = kind
    2349. 

  2349. 		self.level = level
    2350. 

  2350. 		self.txt   = txt
    2351. 

  2351. 		self.label = label
    2352. 

  2352. 	
    2353. 

  2353. 	def _set_count_id(self):
    2354. 

  2354. 		"Compose and save the title count identifier (if needed)."
    2355. 

  2355. 		count_id = ''
    2356. 

  2356. 		if self.kind == 'numtitle' and not rules['autonumbertitle']:
    2357. 

  2357. 			# manually increase title count
    2358. 

  2358. 			self.count[self.level] = self.count[self.level] +1
    2359. 

  2359. 			# reset sublevels count (if any)
    2360. 

  2360. 			max_levels = len(self.count)
    2361. 

  2361. 			if self.level < max_levels-1:
    2362. 

  2362. 				for i in range(self.level+1, max_levels):
    2363. 

  2363. 					self.count[i] = 0
    2364. 

  2364. 			# compose count id from hierarchy
    2365. 

  2365. 			for i in range(self.level):
    2366. 

  2366. 				count_id= "%s%d."%(count_id, self.count[i+1])
    2367. 

  2367. 		self.count_id = count_id
    2368. 

  2368. 	
    2369. 

  2369. 	def _set_label(self):
    2370. 

  2370. 		"Compose and save title label, used by anchors."
    2371. 

  2371. 		# remove invalid chars from label set by user
    2372. 

  2372. 		self.label = re.sub('[^A-Za-z0-9_-]', '', self.label or '')
    2373. 

  2373. 		# generate name as 15 first :alnum: chars
    2374. 

  2374. 		#TODO how to translate safely accented chars to plain?
    2375. 

  2375. 		#self.label = re.sub('[^A-Za-z0-9]', '', self.txt)[:15]
    2376. 

  2376. 		# 'tocN' label - sequential count, ignoring 'toc-level'
    2377. 

  2377. 		#self.label = self.anchor_prefix + str(len(self.toc)+1)
    2378. 

  2378. 	
    2379. 

  2379. 	def _get_tagged_anchor(self):
    2380. 

  2380. 		"Return anchor if user defined a label, or TOC is on."
    2381. 

  2381. 		ret = ''
    2382. 

  2382. 		label = self.label
    2383. 

  2383. 		if CONF['toc'] and self.level <= CONF['toc-level']:
    2384. 

  2384. 			# this count is needed bcos self.toc stores all
    2385. 

  2385. 			# titles, regardless of the 'toc-level' setting,
    2386. 

  2386. 			# so we can't use self.toc lenght to number anchors
    2387. 

  2387. 			self.anchor_count = self.anchor_count + 1
    2388. 

  2388. 			# autonumber label (if needed)
    2389. 

  2389. 			label = label or '%s%s'%(
    2390. 

  2390. 			        self.anchor_prefix, self.anchor_count)
    2391. 

  2391. 		if label and TAGS['anchor']:
    2392. 

  2392. 			ret = regex['x'].sub(label,TAGS['anchor'])
    2393. 

  2393. 		return ret
    2394. 

  2394. 	
    2395. 

  2395. 	def _get_full_title_text(self):
    2396. 

  2396. 		"Returns the full title contents, already escaped."
    2397. 

  2397. 		ret = self.txt
    2398. 

  2398. 		# insert count_id (if any) before text
    2399. 

  2399. 		if self.count_id:
    2400. 

  2400. 			ret = '%s %s'%(self.count_id, ret)
    2401. 

  2401. 		# escape specials
    2402. 

  2402. 		ret = doEscape(TARGET, ret)
    2403. 

  2403. 		# same targets needs final escapes on title lines
    2404. 

  2404. 		# it's here because there is a 'continue' after title
    2405. 

  2405. 		if rules['finalescapetitle']:
    2406. 

  2406. 			ret = doFinalEscape(TARGET, ret)
    2407. 

  2407. 		return ret
    2408. 

  2408. 	
    2409. 

  2409. 	def get(self):
    2410. 

  2410. 		"Returns the tagged title as a list."
    2411. 

  2411. 		ret = []
    2412. 

  2412. 		
    2413. 

  2413. 		# maybe some anchoring before?
    2414. 

  2414. 		anchor = self._get_tagged_anchor()
    2415. 

  2415. 		self.tag = regex['_anchor'].sub(anchor, self.tag)
    2416. 

  2416. 		
    2417. 

  2417. 		### compose & escape title text (TOC uses unescaped)
    2418. 

  2418. 		full_title = self._get_full_title_text()
    2419. 

  2419. 		
    2420. 

  2420. 		# close previous section area
    2421. 

  2421. 		ret.extend(self.tag_hold)
    2422. 

  2422. 		self.tag_hold = []
    2423. 

  2423. 		 
    2424. 

  2424. 		# finish title, adding "underline" on TXT target
    2425. 

  2425. 		tagged = regex['x'].sub(full_title, self.tag)
    2426. 

  2426. 		if TARGET == 'txt':
    2427. 

  2427. 			ret.append('') # blank line before
    2428. 

  2428. 			ret.append(tagged)
    2429. 

  2429. 			ret.append(regex['x'].sub('='*len(full_title),self.tag))
    2430. 

  2430. 			ret.append('') # blank line after
    2431. 

  2431. 		else:
    2432. 

  2432. 			ret.append(tagged)
    2433. 

  2433. 		return ret
    2434. 

  2434. 	
    2435. 

  2435. 	def dump_marked_toc(self, max_level=99):
    2436. 

  2436. 		"Dumps all toc itens as a valid t2t markup list"
    2437. 

  2437. 		#TODO maybe use quote+linebreaks instead lists
    2438. 

  2438. 		ret = []
    2439. 

  2439. 		toc_count = 1
    2440. 

  2440. 		for level, count_id, txt, label in self.toc:
    2441. 

  2441. 			if level > max_level: continue   # ignore
    2442. 

  2442. 			indent = '  '*level
    2443. 

  2443. 			id_txt = string.lstrip('%s %s'%(count_id, txt))
    2444. 

  2444. 			label = label or self.anchor_prefix+`toc_count`
    2445. 

  2445. 			toc_count = toc_count + 1
    2446. 

  2446. 			# TOC will have links
    2447. 

  2447. 			if TAGS['anchor']:
    2448. 

  2448. 				# TOC is more readable with master topics
    2449. 

  2449. 				# not linked at number. This is a stoled
    2450. 

  2450. 				# idea from Windows .CHM help files
    2451. 

  2451. 				if CONF['enum-title'] and level == 1:
    2452. 

  2452. 					tocitem = '%s+ [""%s"" #%s]'%(
    2453. 

  2453. 					          indent, txt, label)
    2454. 

  2454. 				else:
    2455. 

  2455. 					tocitem = '%s- [""%s"" #%s]'%(
    2456. 

  2456. 					          indent, id_txt, label)
    2457. 

  2457. 			# no links on TOC, just text
    2458. 

  2458. 			else:
    2459. 

  2459. 				# man don't reformat TOC lines, cool!
    2460. 

  2460. 				if TARGET in ['txt', 'man']:
    2461. 

  2461. 					tocitem = '%s""%s""' %(
    2462. 

  2462. 					          indent, id_txt)
    2463. 

  2463. 				else:
    2464. 

  2464. 					tocitem = '%s- ""%s""'%(
    2465. 

  2465. 					          indent, id_txt)
    2466. 

  2466. 			ret.append(tocitem)
    2467. 

  2467. 		return ret
    2468. 

  2468. 

  2469. 

  2470. ##############################################################################
    2471. 

  2471. 

  2472. #TODO check all this table mess
    2473. 

  2473. # trata linhas TABLE, com as prop do parse_row
    2474. 

  2474. # o metodo table() do BLOCK xunxa e troca as celulas pelas parseadas
    2475. 

  2475. class TableMaster:
    2476. 

  2476. 	def __init__(self, line=''):
    2477. 

  2477. 		self.rows      = []
    2478. 

  2478. 		self.border    = 0
    2479. 

  2479. 		self.align     = 'Left'
    2480. 

  2480. 		self.cellalign = []
    2481. 

  2481. 		self.cellspan  = []
    2482. 

  2482. 		if line:
    2483. 

  2483. 			prop = self.parse_row(line)
    2484. 

  2484. 			self.border    = prop['border']
    2485. 

  2485. 			self.align     = prop['align']
    2486. 

  2486. 			self.cellalign = prop['cellalign']
    2487. 

  2487. 			self.cellspan  = prop['cellspan']
    2488. 

  2488. 	
    2489. 

  2489. 	def _get_open_tag(self):
    2490. 

  2490. 		topen     = TAGS['tableOpen']
    2491. 

  2491. 		tborder   = TAGS['tableBorder']
    2492. 

  2492. 		talign    = TAGS['tableAlign'+self.align]
    2493. 

  2493. 		calignsep = TAGS['tableColAlignSep']
    2494. 

  2494. 		calign    = ''
    2495. 

  2495. 		
    2496. 

  2496. 		# the first line defines if table has border or not
    2497. 

  2497. 		if not self.border: tborder = ''
    2498. 

  2498. 		# set the columns alignment
    2499. 

  2499. 		if rules['tablecellaligntype'] == 'column':
    2500. 

  2500. 			calign = map(lambda x: TAGS['tableColAlign%s'%x],
    2501. 

  2501. 			             self.cellalign)
    2502. 

  2502. 			calign = string.join(calign, calignsep)
    2503. 

  2503. 		# align full table, set border and Column align (if any)
    2504. 

  2504. 		topen = regex['_tableAlign'   ].sub(talign , topen)
    2505. 

  2505. 		topen = regex['_tableBorder'  ].sub(tborder, topen)
    2506. 

  2506. 		topen = regex['_tableColAlign'].sub(calign , topen)
    2507. 

  2507. 		# tex table spec, border or not: {|l|c|r|} , {lcr}
    2508. 

  2508. 		if calignsep and not self.border:
    2509. 

  2509. 			# remove cell align separator
    2510. 

  2510. 			topen = string.replace(topen, calignsep, '')
    2511. 

  2511. 		return topen
    2512. 

  2512. 	
    2513. 

  2513. 	def _get_cell_align(self, cells):
    2514. 

  2514. 		ret = []
    2515. 

  2515. 		for cell in cells:
    2516. 

  2516. 			align = 'Left'
    2517. 

  2517. 			if string.strip(cell):
    2518. 

  2518. 				if cell[0] == ' ' and cell[-1] == ' ':
    2519. 

  2519. 					align = 'Center'
    2520. 

  2520. 				elif cell[0] == ' ':
    2521. 

  2521. 					align = 'Right'
    2522. 

  2522. 			ret.append(align)
    2523. 

  2523. 		return ret
    2524. 

  2524. 	
    2525. 

  2525. 	def _get_cell_span(self, cells):
    2526. 

  2526. 		ret = []
    2527. 

  2527. 		for cell in cells:
    2528. 

  2528. 			span = 0
    2529. 

  2529. 			m = re.search('\a(\|+)$', cell)
    2530. 

  2530. 			if m: span = len(m.group(1))+1
    2531. 

  2531. 			ret.append(span)
    2532. 

  2532. 		return ret
    2533. 

  2533. 	
    2534. 

  2534. 	def _tag_cells(self, rowdata):
    2535. 

  2535. 		row = []
    2536. 

  2536. 		cells  = rowdata['cells']
    2537. 

  2537. 		open   = TAGS['tableCellOpen']
    2538. 

  2538. 		close  = TAGS['tableCellClose']
    2539. 

  2539. 		sep    = TAGS['tableCellSep']
    2540. 

  2540. 		calign = map(lambda x: TAGS['tableCellAlign'+x],
    2541. 

  2541. 		             rowdata['cellalign'])
    2542. 

  2542. 		# populate the span tag
    2543. 

  2543. 		cspan = []
    2544. 

  2544. 		for i in rowdata['cellspan']:
    2545. 

  2545. 			if i > 0:
    2546. 

  2546. 				cspan.append(regex['x'].sub(
    2547. 

  2547. 				str(i), TAGS['tableCellColSpan']))
    2548. 

  2548. 			else:
    2549. 

  2549. 				cspan.append('')
    2550. 

  2550. 		
    2551. 

  2551. 		# maybe is it a title row?
    2552. 

  2552. 		if rowdata['title']:
    2553. 

  2553. 			open  = TAGS['tableTitleCellOpen']  or open
    2554. 

  2554. 			close = TAGS['tableTitleCellClose'] or close
    2555. 

  2555. 			sep   = TAGS['tableTitleCellSep']   or sep
    2556. 

  2556. 		
    2557. 

  2557. 		# should we break the line on *each* table cell?
    2558. 

  2558. 		if rules['breaktablecell']: close = close+'\n'
    2559. 

  2559. 		
    2560. 

  2560. 		# cells pre processing
    2561. 

  2561. 		if rules['tablecellstrip']:
    2562. 

  2562. 			cells = map(lambda x: string.strip(x), cells)
    2563. 

  2563. 		if rowdata['title'] and rules['tabletitlerowinbold']:
    2564. 

  2564. 			cells = map(lambda x: enclose_me('fontBold',x), cells)
    2565. 

  2565. 		
    2566. 

  2566. 		# add cell BEGIN/END tags
    2567. 

  2567. 		for cell in cells:
    2568. 

  2568. 			copen = open
    2569. 

  2569. 			# insert cell align into open tag (if cell is alignable)
    2570. 

  2570. 			if rules['tablecellaligntype'] == 'cell':
    2571. 

  2571. 				copen = regex['_tableCellAlign'].sub(
    2572. 

  2572. 					calign.pop(0), copen)
    2573. 

  2573. 			if rules['tablecellspannable']:
    2574. 

  2574. 				copen = regex['_tableCellColSpan'].sub(
    2575. 

  2575. 					cspan.pop(0), copen)
    2576. 

  2576. 			row.append(copen + cell + close)
    2577. 

  2577. 		
    2578. 

  2578. 		# maybe there are cell separators?
    2579. 

  2579. 		return string.join(row, sep)
    2580. 

  2580. 	
    2581. 

  2581. 	def add_row(self, cells):
    2582. 

  2582. 		self.rows.append(cells)
    2583. 

  2583. 	
    2584. 

  2584. 	def parse_row(self, line):
    2585. 

  2585. 		# default table proprierties
    2586. 

  2586. 		ret = {'border':0,'title':0,'align':'Left',
    2587. 

  2587. 		       'cells':[],'cellalign':[], 'cellspan':[]}
    2588. 

  2588. 		# detect table align (and remove spaces mark)
    2589. 

  2589. 		if line[0] == ' ': ret['align'] = 'Center'
    2590. 

  2590. 		line = string.lstrip(line)
    2591. 

  2591. 		# detect title mark
    2592. 

  2592. 		if line[1] == '|': ret['title'] = 1
    2593. 

  2593. 		# detect border mark and normalize the EOL
    2594. 

  2594. 		m = re.search(' (\|+) *$', line)
    2595. 

  2595. 		if m: line = line+' ' ; ret['border'] = 1
    2596. 

  2596. 		else: line = line+' | '
    2597. 

  2597. 		# delete table mark
    2598. 

  2598. 		line = regex['table'].sub('', line)
    2599. 

  2599. 		# detect colspan  | foo | bar baz |||
    2600. 

  2600. 		line = re.sub(' (\|+)\| ', '\a\\1 | ', line)
    2601. 

  2601. 		# split cells (the last is fake)
    2602. 

  2602. 		ret['cells'] = string.split(line, ' | ')[:-1]
    2603. 

  2603. 		# find cells span
    2604. 

  2604. 		ret['cellspan'] = self._get_cell_span(ret['cells'])
    2605. 

  2605. 		# remove span ID
    2606. 

  2606. 		ret['cells'] = map(lambda x:re.sub('\a\|+$','',x),ret['cells'])
    2607. 

  2607. 		# find cells align
    2608. 

  2608. 		ret['cellalign'] = self._get_cell_align(ret['cells'])
    2609. 

  2609. 		# hooray!
    2610. 

  2610. 		Debug('Table Prop: %s' % ret, 7)
    2611. 

  2611. 		return ret
    2612. 

  2612. 	
    2613. 

  2613. 	def dump(self):
    2614. 

  2614. 		open  = self._get_open_tag()
    2615. 

  2615. 		rows  = self.rows
    2616. 

  2616. 		close = TAGS['tableClose']
    2617. 

  2617. 		
    2618. 

  2618. 		rowopen     = TAGS['tableRowOpen']
    2619. 

  2619. 		rowclose    = TAGS['tableRowClose']
    2620. 

  2620. 		rowsep      = TAGS['tableRowSep']
    2621. 

  2621. 		titrowopen  = TAGS['tableTitleRowOpen']  or rowopen
    2622. 

  2622. 		titrowclose = TAGS['tableTitleRowClose'] or rowclose
    2623. 

  2623. 		
    2624. 

  2624. 		if rules['breaktablelineopen']:
    2625. 

  2625. 			rowopen = rowopen + '\n'
    2626. 

  2626. 			titrowopen = titrowopen + '\n'
    2627. 

  2627. 		
    2628. 

  2628. 		# tex gotchas
    2629. 

  2629. 		if TARGET == 'tex':
    2630. 

  2630. 			if not self.border:
    2631. 

  2631. 				rowopen = titrowopen = ''
    2632. 

  2632. 			else:
    2633. 

  2633. 				close = rowopen + close
    2634. 

  2634. 		
    2635. 

  2635. 		# now we tag all the table cells on each row
    2636. 

  2636. 		#tagged_cells = map(lambda x: self._tag_cells(x), rows) #!py15
    2637. 

  2637. 		tagged_cells = []
    2638. 

  2638. 		for cell in rows: tagged_cells.append(self._tag_cells(cell))
    2639. 

  2639. 		
    2640. 

  2640. 		# add row separator tags between lines
    2641. 

  2641. 		tagged_rows = []
    2642. 

  2642. 		if rowsep:
    2643. 

  2643. 			#!py15
    2644. 

  2644. 			#tagged_rows = map(lambda x:x+rowsep, tagged_cells)
    2645. 

  2645. 			for cell in tagged_cells:
    2646. 

  2646. 				tagged_rows.append(cell+rowsep)
    2647. 

  2647. 			# remove last rowsep, because the table is over
    2648. 

  2648. 			tagged_rows[-1] = string.replace(
    2649. 

  2649. 			                  tagged_rows[-1], rowsep, '')
    2650. 

  2650. 		# add row BEGIN/END tags for each line
    2651. 

  2651. 		else:
    2652. 

  2652. 			for rowdata in rows:
    2653. 

  2653. 				if rowdata['title']:
    2654. 

  2654. 					o,c = titrowopen, titrowclose
    2655. 

  2655. 				else:
    2656. 

  2656. 					o,c = rowopen, rowclose
    2657. 

  2657. 				row = tagged_cells.pop(0)
    2658. 

  2658. 				tagged_rows.append(o + row + c)
    2659. 

  2659. 		
    2660. 

  2660. 		fulltable = [open] + tagged_rows + [close]
    2661. 

  2661. 		
    2662. 

  2662. 		if rules['blankendtable']: fulltable.append('')
    2663. 

  2663. 		return fulltable
    2664. 

  2664. 

  2665. 

  2666. ##############################################################################
    2667. 

  2667. 

  2668. 

  2669. class BlockMaster:
    2670. 

  2670. 	"TIP: use blockin/out to add/del holders"
    2671. 

  2671. 	def __init__(self):
    2672. 

  2672. 		self.BLK = []
    2673. 

  2673. 		self.HLD = []
    2674. 

  2674. 		self.PRP = []
    2675. 

  2675. 		self.depth = 0
    2676. 

  2676. 		self.last = ''
    2677. 

  2677. 		self.tableparser = None
    2678. 

  2678. 		self.contains = {
    2679. 

  2679. 		  'para'    :['passthru','raw'],
    2680. 

  2680. 		  'verb'    :[],
    2681. 

  2681. 		  'table'   :[],
    2682. 

  2682. 		  'raw'     :[],
    2683. 

  2683. 		  'passthru':[],
    2684. 

  2684. 		  'quote'   :['quote','passthru','raw'],
    2685. 

  2685. 		  'list'    :['list' ,'numlist' ,'deflist','para','verb',
    2686. 

  2686. 		              'raw'  ,'passthru'],
    2687. 

  2687. 		  'numlist' :['list' ,'numlist' ,'deflist','para','verb',
    2688. 

  2688. 		              'raw'  ,'passthru'],
    2689. 

  2689. 		  'deflist' :['list' ,'numlist' ,'deflist','para','verb',
    2690. 

  2690. 		              'raw'  ,'passthru']
    2691. 

  2691. 		}
    2692. 

  2692. 		self.allblocks = self.contains.keys()
    2693. 

  2693. 	
    2694. 

  2694. 	def block(self):
    2695. 

  2695. 		if not self.BLK: return ''
    2696. 

  2696. 		return self.BLK[-1]
    2697. 

  2697. 	
    2698. 

  2698. 	def isblock(self, name=''):
    2699. 

  2699. 		return self.block() == name
    2700. 

  2700. 	
    2701. 

  2701. 	def prop(self, key):
    2702. 

  2702. 		if not self.PRP: return ''
    2703. 

  2703. 		return self.PRP[-1].get(key) or ''
    2704. 

  2704. 	
    2705. 

  2705. 	def propset(self, key, val):
    2706. 

  2706. 		self.PRP[-1][key] = val
    2707. 

  2707. 		#Debug('BLOCK prop ++: %s->%s'%(key,repr(val)), 1)
    2708. 

  2708. 		#Debug('BLOCK props: %s'%(repr(self.PRP)), 1)
    2709. 

  2709. 	
    2710. 

  2710. 	def hold(self):
    2711. 

  2711. 		if not self.HLD: return []
    2712. 

  2712. 		return self.HLD[-1]
    2713. 

  2713. 	
    2714. 

  2714. 	def holdadd(self, line):
    2715. 

  2715. 		if self.block()[-4:] == 'list': line = [line]
    2716. 

  2716. 		self.HLD[-1].append(line)
    2717. 

  2717. 		Debug('HOLD add: %s'%repr(line), 4)
    2718. 

  2718. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    2719. 

  2719. 	
    2720. 

  2720. 	def holdaddsub(self, line):
    2721. 

  2721. 		self.HLD[-1][-1].append(line)
    2722. 

  2722. 		Debug('HOLD addsub: %s'%repr(line), 4)
    2723. 

  2723. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    2724. 

  2724. 	
    2725. 

  2725. 	def holdextend(self, lines):
    2726. 

  2726. 		if self.block()[-4:] == 'list': lines = [lines]
    2727. 

  2727. 		self.HLD[-1].extend(lines)
    2728. 

  2728. 		Debug('HOLD extend: %s'%repr(lines), 4)
    2729. 

  2729. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    2730. 

  2730. 	
    2731. 

  2731. 	def blockin(self, block):
    2732. 

  2732. 		ret = []
    2733. 

  2733. 		if block not in self.allblocks:
    2734. 

  2734. 			Error("Invalid block '%s'"%block)
    2735. 

  2735. 		# first, let's close other possible open blocks
    2736. 

  2736. 		while self.block() and block not in self.contains[self.block()]:
    2737. 

  2737. 			ret.extend(self.blockout())
    2738. 

  2738. 		# now we can gladly add this new one
    2739. 

  2739. 		self.BLK.append(block)
    2740. 

  2740. 		self.HLD.append([])
    2741. 

  2741. 		self.PRP.append({})
    2742. 

  2742. 		if block == 'table': self.tableparser = TableMaster()
    2743. 

  2743. 		# deeper and deeper
    2744. 

  2744. 		self.depth = len(self.BLK)
    2745. 

  2745. 		Debug('block ++ (%s): %s' % (block,self.BLK), 3)
    2746. 

  2746. 		return ret
    2747. 

  2747. 	
    2748. 

  2748. 	def blockout(self):
    2749. 

  2749. 		if not self.BLK: Error('No block to pop')
    2750. 

  2750. 		self.last = self.BLK.pop()
    2751. 

  2751. 		tagged = getattr(self, self.last)()
    2752. 

  2752. 		parsed = self.HLD.pop()
    2753. 

  2753. 		self.PRP.pop()
    2754. 

  2754. 		self.depth = len(self.BLK)
    2755. 

  2755. 		if self.last == 'table': del self.tableparser
    2756. 

  2756. 		# inserting a nested block into mother
    2757. 

  2757. 		if self.block():
    2758. 

  2758. 			if self.block()[-4:] == 'list':
    2759. 

  2759. 				self.HLD[-1][-1].append(tagged)
    2760. 

  2760. 			else:
    2761. 

  2761. 				self.HLD[-1].append(tagged)
    2762. 

  2762. 			tagged = []   # reset. mother will have it all
    2763. 

  2763. 		Debug('block -- (%s): %s' % (self.last,self.BLK), 3)
    2764. 

  2764. 		Debug('RELEASED (%s): %s' % (self.last,parsed), 3)
    2765. 

  2765. 		if tagged: Debug('BLOCK: %s'%tagged, 6)
    2766. 

  2766. 		return tagged
    2767. 

  2767. 	
    2768. 

  2768. 	def _last_escapes(self, line):
    2769. 

  2769. 		return doFinalEscape(TARGET, line)
    2770. 

  2770. 	
    2771. 

  2771. 	def _get_escaped_hold(self):
    2772. 

  2772. 		ret = []
    2773. 

  2773. 		for line in self.hold():
    2774. 

  2774. 			linetype = type(line)
    2775. 

  2775. 			if linetype == type(''):
    2776. 

  2776. 				ret.append(self._last_escapes(line))
    2777. 

  2777. 			elif linetype == type([]):
    2778. 

  2778. 				ret.extend(line)
    2779. 

  2779. 			else:
    2780. 

  2780. 				Error("BlockMaster: Unknown HOLD item type:"
    2781. 

  2781. 				      " %s"%linetype)
    2782. 

  2782. 		return ret
    2783. 

  2783. 	
    2784. 

  2784. 	def _remove_twoblanks(self, lastitem):
    2785. 

  2785. 		if len(lastitem) > 1 and lastitem[-2:] == ['','']:
    2786. 

  2786. 			return lastitem[:-2]
    2787. 

  2787. 		return lastitem
    2788. 

  2788. 	
    2789. 

  2789. 	def passthru(self):
    2790. 

  2790. 		return self.hold()
    2791. 

  2791. 	
    2792. 

  2792. 	def raw(self):
    2793. 

  2793. 		lines = self.hold()
    2794. 

  2794. 		return map(lambda x: doEscape(TARGET, x), lines)
    2795. 

  2795. 	
    2796. 

  2796. 	def para(self):
    2797. 

  2797. 		tagged = []
    2798. 

  2798. 		open  = TAGS['paragraphOpen']
    2799. 

  2799. 		close = TAGS['paragraphClose']
    2800. 

  2800. 		lines = self._get_escaped_hold()
    2801. 

  2801. 		# open (or not) paragraph
    2802. 

  2802. 		if not open+close and self.last == 'para':
    2803. 

  2803. 			pass # avoids multiple blank lines
    2804. 

  2804. 		else:
    2805. 

  2805. 			tagged.append(open)
    2806. 

  2806. 		# pagemaker likes a paragraph as a single long line
    2807. 

  2807. 		if rules['onelinepara']:
    2808. 

  2808. 			tagged.append(string.join(lines,' '))
    2809. 

  2809. 		# others are normal :)
    2810. 

  2810. 		else:
    2811. 

  2811. 			tagged.extend(lines)
    2812. 

  2812. 		tagged.append(close)
    2813. 

  2813. 		
    2814. 

  2814. 		# very very very very very very very very very UGLY fix
    2815. 

  2815. 		# needed because <center> can't appear inside <p>
    2816. 

  2816. 		try:
    2817. 

  2817. 			if len(lines) == 1 and \
    2818. 

  2818. 			   TARGET in ('html', 'xhtml') and \
    2819. 

  2819. 			   re.match('^\s*<center>.*</center>\s*$', lines[0]):
    2820. 

  2820. 				tagged = [lines[0]]
    2821. 

  2821. 		except: pass
    2822. 

  2822. 		
    2823. 

  2823. 		return tagged
    2824. 

  2824. 	
    2825. 

  2825. 	def verb(self):
    2826. 

  2826. 		"Verbatim lines are not masked, so there's no need to unmask"
    2827. 

  2827. 		tagged = []
    2828. 

  2828. 		tagged.append(TAGS['blockVerbOpen'])
    2829. 

  2829. 		for line in self.hold():
    2830. 

  2830. 			if self.prop('mapped') == 'table':
    2831. 

  2831. 				line = MacroMaster().expand(line)
    2832. 

  2832. 			if not rules['verbblocknotescaped']:
    2833. 

  2833. 				line = doEscape(TARGET,line)
    2834. 

  2834. 			if rules['indentverbblock']:
    2835. 

  2835. 				line = '  '+line
    2836. 

  2836. 			if rules['verbblockfinalescape']:
    2837. 

  2837. 				line = doFinalEscape(TARGET, line)
    2838. 

  2838. 			tagged.append(line)
    2839. 

  2839. 		#TODO maybe use if not TAGS['blockVerbClose']
    2840. 

  2840. 		if TARGET != 'pm6':
    2841. 

  2841. 			tagged.append(TAGS['blockVerbClose'])
    2842. 

  2842. 		return tagged
    2843. 

  2843. 	
    2844. 

  2844. 	def table(self):
    2845. 

  2845. 		# rewrite all table cells by the unmasked and escaped data
    2846. 

  2846. 		lines = self._get_escaped_hold()
    2847. 

  2847. 		for i in range(len(lines)):
    2848. 

  2848. 			cells = string.split(lines[i], SEPARATOR)
    2849. 

  2849. 			self.tableparser.rows[i]['cells'] = cells
    2850. 

  2850. 		
    2851. 

  2851. 		return self.tableparser.dump()
    2852. 

  2852. 	
    2853. 

  2853. 	def quote(self):
    2854. 

  2854. 		tagged = []
    2855. 

  2855. 		myre   = regex['quote']
    2856. 

  2856. 		open   = TAGS['blockQuoteOpen']            # block based
    2857. 

  2857. 		close  = TAGS['blockQuoteClose']
    2858. 

  2858. 		qline  = TAGS['blockQuoteLine']            # line based
    2859. 

  2859. 		indent = tagindent = '\t'*self.depth
    2860. 

  2860. 		if rules['tagnotindentable']: tagindent = ''
    2861. 

  2861. 		if not rules['keepquoteindent']: indent = ''
    2862. 

  2862. 		
    2863. 

  2863. 		if open: tagged.append(tagindent+open)     # open block
    2864. 

  2864. 		for item in self.hold():
    2865. 

  2865. 			if type(item) == type([]):
    2866. 

  2866. 				tagged.extend(item)        # subquotes
    2867. 

  2867. 			else:
    2868. 

  2868. 				item = myre.sub('', item)  # del TABs
    2869. 

  2869. 				if rules['barinsidequote']:
    2870. 

  2870. 					item = get_tagged_bar(item)
    2871. 

  2871. 				item = self._last_escapes(item)
    2872. 

  2872. 				item = qline*self.depth + item
    2873. 

  2873. 				tagged.append(indent+item) # quote line
    2874. 

  2874. 		if close: tagged.append(tagindent+close)   # close block
    2875. 

  2875. 		return tagged
    2876. 

  2876. 	
    2877. 

  2877. 	def deflist(self): return self.list('deflist')
    2878. 

  2878. 	def numlist(self): return self.list('numlist')
    2879. 

  2879. 	def list(self, name='list'):
    2880. 

  2880. 		tagged    = []
    2881. 

  2881. 		items     = self.hold()
    2882. 

  2882. 		indent    = self.prop('indent')
    2883. 

  2883. 		tagindent = indent
    2884. 

  2884. 		listopen  = TAGS.get(name+'Open')
    2885. 

  2885. 		listclose = TAGS.get(name+'Close')
    2886. 

  2886. 		listline  = TAGS.get(name+'ItemLine')
    2887. 

  2887. 		itemcount = 0
    2888. 

  2888. 		if rules['tagnotindentable']: tagindent = ''
    2889. 

  2889. 		if not rules['keeplistindent']: indent = ''
    2890. 

  2890. 		
    2891. 

  2891. 		if name == 'deflist':
    2892. 

  2892. 			itemopen  = TAGS[name+'Item1Open']
    2893. 

  2893. 			itemclose = TAGS[name+'Item2Close']
    2894. 

  2894. 			itemsep   = TAGS[name+'Item1Close']+\
    2895. 

  2895. 			            TAGS[name+'Item2Open']
    2896. 

  2896. 		else:
    2897. 

  2897. 			itemopen  = TAGS[name+'ItemOpen']
    2898. 

  2898. 			itemclose = TAGS[name+'ItemClose']
    2899. 

  2899. 			itemsep   = ''
    2900. 

  2900. 		
    2901. 

  2901. 		# ItemLine: number of leading chars identifies list depth
    2902. 

  2902. 		if listline:
    2903. 

  2903. 			itemopen  = listline*self.depth
    2904. 

  2904. 			# dirty fix for mgp
    2905. 

  2905. 			if name == 'numlist': itemopen = itemopen + '\a. '
    2906. 

  2906. 		
    2907. 

  2907. 		# remove two-blanks from list ending mark, to avoid <p>
    2908. 

  2908. 		items[-1] = self._remove_twoblanks(items[-1])
    2909. 

  2909. 		
    2910. 

  2910. 		# open list (not nestable lists are only opened at mother)
    2911. 

  2911. 		if listopen and not \
    2912. 

  2912. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    2913. 

  2913. 			tagged.append(tagindent+listopen)
    2914. 

  2914. 		
    2915. 

  2915. 		# tag each list item (multine items)
    2916. 

  2916. 		itemopenorig = itemopen
    2917. 

  2917. 		for item in items:
    2918. 

  2918. 			
    2919. 

  2919. 			# add "manual" item count for noautonum targets
    2920. 

  2920. 			itemcount = itemcount + 1
    2921. 

  2921. 			if name == 'numlist' and not rules['autonumberlist']:
    2922. 

  2922. 				n = str(itemcount)
    2923. 

  2923. 				itemopen = regex['x'].sub(n, itemopenorig)
    2924. 

  2924. 				del n
    2925. 

  2925. 			
    2926. 

  2926. 			item[0] = self._last_escapes(item[0])
    2927. 

  2927. 			if name == 'deflist':
    2928. 

  2928. 				term, rest = string.split(item[0],SEPARATOR,1)
    2929. 

  2929. 				item[0] = rest
    2930. 

  2930. 				if not item[0]: del item[0]      # to avoid <p>
    2931. 

  2931. 				tagged.append(tagindent+itemopen+term+itemsep)
    2932. 

  2932. 			else:
    2933. 

  2933. 				fullitem = tagindent+itemopen
    2934. 

  2934. 				tagged.append(string.replace(
    2935. 

  2935. 				              item[0], SEPARATOR, fullitem))
    2936. 

  2936. 				del item[0]
    2937. 

  2937. 			
    2938. 

  2938. 			# process next lines for this item (if any)
    2939. 

  2939. 			for line in item:
    2940. 

  2940. 				if type(line) == type([]): # sublist inside
    2941. 

  2941. 					tagged.extend(line)
    2942. 

  2942. 				else:
    2943. 

  2943. 					line = self._last_escapes(line)
    2944. 

  2944. 					# blank lines turns to <p>
    2945. 

  2945. 					if not line and rules['parainsidelist']:
    2946. 

  2946. 						line = string.rstrip(indent   +\
    2947. 

  2947. 						         TAGS['paragraphOpen']+\
    2948. 

  2948. 						         TAGS['paragraphClose'])
    2949. 

  2949. 					if not rules['keeplistindent']:
    2950. 

  2950. 						line = string.lstrip(line)
    2951. 

  2951. 					tagged.append(line)
    2952. 

  2952. 			
    2953. 

  2953. 			# close item (if needed)
    2954. 

  2954. 			if itemclose: tagged.append(tagindent+itemclose)
    2955. 

  2955. 		
    2956. 

  2956. 		# close list (not nestable lists are only closed at mother)
    2957. 

  2957. 		if listclose and not \
    2958. 

  2958. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    2959. 

  2959. 			tagged.append(tagindent+listclose)
    2960. 

  2960. 		
    2961. 

  2961. 		if rules['blankendmotherlist'] and BLOCK.depth == 1:
    2962. 

  2962. 			tagged.append('')
    2963. 

  2963. 		
    2964. 

  2964. 		return tagged
    2965. 

  2965. 

  2966. 

  2967. ##############################################################################
    2968. 

  2968. 

  2969. 

  2970. class MacroMaster:
    2971. 

  2971. 	def __init__(self, config={}):
    2972. 

  2972. 		self.name     = ''
    2973. 

  2973. 		self.config   = config or CONF
    2974. 

  2974. 		self.infile   = self.config['sourcefile']
    2975. 

  2975. 		self.outfile  = self.config['outfile']
    2976. 

  2976. 		self.currdate = time.localtime(time.time())
    2977. 

  2977. 		self.rgx      = regex.get('macros') or getRegexes()['macros']
    2978. 

  2978. 		self.fileinfo = { 'infile': None, 'outfile': None }
    2979. 

  2979. 		self.dft_fmt  = MACROS
    2980. 

  2980. 	
    2981. 

  2981. 	def walk_file_format(self, fmt):
    2982. 

  2982. 		"Walks the %%{in/out}file format string, expanding the % flags"
    2983. 

  2983. 		i = 0; ret = ''                                 # counter/hold
    2984. 

  2984. 		while i < len(fmt):                             # char by char
    2985. 

  2985. 			c = fmt[i]; i = i + 1
    2986. 

  2986. 			if c == '%':                            # hot char!
    2987. 

  2987. 				if i == len(fmt):               # % at the end
    2988. 

  2988. 					ret = ret + c
    2989. 

  2989. 					break
    2990. 

  2990. 				c = fmt[i]; i = i + 1           # read next
    2991. 

  2991. 				ret = ret + self.expand_file_flag(c)
    2992. 

  2992. 			else:
    2993. 

  2993. 				ret = ret +c                    # common char
    2994. 

  2994. 		return ret
    2995. 

  2995. 	
    2996. 

  2996. 	def expand_file_flag(self, flag):
    2997. 

  2997. 		"%f: filename          %F: filename (w/o extension)"
    2998. 

  2998. 		"%d: dirname           %D: dirname (only parent dir)"
    2999. 

  2999. 		"%p: file path         %e: extension"
    3000. 

  3000. 		info = self.fileinfo[self.name]           # get dict
    3001. 

  3001. 		if   flag == '%': x = '%'                 # %% -> %
    3002. 

  3002. 		elif flag == 'f': x = info['name']
    3003. 

  3003. 		elif flag == 'F': x = re.sub('\.[^.]*$','',info['name'])
    3004. 

  3004. 		elif flag == 'd': x = info['dir']
    3005. 

  3005. 		elif flag == 'D': x = os.path.split(info['dir'])[-1]
    3006. 

  3006. 		elif flag == 'p': x = info['path']
    3007. 

  3007. 		elif flag == 'e': x = re.search('.(\.([^.]+))?$',info['name']
    3008. 

  3008. 		                                ).group(2) or ''
    3009. 

  3009. 		#TODO simplier way for %e ?
    3010. 

  3010. 		else            : x = '%'+flag            # false alarm
    3011. 

  3011. 		return x
    3012. 

  3012. 	
    3013. 

  3013. 	def set_file_info(self, macroname):
    3014. 

  3014. 		if self.fileinfo.get(macroname): return   # already done
    3015. 

  3015. 		file = getattr(self, self.name)           # self.infile
    3016. 

  3016. 		if file in [STDOUT, MODULEOUT]:
    3017. 

  3017. 			dir = ''; path = name = file
    3018. 

  3018. 		else:
    3019. 

  3019. 			path = os.path.abspath(file)
    3020. 

  3020. 			dir  = os.path.dirname(path)
    3021. 

  3021. 			name = os.path.basename(path)
    3022. 

  3022. 		self.fileinfo[macroname] = {'path':path,'dir':dir,'name':name}
    3023. 

  3023. 	
    3024. 

  3024. 	def expand(self, line=''):
    3025. 

  3025. 		"Expand all macros found on the line"
    3026. 

  3026. 		while self.rgx.search(line):
    3027. 

  3027. 			m = self.rgx.search(line)
    3028. 

  3028. 			name = self.name = string.lower(m.group('name'))
    3029. 

  3029. 			fmt = m.group('fmt') or self.dft_fmt.get(name)
    3030. 

  3030. 			if name == 'date':
    3031. 

  3031. 				txt = time.strftime(fmt,self.currdate)
    3032. 

  3032. 			elif name == 'mtime':
    3033. 

  3033. 				if self.infile in [STDIN, MODULEIN]:
    3034. 

  3034. 					fdate = self.currdate
    3035. 

  3035. 				else:
    3036. 

  3036. 					mtime = os.path.getmtime(self.infile)
    3037. 

  3037. 					fdate = time.localtime(mtime)
    3038. 

  3038. 				txt = time.strftime(fmt,fdate)
    3039. 

  3039. 			elif name in ['infile','outfile']:
    3040. 

  3040. 				self.set_file_info(name)
    3041. 

  3041. 				txt = self.walk_file_format(fmt)
    3042. 

  3042. 			else:
    3043. 

  3043. 				Error("Unknown macro name '%s'"%name)
    3044. 

  3044. 			line = self.rgx.sub(txt,line,1)
    3045. 

  3045. 		return line
    3046. 

  3046. 

  3047. 

  3048. ##############################################################################
    3049. 

  3049. 

  3050. 

  3051. def dumpConfig(source_raw, parsed_config):
    3052. 

  3052. 	onoff = {1:_('ON'), 0:_('OFF')}
    3053. 

  3053. 	data = [
    3054. 

  3054. 	  (_('RC file')        , RC_RAW     ),
    3055. 

  3055. 	  (_('source document'), source_raw ),
    3056. 

  3056. 	  (_('command line')   , CMDLINE_RAW)
    3057. 

  3057. 	]
    3058. 

  3058. 	# first show all RAW data found
    3059. 

  3059. 	for label, cfg in data:
    3060. 

  3060. 		print _('RAW config for %s')%label
    3061. 

  3061. 		for target,key,val in cfg:
    3062. 

  3062. 			target = '(%s)'%target
    3063. 

  3063. 			key    = dotted_spaces("%-14s"%key)
    3064. 

  3064. 			val    = val or _('ON')
    3065. 

  3065. 			print '  %-8s %s: %s'%(target,key,val)
    3066. 

  3066. 		print
    3067. 

  3067. 	# then the parsed results of all of them
    3068. 

  3068. 	print _('Full PARSED config')
    3069. 

  3069. 	keys = parsed_config.keys() ; keys.sort()  # sorted
    3070. 

  3070. 	for key in keys:
    3071. 

  3071. 		val = parsed_config[key]
    3072. 

  3072. 		# filters are the last
    3073. 

  3073. 		if key in ['preproc', 'postproc']:
    3074. 

  3074. 			continue
    3075. 

  3075. 		# flag beautifier
    3076. 

  3076. 		if key in FLAGS.keys()+ACTIONS.keys():
    3077. 

  3077. 			val = onoff.get(val) or val
    3078. 

  3078. 		# list beautifier
    3079. 

  3079. 		if type(val) == type([]):
    3080. 

  3080. 			if key == 'options': sep = ' '
    3081. 

  3081. 			else               : sep = ', '
    3082. 

  3082. 			val = string.join(val, sep)
    3083. 

  3083. 		print "%25s: %s"%(dotted_spaces("%-14s"%key),val)
    3084. 

  3084. 	print
    3085. 

  3085. 	print _('Active filters')
    3086. 

  3086. 	for filter in ['preproc','postproc']:
    3087. 

  3087. 		for rule in parsed_config.get(filter) or []:
    3088. 

  3088. 			print "%25s: %s  ->  %s"%(
    3089. 

  3089. 			   dotted_spaces("%-14s"%filter),rule[0],rule[1])
    3090. 

  3090. 

  3091. 

  3092. def get_file_body(file):
    3093. 

  3093. 	"Returns all the document BODY lines"
    3094. 

  3094. 	return process_source_file(file, noconf=1)[1][2]
    3095. 

  3095. 

  3096. 

  3097. def finish_him(outlist, config):
    3098. 

  3098. 	"Writing output to screen or file"
    3099. 

  3099. 	outfile = config['outfile']
    3100. 

  3100. 	outlist = unmaskEscapeChar(outlist)
    3101. 

  3101. 	outlist = expandLineBreaks(outlist)
    3102. 

  3102. 	
    3103. 

  3103. 	# apply PostProc filters
    3104. 

  3104. 	if config['postproc']:
    3105. 

  3105. 		filters = compile_filters(config['postproc'],
    3106. 

  3106. 		                        _('Invalid PostProc filter regex'))
    3107. 

  3107. 		postoutlist = []
    3108. 

  3108. 		errmsg = _('Invalid PostProc filter replacement')
    3109. 

  3109. 		for line in outlist:
    3110. 

  3110. 			for rgx,repl in filters:
    3111. 

  3111. 				try: line = rgx.sub(repl, line)
    3112. 

  3112. 				except: Error("%s: '%s'"%(errmsg, repl))
    3113. 

  3113. 			postoutlist.append(line)
    3114. 

  3114. 		outlist = postoutlist[:]
    3115. 

  3115. 	
    3116. 

  3116. 	if outfile == MODULEOUT:
    3117. 

  3117. 		return outlist
    3118. 

  3118. 	elif outfile == STDOUT:
    3119. 

  3119. 		if GUI:
    3120. 

  3120. 			return outlist, config
    3121. 

  3121. 		else:
    3122. 

  3122. 			for line in outlist: print line
    3123. 

  3123. 	else:
    3124. 

  3124. 		Savefile(outfile, addLineBreaks(outlist))
    3125. 

  3125. 		if not GUI and not QUIET:
    3126. 

  3126. 			print _('%s wrote %s')%(my_name,outfile)
    3127. 

  3127. 	
    3128. 

  3128. 	if config['split']:
    3129. 

  3129. 		if not QUIET: print "--- html..."
    3130. 

  3130. 		sgml2html = 'sgml2html -s %s -l %s %s'%(
    3131. 

  3131. 		            config['split'],config['lang'] or lang,outfile)
    3132. 

  3132. 		if not QUIET: print "Running system command:", sgml2html
    3133. 

  3133. 		os.system(sgml2html)
    3134. 

  3134. 

  3135. 

  3136. def toc_inside_body(body, toc, config):
    3137. 

  3137. 	ret = []
    3138. 

  3138. 	if AUTOTOC: return body                     # nothing to expand
    3139. 

  3139. 	toc_mark = MaskMaster().tocmask
    3140. 

  3140. 	# expand toc mark with TOC contents
    3141. 

  3141. 	for line in body:
    3142. 

  3142. 		if string.count(line, toc_mark):    # toc mark found
    3143. 

  3143. 			if config['toc']:
    3144. 

  3144. 				ret.extend(toc)     # include if --toc
    3145. 

  3145. 			else:
    3146. 

  3146. 				pass                # or remove %%toc line
    3147. 

  3147. 		else:
    3148. 

  3148. 			ret.append(line)            # common line
    3149. 

  3149. 	return ret
    3150. 

  3150. 

  3151. def toc_tagger(toc, config):
    3152. 

  3152. 	"Convert t2t-marked TOC (it is a list) to target-tagged TOC"
    3153. 

  3153. 	ret = []
    3154. 

  3154. 	# tag if TOC-only TOC "by hand" (target don't have a TOC tag)
    3155. 

  3155. 	if config['toc-only'] or (config['toc'] and not TAGS['TOC']):
    3156. 

  3156. 		fakeconf = config.copy()
    3157. 

  3157. 		fakeconf['headers']    = 0
    3158. 

  3158. 		fakeconf['toc-only']   = 0
    3159. 

  3159. 		fakeconf['mask-email'] = 0
    3160. 

  3160. 		fakeconf['preproc']    = []
    3161. 

  3161. 		fakeconf['postproc']   = []
    3162. 

  3162. 		fakeconf['css-sugar']  = 0
    3163. 

  3163. 		ret,foo = convert(toc, fakeconf)
    3164. 

  3164. 		set_global_config(config)   # restore config
    3165. 

  3165. 	# target TOC is a tag
    3166. 

  3166. 	elif config['toc'] and TAGS['TOC']:
    3167. 

  3167. 		ret = [TAGS['TOC']]
    3168. 

  3168. 	return ret
    3169. 

  3169. 

  3170. def toc_formatter(toc, config):
    3171. 

  3171. 	"Formats TOC for automatic placement between headers and body"
    3172. 

  3172. 	if config['toc-only']: return toc              # no formatting needed
    3173. 

  3173. 	if not config['toc'] : return []               # TOC disabled
    3174. 

  3174. 	ret = toc
    3175. 

  3175. 	# TOC open/close tags (if any)
    3176. 

  3176. 	if TAGS['tocOpen' ]: ret.insert(0, TAGS['tocOpen'])
    3177. 

  3177. 	if TAGS['tocClose']: ret.append(TAGS['tocClose'])
    3178. 

  3178. 	# autotoc specific formatting
    3179. 

  3179. 	if AUTOTOC:
    3180. 

  3180. 		if rules['autotocwithbars']:           # TOC between bars
    3181. 

  3181. 			para = TAGS['paragraphOpen']+TAGS['paragraphClose']
    3182. 

  3182. 			bar  = regex['x'].sub('-'*72,TAGS['bar1'])
    3183. 

  3183. 			tocbar = [para, bar, para]
    3184. 

  3184. 			ret = tocbar + ret + tocbar
    3185. 

  3185. 		if rules['blankendautotoc']:           # blank line after TOC
    3186. 

  3186. 			ret.append('')
    3187. 

  3187. 		if rules['autotocnewpagebefore']:      # page break before TOC
    3188. 

  3188. 			ret.insert(0,TAGS['pageBreak'])
    3189. 

  3189. 		if rules['autotocnewpageafter']:       # page break after TOC
    3190. 

  3190. 			ret.append(TAGS['pageBreak'])
    3191. 

  3191. 	return ret
    3192. 

  3192. 

  3193. 

  3194. def doHeader(headers, config):
    3195. 

  3195. 	if not config['headers']: return []
    3196. 

  3196. 	if not headers: headers = ['','','']
    3197. 

  3197. 	target = config['target']
    3198. 

  3198. 	if not HEADER_TEMPLATE.has_key(target):
    3199. 

  3199. 		Error("doheader: Unknow target '%s'"%target)
    3200. 

  3200. 	
    3201. 

  3201. 	if target in ['html','xhtml'] and config.get('css-sugar'):
    3202. 

  3202. 		template = string.split(HEADER_TEMPLATE[target+'css'], '\n')
    3203. 

  3203. 	else:
    3204. 

  3204. 		template = string.split(HEADER_TEMPLATE[target], '\n')
    3205. 

  3205. 	
    3206. 

  3206. 	head_data = {'STYLE':'', 'ENCODING':''}
    3207. 

  3207. 	for key in head_data.keys():
    3208. 

  3208. 		val = config.get(string.lower(key))
    3209. 

  3209. 		if key == 'ENCODING': val = get_encoding_string(val, target)
    3210. 

  3210. 		head_data[key] = val
    3211. 

  3211. 	# parse header contents
    3212. 

  3212. 	for i in 0,1,2:
    3213. 

  3213. 		# expand macros
    3214. 

  3214. 		contents = MacroMaster(config=config).expand(headers[i])
    3215. 

  3215. 		# Escapes - on tex, just do it if any \tag{} present
    3216. 

  3216. 		if target != 'tex' or \
    3217. 

  3217. 		  (target == 'tex' and re.search(r'\\\w+{', contents)):
    3218. 

  3218. 			contents = doEscape(target, contents)
    3219. 

  3219. 		if target == 'lout':
    3220. 

  3220. 			contents = doFinalEscape(target, contents)
    3221. 

  3221. 		
    3222. 

  3222. 		head_data['HEADER%d'%(i+1)] = contents
    3223. 

  3223. 	# css-inside removes STYLE line	
    3224. 

  3224. 	if target in ['html','xhtml'] and config.get('css-inside') and \
    3225. 

  3225. 	   config.get('style'):
    3226. 

  3226. 		head_data['STYLE'] = ''   
    3227. 

  3227. 	Debug("Header Data: %s"%head_data, 1)
    3228. 

  3228. 	# scan for empty dictionary keys
    3229. 

  3229. 	# if found, scan template lines for that key reference
    3230. 

  3230. 	# if found, remove the reference
    3231. 

  3231. 	# if there isn't any other key reference on the same line, remove it
    3232. 

  3232. 	for key in head_data.keys():
    3233. 

  3233. 		if head_data.get(key): continue
    3234. 

  3234. 		for line in template:
    3235. 

  3235. 			if string.count(line, '%%(%s)s'%key):
    3236. 

  3236. 				sline = string.replace(line, '%%(%s)s'%key, '')
    3237. 

  3237. 				if not re.search(r'%\([A-Z0-9]+\)s', sline):
    3238. 

  3238. 					template.remove(line)
    3239. 

  3239. 	# populate template with data
    3240. 

  3240. 	template = string.join(template, '\n') % head_data
    3241. 

  3241. 	
    3242. 

  3242. 	# adding CSS contents into template (for --css-inside)
    3243. 

  3243. 	if target in ['html','xhtml'] and config.get('css-inside') and \
    3244. 

  3244. 	   config.get('style'):
    3245. 

  3245. 		TAGS = getTags(config)
    3246. 

  3246. 		cssfile = config['style']
    3247. 

  3247. 		if not os.path.isabs(cssfile):
    3248. 

  3248. 			infile = config.get('sourcefile')
    3249. 

  3249. 			cssfile = os.path.join(os.path.dirname(infile), cssfile)
    3250. 

  3250. 		css = string.join(Readfile(cssfile, 1, 1), '\n')
    3251. 

  3251. 		css = "%s\n%s\n%s\n" % (TAGS['cssOpen'], css, TAGS['cssClose'])
    3252. 

  3252. 		template = re.sub('(?i)(</HEAD>)', css+r'\1', template)
    3253. 

  3253. 	
    3254. 

  3254. 	return string.split(template, '\n')
    3255. 

  3255. 

  3256. def doCommentLine(txt):
    3257. 

  3257. 	# the -- string ends a (h|sg|xht)ml comment :(
    3258. 

  3258. 	txt = maskEscapeChar(txt)
    3259. 

  3259. 	if string.count(TAGS['comment'], '--') and \
    3260. 

  3260. 	   string.count(txt, '--'):
    3261. 

  3261. 		txt = re.sub('-(?=-)', r'-\\', txt)
    3262. 

  3262. 	
    3263. 

  3263. 	if TAGS['comment']:
    3264. 

  3264. 		return regex['x'].sub(txt, TAGS['comment'])
    3265. 

  3265. 	return ''
    3266. 

  3266. 

  3267. def doFooter(config):
    3268. 

  3268. 	if not config['headers']: return []
    3269. 

  3269. 	ret = []
    3270. 

  3270. 	target = config['target']
    3271. 

  3271. 	cmdline = config['realcmdline']
    3272. 

  3272. 	typename = target
    3273. 

  3273. 	if target == 'tex': typename = 'LaTeX2e'
    3274. 

  3274. 	ppgd = '%s code generated by %s %s (%s)'%(
    3275. 

  3275. 	        typename,my_name,my_version,my_url)
    3276. 

  3276. 	cmdline = 'cmdline: %s %s'%(my_name, string.join(cmdline, ' '))
    3277. 

  3277. 	ret.append('')
    3278. 

  3278. 	ret.append(doCommentLine(ppgd))
    3279. 

  3279. 	ret.append(doCommentLine(cmdline))
    3280. 

  3280. 	ret.append(TAGS['EOD'])
    3281. 

  3281. 	return ret
    3282. 

  3282. 

  3283. def doEscape(target,txt):
    3284. 

  3284. 	"Target-specific special escapes. Apply *before* insert any tag."
    3285. 

  3285. 	tmpmask = 'vvvvThisEscapingSuxvvvv'
    3286. 

  3286. 	if target in ['html','sgml','xhtml']:
    3287. 

  3287. 		txt = re.sub('&','&amp;',txt)
    3288. 

  3288. 		txt = re.sub('<','&lt;',txt)
    3289. 

  3289. 		txt = re.sub('>','&gt;',txt)
    3290. 

  3290. 		if target == 'sgml':
    3291. 

  3291. 			txt = re.sub('\xff','&yuml;',txt)  # "+y
    3292. 

  3292. 	elif target == 'pm6':
    3293. 

  3293. 		txt = re.sub('<','<\#60>',txt)
    3294. 

  3294. 	elif target == 'mgp':
    3295. 

  3295. 		txt = re.sub('^%',' %',txt)  # add leading blank to avoid parse
    3296. 

  3296. 	elif target == 'man':
    3297. 

  3297. 		txt = re.sub("^([.'])", '\\&\\1',txt)           # command ID
    3298. 

  3298. 		txt = string.replace(txt,ESCCHAR, ESCCHAR+'e')  # \e
    3299. 

  3299. 	elif target == 'lout':
    3300. 

  3300. 		# TIP: / moved to FinalEscape to avoid //italic//
    3301. 

  3301. 		# TIP: these are also converted by lout:  ...  ---  --
    3302. 

  3302. 		txt = string.replace(txt, ESCCHAR, tmpmask)             # \
    3303. 

  3303. 		txt = string.replace(txt, '"', '"%s""'%ESCCHAR)         # "\""
    3304. 

  3304. 		txt = re.sub('([|&{}@#^~])', '"\\1"',txt)               # "@"
    3305. 

  3305. 		txt = string.replace(txt, tmpmask, '"%s"'%(ESCCHAR*2))  # "\\"
    3306. 

  3306. 	elif target == 'tex':
    3307. 

  3307. 		# mark literal \ to be changed to $\backslash$ later
    3308. 

  3308. 		txt = string.replace( txt, ESCCHAR, tmpmask)
    3309. 

  3309. 		txt = re.sub('([#$&%{}])', ESCCHAR+r'\1'  , txt)  # \%
    3310. 

  3310. 		txt = re.sub('([~^])'    , ESCCHAR+r'\1{}', txt)  # \~{}
    3311. 

  3311. 		txt = re.sub('([<|>])'   ,         r'$\1$', txt)  # $>$
    3312. 

  3312. 		txt = string.replace(txt, tmpmask,
    3313. 

  3313. 		                     maskEscapeChar(r'$\backslash$'))
    3314. 

  3314. 		# TIP the _ is escaped at the end
    3315. 

  3315. 	return txt
    3316. 

  3316. 

  3317. # TODO man: where - really needs to be escaped?
    3318. 

  3318. def doFinalEscape(target, txt):
    3319. 

  3319. 	"Last escapes of each line"
    3320. 

  3320. 	if   target == 'pm6' : txt = string.replace(txt,ESCCHAR+'<',r'<\#92><')
    3321. 

  3321. 	elif target == 'man' : txt = string.replace(txt, '-', r'\-')
    3322. 

  3322. 	elif target == 'sgml': txt = string.replace(txt, '[', '&lsqb;')
    3323. 

  3323. 	elif target == 'lout': txt = string.replace(txt, '/', '"/"')
    3324. 

  3324. 	elif target == 'tex' :
    3325. 

  3325. 		txt = string.replace(txt, '_', r'\_')
    3326. 

  3326. 		txt = string.replace(txt, 'vvvvTexUndervvvv', '_')  # shame!
    3327. 

  3327. 	return txt
    3328. 

  3328. 

  3329. def EscapeCharHandler(action, data):
    3330. 

  3330. 	"Mask/Unmask the Escape Char on the given string"
    3331. 

  3331. 	if not string.strip(data): return data
    3332. 

  3332. 	if action not in ['mask','unmask']:
    3333. 

  3333. 		Error("EscapeCharHandler: Invalid action '%s'"%action)
    3334. 

  3334. 	if action == 'mask': return string.replace(data,'\\',ESCCHAR)
    3335. 

  3335. 	else:                return string.replace(data,ESCCHAR,'\\')
    3336. 

  3336. 

  3337. def maskEscapeChar(data):
    3338. 

  3338. 	"Replace any Escape Char \ with a text mask (Input: str or list)"
    3339. 

  3339. 	if type(data) == type([]):
    3340. 

  3340. 		return map(lambda x: EscapeCharHandler('mask', x), data)
    3341. 

  3341. 	return EscapeCharHandler('mask',data)
    3342. 

  3342. 

  3343. def unmaskEscapeChar(data):
    3344. 

  3344. 	"Undo the Escape char \ masking (Input: str or list)"
    3345. 

  3345. 	if type(data) == type([]):
    3346. 

  3346. 		return map(lambda x: EscapeCharHandler('unmask', x), data)
    3347. 

  3347. 	return EscapeCharHandler('unmask',data)
    3348. 

  3348. 

  3349. def addLineBreaks(mylist):
    3350. 

  3350. 	"use LB to respect sys.platform"
    3351. 

  3351. 	ret = []
    3352. 

  3352. 	for line in mylist:
    3353. 

  3353. 		line = string.replace(line,'\n',LB)  # embedded \n's
    3354. 

  3354. 		ret.append(line+LB)                  # add final line break
    3355. 

  3355. 	return ret
    3356. 

  3356. 

  3357. # convert ['foo\nbar'] to ['foo', 'bar'] 
    3358. 

  3358. def expandLineBreaks(mylist):
    3359. 

  3359. 	ret = []
    3360. 

  3360. 	for line in mylist:
    3361. 

  3361. 		ret.extend(string.split(line, '\n'))
    3362. 

  3362. 	return ret
    3363. 

  3363. 

  3364. def compile_filters(filters, errmsg='Filter'):
    3365. 

  3365. 	if filters:
    3366. 

  3366. 		for i in range(len(filters)):
    3367. 

  3367. 			patt,repl = filters[i]
    3368. 

  3368. 			try: rgx = re.compile(patt)
    3369. 

  3369. 			except: Error("%s: '%s'"%(errmsg, patt))
    3370. 

  3370. 			filters[i] = (rgx,repl)
    3371. 

  3371. 	return filters
    3372. 

  3372. 

  3373. def enclose_me(tagname, txt):
    3374. 

  3374. 	return TAGS.get(tagname+'Open') + txt + TAGS.get(tagname+'Close')
    3375. 

  3375. 

  3376. def beautify_me(name, line):
    3377. 

  3377. 	"where name is: bold, italic or underline"
    3378. 

  3378. 	name  = 'font%s' % string.capitalize(name)
    3379. 

  3379. 	open  = TAGS['%sOpen'%name]
    3380. 

  3380. 	close = TAGS['%sClose'%name]
    3381. 

  3381. 	txt = r'%s\1%s'%(open, close)
    3382. 

  3382. 	line = regex[name].sub(txt,line)
    3383. 

  3383. 	return line
    3384. 

  3384. 

  3385. def get_tagged_link(label, url):
    3386. 

  3386. 	ret = ''
    3387. 

  3387. 	target = CONF['target']
    3388. 

  3388. 	image_re = regex['img']
    3389. 

  3389. 	
    3390. 

  3390. 	# set link type
    3391. 

  3391. 	if regex['email'].match(url):
    3392. 

  3392. 		linktype = 'email'
    3393. 

  3393. 	else:
    3394. 

  3394. 		linktype = 'url';
    3395. 

  3395. 	
    3396. 

  3396. 	# escape specials from TEXT parts
    3397. 

  3397. 	label = doEscape(target,label)
    3398. 

  3398. 	
    3399. 

  3399. 	# escape specials from link URL
    3400. 

  3400. 	if rules['linkable'] and rules['escapeurl']:
    3401. 

  3401. 		url = doEscape(target, url)
    3402. 

  3402. 	
    3403. 

  3403. 	# if not linkable, the URL is plain text, that needs escape
    3404. 

  3404. 	if not rules['linkable']:
    3405. 

  3405. 		if target == 'tex':
    3406. 

  3406. 			url = re.sub('^#', '\#', url) # ugly, but compile
    3407. 

  3407. 		else:
    3408. 

  3408. 			url = doEscape(target,url)
    3409. 

  3409. 	
    3410. 

  3410. 	# adding protocol to guessed link
    3411. 

  3411. 	guessurl = ''
    3412. 

  3412. 	if linktype == 'url' and \
    3413. 

  3413. 	   re.match(regex['_urlskel']['guess'], url):
    3414. 

  3414. 		if url[0] == 'w': guessurl = 'http://' +url
    3415. 

  3415. 		else            : guessurl =  'ftp://' +url
    3416. 

  3416. 		
    3417. 

  3417. 		# not link aware targets -> protocol is useless
    3418. 

  3418. 		if not rules['linkable']: guessurl = ''
    3419. 

  3419. 	
    3420. 

  3420. 	# simple link (not guessed)
    3421. 

  3421. 	if not label and not guessurl:
    3422. 

  3422. 		if CONF['mask-email'] and linktype == 'email':
    3423. 

  3423. 			# do the email mask feature (no TAGs, just text)
    3424. 

  3424. 			url = string.replace(url,'@',' (a) ')
    3425. 

  3425. 			url = string.replace(url,'.',' ')
    3426. 

  3426. 			url = "<%s>" % url
    3427. 

  3427. 			if rules['linkable']: url = doEscape(target, url)
    3428. 

  3428. 			ret = url
    3429. 

  3429. 		else:
    3430. 

  3430. 			# just add link data to tag
    3431. 

  3431. 			tag = TAGS[linktype]
    3432. 

  3432. 			ret = regex['x'].sub(url,tag)
    3433. 

  3433. 	
    3434. 

  3434. 	# named link or guessed simple link
    3435. 

  3435. 	else:
    3436. 

  3436. 		# adjusts for guessed link
    3437. 

  3437. 		if not label: label = url         # no   protocol
    3438. 

  3438. 		if guessurl : url   = guessurl    # with protocol
    3439. 

  3439. 		
    3440. 

  3440. 		# image inside link!
    3441. 

  3441. 		if image_re.match(label):
    3442. 

  3442. 			if rules['imglinkable']:  # get image tag
    3443. 

  3443. 				label = parse_images(label)
    3444. 

  3444. 			else:                     #  img@link !supported
    3445. 

  3445. 				label = "(%s)"%image_re.match(label).group(1)
    3446. 

  3446. 		
    3447. 

  3447. 		# putting data on the right appearance order
    3448. 

  3448. 		if rules['linkable']:
    3449. 

  3449. 			urlorder = [url, label]   # link before label
    3450. 

  3450. 		else:
    3451. 

  3451. 			urlorder = [label, url]   # label before link
    3452. 

  3452. 		
    3453. 

  3453. 		# add link data to tag (replace \a's)
    3454. 

  3454. 		ret = TAGS["%sMark"%linktype]
    3455. 

  3455. 		for data in urlorder:
    3456. 

  3456. 			ret = regex['x'].sub(data,ret,1)
    3457. 

  3457. 	
    3458. 

  3458. 	return ret
    3459. 

  3459. 

  3460. 

  3461. def parse_deflist_term(line):
    3462. 

  3462. 	"Extract and parse definition list term contents"
    3463. 

  3463. 	img_re = regex['img']
    3464. 

  3464. 	term   = regex['deflist'].search(line).group(3)
    3465. 

  3465. 	
    3466. 

  3466. 	# mask image inside term as (image.jpg), where not supported
    3467. 

  3467. 	if not rules['imgasdefterm'] and img_re.search(term):
    3468. 

  3468. 		while img_re.search(term):
    3469. 

  3469. 			imgfile = img_re.search(term).group(1)
    3470. 

  3470. 			term = img_re.sub('(%s)'%imgfile, term, 1)
    3471. 

  3471. 	
    3472. 

  3472. 	#TODO tex: escape ] on term. \], \rbrack{} and \verb!]! don't work :(
    3473. 

  3473. 	return term
    3474. 

  3474. 

  3475. 

  3476. def get_tagged_bar(line):
    3477. 

  3477. 	m = regex['bar'].search(line)
    3478. 

  3478. 	if not m: return line
    3479. 

  3479. 	txt = m.group(2)
    3480. 

  3480. 	
    3481. 

  3481. 	# map strong bar to pagebreak
    3482. 

  3482. 	if rules['mapbar2pagebreak'] and TAGS['pageBreak']:
    3483. 

  3483. 		TAGS['bar2'] = TAGS['pageBreak']
    3484. 

  3484. 	
    3485. 

  3485. 	# set bar type
    3486. 

  3486. 	if txt[0] == '=': bar = TAGS['bar2']
    3487. 

  3487. 	else            : bar = TAGS['bar1']
    3488. 

  3488. 	
    3489. 

  3489. 	# to avoid comment tag confusion like <!-- ------ -->
    3490. 

  3490. 	if string.count(TAGS['comment'], '--'):
    3491. 

  3491. 		txt = string.replace(txt,'--','__')
    3492. 

  3492. 	
    3493. 

  3493. 	# tag line
    3494. 

  3494. 	return regex['x'].sub(txt, bar)
    3495. 

  3495. 

  3496. 

  3497. def get_image_align(line):
    3498. 

  3498. 	"Return the image (first found) align for the given line"
    3499. 

  3499. 	
    3500. 

  3500. 	# first clear marks that can mess align detection
    3501. 

  3501. 	line = re.sub(SEPARATOR+'$', '', line)  # remove deflist sep
    3502. 

  3502. 	line = re.sub('^'+SEPARATOR, '', line)  # remove list sep
    3503. 

  3503. 	line = re.sub('^[\t]+'     , '', line)  # remove quote mark
    3504. 

  3504. 	
    3505. 

  3505. 	# get image position on the line
    3506. 

  3506. 	m = regex['img'].search(line)
    3507. 

  3507. 	ini = m.start() ; head = 0
    3508. 

  3508. 	end = m.end()   ; tail = len(line)
    3509. 

  3509. 	
    3510. 

  3510. 	# the align detection algorithm
    3511. 

  3511. 	if   ini == head and end != tail: align = 'left'   # ^img + text$
    3512. 

  3512. 	elif ini != head and end == tail: align = 'right'  # ^text + img$
    3513. 

  3513. 	else                            : align = 'center' # default align
    3514. 

  3514. 	
    3515. 

  3515. 	# some special cases
    3516. 

  3516. 	if BLOCK.isblock('table'): align = 'center'    # ignore when table
    3517. 

  3517. #	if TARGET == 'mgp' and align == 'center': align = 'center'
    3518. 

  3518. 	
    3519. 

  3519. 	return align
    3520. 

  3520. 

  3521. 

  3522. # reference: http://www.iana.org/assignments/character-sets
    3523. 

  3523. # http://www.drclue.net/F1.cgi/HTML/META/META.html
    3524. 

  3524. def get_encoding_string(enc, target):
    3525. 

  3525. 	if not enc: return ''
    3526. 

  3526. 	# target specific translation table
    3527. 

  3527. 	translate = {
    3528. 

  3528. 	'tex': {
    3529. 

  3529. 	  # missing: ansinew , applemac , cp437 , cp437de , cp865
    3530. 

  3530. 	  'us-ascii'    : 'ascii',
    3531. 

  3531. 	  'windows-1250': 'cp1250',
    3532. 

  3532. 	  'windows-1252': 'cp1252',
    3533. 

  3533. 	  'ibm850'      : 'cp850',
    3534. 

  3534. 	  'ibm852'      : 'cp852',
    3535. 

  3535. 	  'iso-8859-1'  : 'latin1',
    3536. 

  3536. 	  'iso-8859-2'  : 'latin2',
    3537. 

  3537. 	  'iso-8859-3'  : 'latin3',
    3538. 

  3538. 	  'iso-8859-4'  : 'latin4',
    3539. 

  3539. 	  'iso-8859-5'  : 'latin5',
    3540. 

  3540. 	  'iso-8859-9'  : 'latin9',
    3541. 

  3541. 	  'koi8-r'      : 'koi8-r'
    3542. 

  3542. 	  }
    3543. 

  3543. 	}
    3544. 

  3544. 	# normalization
    3545. 

  3545. 	enc = re.sub('(?i)(us[-_]?)?ascii|us|ibm367','us-ascii'  , enc)
    3546. 

  3546. 	enc = re.sub('(?i)(ibm|cp)?85([02])'        ,'ibm85\\2'  , enc)
    3547. 

  3547. 	enc = re.sub('(?i)(iso[_-]?)?8859[_-]?'     ,'iso-8859-' , enc)
    3548. 

  3548. 	enc = re.sub('iso-8859-($|[^1-9]).*'        ,'iso-8859-1', enc)
    3549. 

  3549. 	# apply translation table
    3550. 

  3550. 	try: enc = translate[target][string.lower(enc)]
    3551. 

  3551. 	except: pass
    3552. 

  3552. 	return enc
    3553. 

  3553. 

  3554. 

  3555. ##############################################################################
    3556. 

  3556. ##MerryChristmas,IdontwanttofighttonightwithyouImissyourbodyandIneedyourlove##
    3557. 

  3557. ##############################################################################
    3558. 

  3558. 

  3559. 

  3560. def process_source_file(file='', noconf=0, contents=[]):
    3561. 

  3561. 	"""
    3562. 

  3562. 	Find and Join all the configuration available for a source file.
    3563. 

  3563. 	No sanity checkings are done on this step.
    3564. 

  3564. 	It also extracts the source document parts into separate holders.
    3565. 

  3565. 	
    3566. 

  3566. 	The config scan order is:
    3567. 

  3567. 	   1. The user configuration file (i.e. $HOME/.txt2tagsrc)
    3568. 

  3568. 	   2. The source document's CONF area
    3569. 

  3569. 	   3. The command line options
    3570. 

  3570. 

  3571. 	The return data is a tuple of two items:
    3572. 

  3572. 	   1. The parsed config dictionary
    3573. 

  3573. 	   2. The document's parts, as a (head, conf, body) tuple
    3574. 

  3574. 	
    3575. 

  3575. 	All the conversion process will be based on the data and
    3576. 

  3576. 	configuration returned by this function.
    3577. 

  3577. 	The source files is readed on this step only.
    3578. 

  3578. 	"""
    3579. 

  3579. 	if contents:
    3580. 

  3580. 		source = SourceDocument(contents=contents)
    3581. 

  3581. 	else:
    3582. 

  3582. 		source = SourceDocument(file)
    3583. 

  3583. 	head, conf, body = source.split()
    3584. 

  3584. 	Message(_("Source document contents stored"),2)
    3585. 

  3585. 	if not noconf:
    3586. 

  3586. 		# read document config
    3587. 

  3587. 		source_raw = source.get_raw_config()
    3588. 

  3588. 		# join all the config directives found, then parse it
    3589. 

  3589. 		full_raw = RC_RAW + source_raw + CMDLINE_RAW
    3590. 

  3590. 		Message(_("Parsing and saving all config found (%03d items)")%(
    3591. 

  3591. 		        len(full_raw)),1)
    3592. 

  3592. 		full_parsed = ConfigMaster(full_raw).parse()
    3593. 

  3593. 		# add manually the filemane to the conf dic
    3594. 

  3594. 		if contents:
    3595. 

  3595. 			full_parsed['sourcefile'] = MODULEIN
    3596. 

  3596. 			full_parsed['infile'] = MODULEIN
    3597. 

  3597. 			full_parsed['outfile'] = MODULEOUT
    3598. 

  3598. 		else:
    3599. 

  3599. 			full_parsed['sourcefile'] = file
    3600. 

  3600. 		# maybe should we dump the config found?
    3601. 

  3601. 		if full_parsed.get('dump-config'):
    3602. 

  3602. 			dumpConfig(source_raw, full_parsed)
    3603. 

  3603. 			Quit()
    3604. 

  3604. 		# okay, all done
    3605. 

  3605. 		Debug("FULL config for this file: %s"%full_parsed, 1)
    3606. 

  3606. 	else:
    3607. 

  3607. 		full_parsed = {}
    3608. 

  3608. 	return full_parsed, (head,conf,body)
    3609. 

  3609. 

  3610. def get_infiles_config(infiles):
    3611. 

  3611. 	"""
    3612. 

  3612. 	Find and Join into a single list, all configuration available
    3613. 

  3613. 	for each input file. This function is supposed to be the very
    3614. 

  3614. 	first one to be called, before any processing.
    3615. 

  3615. 	"""
    3616. 

  3616. 	ret = []
    3617. 

  3617. 	if not infiles: return []
    3618. 

  3618. 	for infile in infiles:
    3619. 

  3619. 		ret.append((process_source_file(infile)))
    3620. 

  3620. 	return ret
    3621. 

  3621. 

  3622. def convert_this_files(configs):
    3623. 

  3623. 	global CONF
    3624. 

  3624. 	for myconf,doc in configs:                 # multifile support
    3625. 

  3625. 		target_head = []
    3626. 

  3626. 		target_toc  = []
    3627. 

  3627. 		target_body = []
    3628. 

  3628. 		target_foot = []
    3629. 

  3629. 		source_head, source_conf, source_body = doc
    3630. 

  3630. 		myconf = ConfigMaster().sanity(myconf)
    3631. 

  3631. 		# compose the target file Headers
    3632. 

  3632. 		#TODO escape line before?
    3633. 

  3633. 		#TODO see exceptions by tex and mgp
    3634. 

  3634. 		Message(_("Composing target Headers"),1)
    3635. 

  3635. 		target_head = doHeader(source_head, myconf)
    3636. 

  3636. 		# parse the full marked body into tagged target
    3637. 

  3637. 		first_body_line = (len(source_head) or 1)+ len(source_conf) + 1
    3638. 

  3638. 		Message(_("Composing target Body"),1)
    3639. 

  3639. 		target_body, marked_toc = convert(source_body, myconf,
    3640. 

  3640. 		                          firstlinenr=first_body_line)
    3641. 

  3641. 		# if dump-source, we're done
    3642. 

  3642. 		if myconf['dump-source']:
    3643. 

  3643. 			for line in source_head+source_conf+target_body:
    3644. 

  3644. 				print line
    3645. 

  3645. 			return
    3646. 

  3646. 		# make TOC (if needed)
    3647. 

  3647. 		Message(_("Composing target TOC"),1)
    3648. 

  3648. 		tagged_toc  = toc_tagger(marked_toc, myconf)
    3649. 

  3649. 		target_toc  = toc_formatter(tagged_toc, myconf)
    3650. 

  3650. 		target_body = toc_inside_body(target_body, target_toc, myconf)
    3651. 

  3651. 		if not AUTOTOC and not myconf['toc-only']: target_toc = []
    3652. 

  3652. 		# compose the target file Footer
    3653. 

  3653. 		Message(_("Composing target Footer"),1)
    3654. 

  3654. 		target_foot = doFooter(myconf)
    3655. 

  3655. 		# finally, we have our document
    3656. 

  3656. 		outlist = target_head + target_toc + target_body + target_foot
    3657. 

  3657. 		# if on GUI, abort before finish_him
    3658. 

  3658. 		# if module, return finish_him as list
    3659. 

  3659. 		# else, write results to file or STDOUT
    3660. 

  3660. 		if GUI:
    3661. 

  3661. 			return outlist, myconf
    3662. 

  3662. 		elif myconf.get('outfile') == MODULEOUT:
    3663. 

  3663. 			return finish_him(outlist, myconf), myconf
    3664. 

  3664. 		else:
    3665. 

  3665. 			Message(_("Saving results to the output file"),1)
    3666. 

  3666. 			finish_him(outlist, myconf)
    3667. 

  3667. 

  3668. 

  3669. def parse_images(line):
    3670. 

  3670. 	"Tag all images found"
    3671. 

  3671. 	while regex['img'].search(line) and TAGS['img'] != '[\a]':
    3672. 

  3672. 		txt = regex['img'].search(line).group(1)
    3673. 

  3673. 		tag = TAGS['img']
    3674. 

  3674. 		
    3675. 

  3675. 		# HTML, XHTML and mgp!
    3676. 

  3676. 		if rules['imgalignable']:
    3677. 

  3677. 			align = get_image_align(line)
    3678. 

  3678. 			# add align on tag
    3679. 

  3679. 			align_name = string.capitalize(align)
    3680. 

  3680. 			align_tag = TAGS['imgAlign'+align_name]
    3681. 

  3681. 			tag = regex['_imgAlign'].sub(align_tag, tag, 1)
    3682. 

  3682. 			# dirty fix to allow centered solo images
    3683. 

  3683. 			if align == 'center' and TARGET in ['html','xhtml']:
    3684. 

  3684. 				rest = regex['img'].sub('',line,1)
    3685. 

  3685. 				if re.match('^\s+$', rest):
    3686. 

  3686. 					tag = "<center>%s</center>" %tag
    3687. 

  3687. 		
    3688. 

  3688. 		if TARGET == 'tex':
    3689. 

  3689. 			tag = re.sub(r'\\b',r'\\\\b',tag)
    3690. 

  3690. 			txt = string.replace(txt, '_', 'vvvvTexUndervvvv')
    3691. 

  3691. 		
    3692. 

  3692. 		line = regex['img'].sub(tag,line,1)
    3693. 

  3693. 		line = regex['x'].sub(txt,line,1)
    3694. 

  3694. 	return line
    3695. 

  3695. 

  3696. 

  3697. def add_inline_tags(line):
    3698. 

  3698. 	# beautifiers
    3699. 

  3699. 	for beauti in ['Bold', 'Italic', 'Underline']:
    3700. 

  3700. 		if regex['font%s'%beauti].search(line):
    3701. 

  3701. 			line = beautify_me(beauti, line)
    3702. 

  3702. 	
    3703. 

  3703. 	line = parse_images(line)
    3704. 

  3704. 	return line
    3705. 

  3705. 

  3706. 

  3707. def get_include_contents(file, path=''):
    3708. 

  3708. 	"Parses %!include: value and extract file contents"
    3709. 

  3709. 	ids = {'`':'verb', '"':'raw', "'":'passthru' }
    3710. 

  3710. 	id = 't2t'
    3711. 

  3711. 	# set include type and remove identifier marks
    3712. 

  3712. 	mark = file[0]
    3713. 

  3713. 	if mark in ids.keys():
    3714. 

  3714. 		if file[:2] == file[-2:] == mark*2:
    3715. 

  3715. 			id = ids[mark]     # set type
    3716. 

  3716. 			file = file[2:-2]  # remove marks
    3717. 

  3717. 	# handle remote dir execution
    3718. 

  3718. 	filepath = os.path.join(path, file)
    3719. 

  3719. 	# read included file contents
    3720. 

  3720. 	lines = Readfile(filepath, remove_linebreaks=1)
    3721. 

  3721. 	# default txt2tags marked text, just BODY matters
    3722. 

  3722. 	if id == 't2t':
    3723. 

  3723. 		lines = get_file_body(filepath)
    3724. 

  3724. 		lines.insert(0, '%%INCLUDED(%s) starts here: %s'%(id,file))
    3725. 

  3725. 		# This appears when included hit EOF with verbatim area open
    3726. 

  3726. 		#lines.append('%%INCLUDED(%s) ends here: %s'%(id,file))
    3727. 

  3727. 	return id, lines
    3728. 

  3728. 

  3729. 

  3730. def set_global_config(config):
    3731. 

  3731. 	global CONF, TAGS, regex, rules, TARGET
    3732. 

  3732. 	CONF   = config
    3733. 

  3733. 	TAGS   = getTags(CONF)
    3734. 

  3734. 	rules  = getRules(CONF)
    3735. 

  3735. 	regex  = getRegexes()
    3736. 

  3736. 	TARGET = config['target']  # save for buggy functions that need global
    3737. 

  3737. 

  3738. 

  3739. def convert(bodylines, config, firstlinenr=1):
    3740. 

  3740. 	global BLOCK
    3741. 

  3741. 	
    3742. 

  3742. 	set_global_config(config)
    3743. 

  3743. 	
    3744. 

  3744. 	target = config['target']
    3745. 

  3745. 	BLOCK = BlockMaster()
    3746. 

  3746. 	MASK  =  MaskMaster()
    3747. 

  3747. 	TITLE = TitleMaster()
    3748. 

  3748. 	
    3749. 

  3749. 	ret = []
    3750. 

  3750. 	dump_source = []
    3751. 

  3751. 	f_lastwasblank = 0
    3752. 

  3752. 	
    3753. 

  3753. 	# compiling all PreProc regexes
    3754. 

  3754. 	pre_filter = compile_filters(
    3755. 

  3755. 		CONF['preproc'], _('Invalid PreProc filter regex'))
    3756. 

  3756. 	
    3757. 

  3757. 	# let's mark it up!
    3758. 

  3758. 	linenr = firstlinenr-1
    3759. 

  3759. 	lineref = 0
    3760. 

  3760. 	while lineref < len(bodylines):
    3761. 

  3761. 		# defaults
    3762. 

  3762. 		MASK.reset()
    3763. 

  3763. 		results_box = ''
    3764. 

  3764. 		
    3765. 

  3765. 		untouchedline = bodylines[lineref]
    3766. 

  3766. 		dump_source.append(untouchedline)
    3767. 

  3767. 		
    3768. 

  3768. 		line = re.sub('[\n\r]+$','',untouchedline)   # del line break
    3769. 

  3769. 		
    3770. 

  3770. 		# apply PreProc filters
    3771. 

  3771. 		if pre_filter:
    3772. 

  3772. 			errmsg = _('Invalid PreProc filter replacement')
    3773. 

  3773. 			for rgx,repl in pre_filter:
    3774. 

  3774. 				try: line = rgx.sub(repl, line)
    3775. 

  3775. 				except: Error("%s: '%s'"%(errmsg, repl))
    3776. 

  3776. 		
    3777. 

  3777. 		line = maskEscapeChar(line)                  # protect \ char
    3778. 

  3778. 		linenr  = linenr  +1
    3779. 

  3779. 		lineref = lineref +1
    3780. 

  3780. 		
    3781. 

  3781. 		Debug(repr(line), 2, linenr)  # heavy debug: show each line
    3782. 

  3782. 		
    3783. 

  3783. 		# any NOT table line (or comment), closes an open table
    3784. 

  3784. 		if ( BLOCK.isblock('table') or
    3785. 

  3785. 		      ( BLOCK.isblock('verb') and
    3786. 

  3786. 		        BLOCK.prop('mapped') == 'table'
    3787. 

  3787. 		       )
    3788. 

  3788. 		    ) \
    3789. 

  3789. 		   and not regex['table'].search(line) \
    3790. 

  3790. 		   and not regex['comment'].search(line):
    3791. 

  3791. 			ret.extend(BLOCK.blockout())
    3792. 

  3792. 		
    3793. 

  3793. 		# any NOT quote line (or comment) closes all open quotes
    3794. 

  3794. 		if BLOCK.isblock('quote') \
    3795. 

  3795. 		   and not regex['quote'].search(line) \
    3796. 

  3796. 		   and not regex['comment'].search(line):
    3797. 

  3797. 			while BLOCK.isblock('quote'):
    3798. 

  3798. 				ret.extend(BLOCK.blockout())
    3799. 

  3799. 		
    3800. 

  3800. 		
    3801. 

  3801. 		#-------------------------[ Raw Text ]----------------------
    3802. 

  3802. 		
    3803. 

  3803. 		# we're already on a raw block
    3804. 

  3804. 		if BLOCK.block() == 'raw':
    3805. 

  3805. 		
    3806. 

  3806. 			# closing raw
    3807. 

  3807. 			if regex['blockRawClose'].search(line):
    3808. 

  3808. 				ret.extend(BLOCK.blockout())
    3809. 

  3809. 				continue
    3810. 

  3810. 			
    3811. 

  3811. 			# normal raw-inside line
    3812. 

  3812. 			BLOCK.holdadd(line)
    3813. 

  3813. 			continue
    3814. 

  3814. 		
    3815. 

  3815. 		# detecting raw block init
    3816. 

  3816. 		if regex['blockRawOpen'].search(line):
    3817. 

  3817. 			ret.extend(BLOCK.blockin('raw'))
    3818. 

  3818. 			continue
    3819. 

  3819. 		
    3820. 

  3820. 		# one line verb-formatted text
    3821. 

  3821. 		if regex['1lineRaw'].search(line):
    3822. 

  3822. 			ret.extend(BLOCK.blockin('raw'))
    3823. 

  3823. 			line = regex['1lineRaw'].sub('',line)
    3824. 

  3824. 			BLOCK.holdadd(line)
    3825. 

  3825. 			ret.extend(BLOCK.blockout())
    3826. 

  3826. 			continue
    3827. 

  3827. 		
    3828. 

  3828. 		#-----------------[ Verbatim (PRE-formatted) ]--------------
    3829. 

  3829. 		
    3830. 

  3830. 		#TIP we'll never support beautifiers inside verbatim
    3831. 

  3831. 		
    3832. 

  3832. 		# we're already on a verb block
    3833. 

  3833. 		if BLOCK.block() == 'verb':
    3834. 

  3834. 			
    3835. 

  3835. 			# closing verb
    3836. 

  3836. 			if regex['blockVerbClose'].search(line):
    3837. 

  3837. 				ret.extend(BLOCK.blockout())
    3838. 

  3838. 				continue
    3839. 

  3839. 			
    3840. 

  3840. 			# normal verb-inside line
    3841. 

  3841. 			BLOCK.holdadd(line)
    3842. 

  3842. 			continue
    3843. 

  3843. 		
    3844. 

  3844. 		# detecting verb block init
    3845. 

  3845. 		if regex['blockVerbOpen'].search(line):
    3846. 

  3846. 			ret.extend(BLOCK.blockin('verb'))
    3847. 

  3847. 			f_lastwasblank = 0
    3848. 

  3848. 			continue
    3849. 

  3849. 		
    3850. 

  3850. 		# one line verb-formatted text
    3851. 

  3851. 		if regex['1lineVerb'].search(line):
    3852. 

  3852. 			ret.extend(BLOCK.blockin('verb'))
    3853. 

  3853. 			line = regex['1lineVerb'].sub('',line)
    3854. 

  3854. 			BLOCK.holdadd(line)
    3855. 

  3855. 			ret.extend(BLOCK.blockout())
    3856. 

  3856. 			f_lastwasblank = 0
    3857. 

  3857. 			continue
    3858. 

  3858. 		
    3859. 

  3859. 		# tables are mapped to verb when target is not table-aware
    3860. 

  3860. 		if not rules['tableable'] and regex['table'].search(line):
    3861. 

  3861. 			if not BLOCK.isblock('verb'):
    3862. 

  3862. 				ret.extend(BLOCK.blockin('verb'))
    3863. 

  3863. 				BLOCK.propset('mapped', 'table')
    3864. 

  3864. 				BLOCK.holdadd(line)
    3865. 

  3865. 				continue
    3866. 

  3866. 		
    3867. 

  3867. 		#---------------------[ blank lines ]-----------------------
    3868. 

  3868. 		
    3869. 

  3869. 		if regex['blankline'].search(line):
    3870. 

  3870. 			
    3871. 

  3871. 			# close open paragraph
    3872. 

  3872. 			if BLOCK.isblock('para'):
    3873. 

  3873. 				ret.extend(BLOCK.blockout())
    3874. 

  3874. 				f_lastwasblank = 1
    3875. 

  3875. 				continue
    3876. 

  3876. 			
    3877. 

  3877. 			# close all open quotes
    3878. 

  3878. 			while BLOCK.isblock('quote'):
    3879. 

  3879. 				ret.extend(BLOCK.blockout())
    3880. 

  3880. 			
    3881. 

  3881. 			# closing all open lists
    3882. 

  3882. 			if f_lastwasblank:          # 2nd consecutive blank
    3883. 

  3883. 				if BLOCK.block()[-4:] == 'list':
    3884. 

  3884. 					BLOCK.holdaddsub('')   # helps parser
    3885. 

  3885. 				while BLOCK.depth:  # closes list (if any)
    3886. 

  3886. 					ret.extend(BLOCK.blockout())
    3887. 

  3887. 				continue            # ignore consecutive blanks
    3888. 

  3888. 			
    3889. 

  3889. 			# paragraph (if any) is wanted inside lists also
    3890. 

  3890. 			if BLOCK.block()[-4:] == 'list':
    3891. 

  3891. 				BLOCK.holdaddsub('')
    3892. 

  3892. 			else:
    3893. 

  3893. 				# html: show blank line (needs tag)
    3894. 

  3894. 				if target in ['html','xhtml']:
    3895. 

  3895. 					ret.append(TAGS['paragraphOpen']+\
    3896. 

  3896. 					           TAGS['paragraphClose'])
    3897. 

  3897. 				# otherwise we just show a blank line
    3898. 

  3898. 				else:
    3899. 

  3899. 					ret.append('')
    3900. 

  3900. 			
    3901. 

  3901. 			f_lastwasblank = 1
    3902. 

  3902. 			continue
    3903. 

  3903. 		
    3904. 

  3904. 		
    3905. 

  3905. 		#---------------------[ special ]---------------------------
    3906. 

  3906. 		
    3907. 

  3907. 		if regex['special'].search(line):
    3908. 

  3908. 			# include command
    3909. 

  3909. 			targ, key, val = ConfigLines().parse_line(
    3910. 

  3910. 			                   line, 'include', target)
    3911. 

  3911. 			if key:
    3912. 

  3912. 				Debug("Found config '%s', value '%s'"%(
    3913. 

  3913. 				       key,val),1,linenr)
    3914. 

  3914. 				
    3915. 

  3915. 				incpath = os.path.dirname(CONF['sourcefile'])
    3916. 

  3916. 				incfile = val
    3917. 

  3917. 				err = _('A file cannot include itself (loop!)')
    3918. 

  3918. 				if CONF['sourcefile'] == incfile:
    3919. 

  3919. 					Error("%s: %s"%(err,incfile))
    3920. 

  3920. 				inctype, inclines = get_include_contents(
    3921. 

  3921. 				                      incfile, incpath)
    3922. 

  3922. 				# verb, raw and passthru are easy
    3923. 

  3923. 				if inctype != 't2t':
    3924. 

  3924. 					ret.extend(BLOCK.blockin(inctype))
    3925. 

  3925. 					BLOCK.holdextend(inclines)
    3926. 

  3926. 					ret.extend(BLOCK.blockout())
    3927. 

  3927. 				else:
    3928. 

  3928. 					# insert include lines into body
    3929. 

  3929. 					#TODO include maxdepth limit
    3930. 

  3930. 					bodylines = bodylines[:lineref] \
    3931. 

  3931. 					           +inclines \
    3932. 

  3932. 					           +bodylines[lineref:]
    3933. 

  3933. 					#TODO fix path if include@include
    3934. 

  3934. 					# remove %!include call
    3935. 

  3935. 					if CONF['dump-source']:
    3936. 

  3936. 						dump_source.pop()
    3937. 

  3937. 				continue
    3938. 

  3938. 			else:
    3939. 

  3939. 				Debug('Bogus Special Line',1,linenr)
    3940. 

  3940. 		
    3941. 

  3941. 		#---------------------[ dump-source ]-----------------------
    3942. 

  3942. 		
    3943. 

  3943. 		# we don't need to go any further
    3944. 

  3944. 		if CONF['dump-source']:
    3945. 

  3945. 			continue
    3946. 

  3946. 		
    3947. 

  3947. 		#---------------------[ comments ]--------------------------
    3948. 

  3948. 		
    3949. 

  3949. 		# just skip them (if not macro)
    3950. 

  3950. 		if regex['comment'].search(line) and not \
    3951. 

  3951. 		   regex['macros'].match(line) and not \
    3952. 

  3952. 		   regex['toc'].match(line):
    3953. 

  3953. 			continue
    3954. 

  3954. 		
    3955. 

  3955. 		# valid line, reset blank status
    3956. 

  3956. 		f_lastwasblank = 0
    3957. 

  3957. 		
    3958. 

  3958. 		#---------------------[ Horizontal Bar ]--------------------
    3959. 

  3959. 		
    3960. 

  3960. 		if regex['bar'].search(line):
    3961. 

  3961. 			
    3962. 

  3962. 			# a bar closes a paragraph
    3963. 

  3963. 			if BLOCK.isblock('para'):
    3964. 

  3964. 				ret.extend(BLOCK.blockout())
    3965. 

  3965. 			
    3966. 

  3966. 			# we need to close all opened quote blocks
    3967. 

  3967. 			# if bar isn't allowed inside or if not a quote line
    3968. 

  3968. 			if BLOCK.isblock('quote'):
    3969. 

  3969. 				if not rules['barinsidequote'] or \
    3970. 

  3970. 				   not regex['quote'].search(line):
    3971. 

  3971. 					while BLOCK.isblock('quote'):
    3972. 

  3972. 						ret.extend(BLOCK.blockout())
    3973. 

  3973. 			
    3974. 

  3974. 			# quote + bar: continue processing for quoting
    3975. 

  3975. 			if rules['barinsidequote'] and \
    3976. 

  3976. 			   regex['quote'].search(line):
    3977. 

  3977. 				pass
    3978. 

  3978. 			
    3979. 

  3979. 			# just bar: save tagged line and we're done
    3980. 

  3980. 			else:
    3981. 

  3981. 				line = get_tagged_bar(line)
    3982. 

  3982. 				if BLOCK.block()[-4:] == 'list':
    3983. 

  3983. 					BLOCK.holdaddsub(line)
    3984. 

  3984. 				elif BLOCK.block():
    3985. 

  3985. 					BLOCK.holdadd(line)
    3986. 

  3986. 				else:
    3987. 

  3987. 					ret.append(line)
    3988. 

  3988. 					Debug("BAR: %s"%line, 6)
    3989. 

  3989. 				continue
    3990. 

  3990. 		
    3991. 

  3991. 		#---------------------[ Title ]-----------------------------
    3992. 

  3992. 		
    3993. 

  3993. 		#TODO set next blank and set f_lastwasblank or f_lasttitle
    3994. 

  3994. 		if (regex['title'].search(line) or
    3995. 

  3995. 		    regex['numtitle'].search(line)) and \
    3996. 

  3996. 		    BLOCK.block()[-4:] != 'list':
    3997. 

  3997. 			
    3998. 

  3998. 			# a title closes a paragraph
    3999. 

  3999. 			if BLOCK.isblock('para'):
    4000. 

  4000. 				ret.extend(BLOCK.blockout())
    4001. 

  4001. 			
    4002. 

  4002. 			TITLE.add(line)
    4003. 

  4003. 			tagged_title = TITLE.get()
    4004. 

  4004. 			ret.extend(tagged_title)
    4005. 

  4005. 			Debug("TITLE: %s"%tagged_title, 6)
    4006. 

  4006. 			
    4007. 

  4007. 			f_lastwasblank = 1
    4008. 

  4008. 			continue
    4009. 

  4009. 		
    4010. 

  4010. 		#---------------------[ %%toc ]-----------------------
    4011. 

  4011. 		
    4012. 

  4012. 		# %%toc line closes paragraph
    4013. 

  4013. 		if BLOCK.block() == 'para' and regex['toc'].search(line):
    4014. 

  4014. 			ret.extend(BLOCK.blockout())
    4015. 

  4015. 		
    4016. 

  4016. 		#---------------------[ apply masks ]-----------------------
    4017. 

  4017. 		
    4018. 

  4018. 		line = MASK.mask(line)
    4019. 

  4019. 		
    4020. 

  4020. 		#XXX from here, only block-inside lines will pass
    4021. 

  4021. 		
    4022. 

  4022. 		#---------------------[ Quote ]-----------------------------
    4023. 

  4023. 		
    4024. 

  4024. 		if regex['quote'].search(line):
    4025. 

  4025. 			
    4026. 

  4026. 			# store number of leading TABS
    4027. 

  4027. 			quotedepth = len(regex['quote'].search(line).group(0))
    4028. 

  4028. 			
    4029. 

  4029. 			# SGML doesn't support nested quotes
    4030. 

  4030. 			if rules['quotenotnested']: quotedepth = 1
    4031. 

  4031. 			
    4032. 

  4032. 			# new quote
    4033. 

  4033. 			if not BLOCK.isblock('quote'):
    4034. 

  4034. 				ret.extend(BLOCK.blockin('quote'))
    4035. 

  4035. 			
    4036. 

  4036. 			# new subquotes
    4037. 

  4037. 			while BLOCK.depth < quotedepth:
    4038. 

  4038. 				BLOCK.blockin('quote')
    4039. 

  4039. 			
    4040. 

  4040. 			# closing quotes
    4041. 

  4041. 			while quotedepth < BLOCK.depth:
    4042. 

  4042. 				ret.extend(BLOCK.blockout())
    4043. 

  4043. 		
    4044. 

  4044. 		#---------------------[ Lists ]-----------------------------
    4045. 

  4045. 		
    4046. 

  4046. 		# an empty item also closes the current list
    4047. 

  4047. 		if BLOCK.block()[-4:] == 'list':
    4048. 

  4048. 			m = regex['listclose'].match(line)
    4049. 

  4049. 			if m:
    4050. 

  4050. 				listindent = m.group(1)
    4051. 

  4051. 				listtype = m.group(2)
    4052. 

  4052. 				currlisttype = BLOCK.prop('type')
    4053. 

  4053. 				currlistindent = BLOCK.prop('indent')
    4054. 

  4054. 				if listindent == currlistindent and \
    4055. 

  4055. 				   listtype == currlisttype:
    4056. 

  4056. 					ret.extend(BLOCK.blockout())
    4057. 

  4057. 					continue
    4058. 

  4058. 		
    4059. 

  4059. 		if   regex['list'].search(line) or \
    4060. 

  4060. 		  regex['numlist'].search(line) or \
    4061. 

  4061. 		  regex['deflist'].search(line):
    4062. 

  4062. 			
    4063. 

  4063. 			listindent = BLOCK.prop('indent')
    4064. 

  4064. 			listids = string.join(LISTNAMES.keys(), '')
    4065. 

  4065. 			m = re.match('^( *)([%s]) '%listids, line)
    4066. 

  4066. 			listitemindent = m.group(1)
    4067. 

  4067. 			listtype = m.group(2)
    4068. 

  4068. 			listname = LISTNAMES[listtype]
    4069. 

  4069. 			results_box = BLOCK.holdadd
    4070. 

  4070. 			
    4071. 

  4071. 			# del list ID (and separate term from definition)
    4072. 

  4072. 			if listname == 'deflist':
    4073. 

  4073. 				term = parse_deflist_term(line)
    4074. 

  4074. 				line = regex['deflist'].sub(term+SEPARATOR,line)
    4075. 

  4075. 			else:
    4076. 

  4076. 				line = regex[listname].sub(SEPARATOR,line)
    4077. 

  4077. 			
    4078. 

  4078. 			# don't cross depth limit
    4079. 

  4079. 			maxdepth = rules['listmaxdepth']
    4080. 

  4080. 			if maxdepth and BLOCK.depth == maxdepth:
    4081. 

  4081. 				if len(listitemindent) > len(listindent):
    4082. 

  4082. 					listitemindent = listindent
    4083. 

  4083. 			
    4084. 

  4084. 			# open mother list or sublist
    4085. 

  4085. 			if BLOCK.block()[-4:] != 'list' or \
    4086. 

  4086. 			   len(listitemindent) > len(listindent):
    4087. 

  4087. 				ret.extend(BLOCK.blockin(listname))
    4088. 

  4088. 				BLOCK.propset('indent',listitemindent)
    4089. 

  4089. 				BLOCK.propset('type',listtype)
    4090. 

  4090. 			
    4091. 

  4091. 			# closing sublists
    4092. 

  4092. 			while len(listitemindent) < len(BLOCK.prop('indent')):
    4093. 

  4093. 				ret.extend(BLOCK.blockout())
    4094. 

  4094. 			
    4095. 

  4095. 			# o-oh, sublist before list ("\n\n  - foo\n- foo")
    4096. 

  4096. 			# fix: close sublist (as mother), open another list
    4097. 

  4097. 			if BLOCK.block()[-4:] != 'list':
    4098. 

  4098. 				ret.extend(BLOCK.blockin(listname))
    4099. 

  4099. 				BLOCK.propset('indent',listitemindent)
    4100. 

  4100. 				BLOCK.propset('type',listtype)
    4101. 

  4101. 		
    4102. 

  4102. 		#---------------------[ Table ]-----------------------------
    4103. 

  4103. 		
    4104. 

  4104. 		#TODO escape undesired format inside table
    4105. 

  4105. 		#TODO add pm6 target
    4106. 

  4106. 		if regex['table'].search(line):
    4107. 

  4107. 			
    4108. 

  4108. 			if not BLOCK.isblock('table'):   # first table line!
    4109. 

  4109. 				ret.extend(BLOCK.blockin('table'))
    4110. 

  4110. 				BLOCK.tableparser.__init__(line)
    4111. 

  4111. 			
    4112. 

  4112. 			tablerow = TableMaster().parse_row(line)
    4113. 

  4113. 			BLOCK.tableparser.add_row(tablerow)     # save config
    4114. 

  4114. 			
    4115. 

  4115. 			# maintain line to unmask and inlines
    4116. 

  4116. 			line = string.join(tablerow['cells'], SEPARATOR)
    4117. 

  4117. 		
    4118. 

  4118. 		#---------------------[ Paragraph ]-------------------------
    4119. 

  4119. 		
    4120. 

  4120. 		if not BLOCK.block() and \
    4121. 

  4121. 		   not string.count(line, MASK.tocmask): # new para!
    4122. 

  4122. 			ret.extend(BLOCK.blockin('para'))
    4123. 

  4123. 		
    4124. 

  4124. 		
    4125. 

  4125. 		############################################################
    4126. 

  4126. 		############################################################
    4127. 

  4127. 		############################################################
    4128. 

  4128. 		
    4129. 

  4129. 		
    4130. 

  4130. 		#---------------------[ Final Parses ]----------------------
    4131. 

  4131. 		
    4132. 

  4132. 		# the target-specific special char escapes for body lines
    4133. 

  4133. 		line = doEscape(target,line)
    4134. 

  4134. 		
    4135. 

  4135. 		line = add_inline_tags(line)
    4136. 

  4136. 		line = MASK.undo(line)
    4137. 

  4137. 		
    4138. 

  4138. 		
    4139. 

  4139. 		#---------------------[ Hold or Return? ]-------------------
    4140. 

  4140. 		
    4141. 

  4141. 		### now we must choose here to put the parsed line
    4142. 

  4142. 		#
    4143. 

  4143. 		if not results_box:
    4144. 

  4144. 			# list item extra lines
    4145. 

  4145. 			if BLOCK.block()[-4:] == 'list':
    4146. 

  4146. 				results_box = BLOCK.holdaddsub
    4147. 

  4147. 			# other blocks
    4148. 

  4148. 			elif BLOCK.block():
    4149. 

  4149. 				results_box = BLOCK.holdadd
    4150. 

  4150. 			# no blocks
    4151. 

  4151. 			else:
    4152. 

  4152. 				line = doFinalEscape(target, line)
    4153. 

  4153. 				results_box = ret.append
    4154. 

  4154. 		
    4155. 

  4155. 		results_box(line)
    4156. 

  4156. 	
    4157. 

  4157. 	# EOF: close any open para/verb/lists/table/quotes
    4158. 

  4158. 	Debug('EOF',7)
    4159. 

  4159. 	while BLOCK.block():
    4160. 

  4160. 		ret.extend(BLOCK.blockout())
    4161. 

  4161. 	
    4162. 

  4162. 	# maybe close some opened title area?
    4163. 

  4163. 	if rules['titleblocks']:
    4164. 

  4164. 		ret.extend(TITLE.close_all())
    4165. 

  4165. 	
    4166. 

  4166. 	# maybe a major tag to enclose body? (like DIV for CSS)
    4167. 

  4167. 	if TAGS['bodyOpen' ]: ret.insert(0, TAGS['bodyOpen'])
    4168. 

  4168. 	if TAGS['bodyClose']: ret.append(TAGS['bodyClose'])
    4169. 

  4169. 	
    4170. 

  4170. 	if CONF['toc-only']: ret = []
    4171. 

  4171. 	marked_toc = TITLE.dump_marked_toc(CONF['toc-level'])
    4172. 

  4172. 	
    4173. 

  4173. 	# if dump-source, all parsing is ignored
    4174. 

  4174. 	if CONF['dump-source']: ret = dump_source[:]
    4175. 

  4175. 	
    4176. 

  4176. 	return ret, marked_toc
    4177. 

  4177. 

  4178. 

  4179. 

  4180. ##############################################################################
    4181. 

  4181. ################################### GUI ######################################
    4182. 

  4182. ##############################################################################
    4183. 

  4183. #
    4184. 

  4184. # tk help: http://python.org/topics/tkinter/
    4185. 

  4185. #    tuto: http://ibiblio.org/obp/py4fun/gui/tkPhone.html
    4186. 

  4186. #          /usr/lib/python*/lib-tk/Tkinter.py
    4187. 

  4187. #
    4188. 

  4188. # grid table : row=0, column=0, columnspan=2, rowspan=2
    4189. 

  4189. # grid align : sticky='n,s,e,w' (North, South, East, West)
    4190. 

  4190. # pack place : side='top,bottom,right,left'
    4191. 

  4191. # pack fill  : fill='x,y,both,none', expand=1
    4192. 

  4192. # pack align : anchor='n,s,e,w' (North, South, East, West)
    4193. 

  4193. # padding    : padx=10, pady=10, ipadx=10, ipady=10 (internal)
    4194. 

  4194. # checkbox   : offvalue is return if the _user_ deselected the box
    4195. 

  4195. # label align: justify=left,right,center
    4196. 

  4196. 

  4197. def load_GUI_resources():
    4198. 

  4198. 	"Load all extra modules and methods used by GUI"
    4199. 

  4199. 	global askopenfilename, showinfo, showwarning, showerror, Tkinter
    4200. 

  4200. 	from tkFileDialog import askopenfilename
    4201. 

  4201. 	from tkMessageBox import showinfo,showwarning,showerror
    4202. 

  4202. 	import Tkinter
    4203. 

  4203. 

  4204. class Gui:
    4205. 

  4205. 	"Graphical Tk Interface"
    4206. 

  4206. 	def __init__(self, conf={}):
    4207. 

  4207. 		self.root = Tkinter.Tk()    # mother window, come to butthead
    4208. 

  4208. 		self.root.title(my_name)    # window title bar text
    4209. 

  4209. 		self.window = self.root     # variable "focus" for inclusion
    4210. 

  4210. 		self.row = 0                # row count for grid()
    4211. 

  4211. 		
    4212. 

  4212. 		self.action_lenght = 150    # left column lenght (pixel)
    4213. 

  4213. 		self.frame_margin  = 10     # frame margin size  (pixel)
    4214. 

  4214. 		self.frame_border  = 6      # frame border size  (pixel)
    4215. 

  4215. 		
    4216. 

  4216. 		# the default Gui colors, can be changed by %!guicolors
    4217. 

  4217. 		self.dft_gui_colors = ['blue','white','lightblue','black']
    4218. 

  4218. 		self.gui_colors = []
    4219. 

  4219. 		self.bg1 = self.fg1 = self.bg2 = self.fg2 = ''
    4220. 

  4220. 		
    4221. 

  4221. 		# on Tk, vars need to be set/get using setvar()/get()
    4222. 

  4222. 		self.infile  = self.setvar('')
    4223. 

  4223. 		self.target  = self.setvar('')
    4224. 

  4224. 		self.target_name = self.setvar('')
    4225. 

  4225. 		
    4226. 

  4226. 		# the checks appearance order
    4227. 

  4227. 		self.checks  = [
    4228. 

  4228. 		  'headers','enum-title','toc','mask-email',
    4229. 

  4229. 		  'toc-only','stdout']
    4230. 

  4230. 		
    4231. 

  4231. 		# creating variables for all checks
    4232. 

  4232. 		for check in self.checks:
    4233. 

  4233. 			setattr(self, 'f_'+check, self.setvar(''))
    4234. 

  4234. 		
    4235. 

  4235. 		# load RC config
    4236. 

  4236. 		self.conf = {}
    4237. 

  4237. 		if conf: self.load_config(conf)
    4238. 

  4238. 	
    4239. 

  4239. 	def load_config(self, conf):
    4240. 

  4240. 		self.conf = conf
    4241. 

  4241. 		self.gui_colors = conf.get('guicolors') or self.dft_gui_colors
    4242. 

  4242. 		self.bg1, self.fg1, self.bg2, self.fg2 = self.gui_colors
    4243. 

  4243. 		self.root.config(bd=15,bg=self.bg1)
    4244. 

  4244. 	
    4245. 

  4245. 	### config as dic for python 1.5 compat (**opts don't work :( )
    4246. 

  4246. 	def entry(self, **opts): return Tkinter.Entry(self.window, opts)
    4247. 

  4247. 	def label(self, txt='', bg=None, **opts):
    4248. 

  4248. 		opts.update({'text':txt,'bg':bg or self.bg1})
    4249. 

  4249. 		return Tkinter.Label(self.window, opts)
    4250. 

  4250. 	def button(self,name,cmd,**opts):
    4251. 

  4251. 		opts.update({'text':name,'command':cmd})
    4252. 

  4252. 		return Tkinter.Button(self.window, opts)
    4253. 

  4253. 	def check(self,name,checked=0,**opts):
    4254. 

  4254. 		bg, fg = self.bg2, self.fg2
    4255. 

  4255. 		opts.update({
    4256. 

  4256. 		  'text':name, 'onvalue':1, 'offvalue':0,
    4257. 

  4257. 		  'activeforeground':fg, 'fg':fg,
    4258. 

  4258. 		  'activebackground':bg, 'bg':bg,
    4259. 

  4259. 		  'highlightbackground':bg, 'anchor':'w'
    4260. 

  4260. 		})
    4261. 

  4261. 		chk = Tkinter.Checkbutton(self.window, opts)
    4262. 

  4262. 		if checked: chk.select()
    4263. 

  4263. 		chk.grid(columnspan=2, sticky='w', padx=0)
    4264. 

  4264. 	def menu(self,sel,items):
    4265. 

  4265. 		return apply(Tkinter.OptionMenu,(self.window,sel)+tuple(items))
    4266. 

  4266. 	
    4267. 

  4267. 	# handy auxiliar functions
    4268. 

  4268. 	def action(self, txt):
    4269. 

  4269. 		self.label(txt, fg=self.fg1, bg=self.bg1,
    4270. 

  4270. 		     wraplength=self.action_lenght).grid(column=0,row=self.row)
    4271. 

  4271. 	def frame_open(self):
    4272. 

  4272. 		self.window = Tkinter.Frame(self.root,bg=self.bg2,
    4273. 

  4273. 		     borderwidth=self.frame_border)
    4274. 

  4274. 	def frame_close(self):
    4275. 

  4275. 		self.window.grid(column=1, row=self.row, sticky='w',
    4276. 

  4276. 		     padx=self.frame_margin)
    4277. 

  4277. 		self.window = self.root
    4278. 

  4278. 		self.label('').grid()
    4279. 

  4279. 		self.row = self.row + 2   # update row count
    4280. 

  4280. 	def target_name2key(self):
    4281. 

  4281. 		name = self.target_name.get()
    4282. 

  4282. 		target = filter(lambda x: TARGET_NAMES[x] == name, TARGETS)
    4283. 

  4283. 		try   : key = target[0]
    4284. 

  4284. 		except: key = ''
    4285. 

  4285. 		self.target = self.setvar(key)
    4286. 

  4286. 	def target_key2name(self):
    4287. 

  4287. 		key = self.target.get()
    4288. 

  4288. 		name = TARGET_NAMES.get(key) or key
    4289. 

  4289. 		self.target_name = self.setvar(name)
    4290. 

  4290. 	
    4291. 

  4291. 	def exit(self): self.root.destroy()
    4292. 

  4292. 	def setvar(self, val): z = Tkinter.StringVar() ; z.set(val) ; return z
    4293. 

  4293. 	
    4294. 

  4294. 	def askfile(self):
    4295. 

  4295. 		ftypes= [(_('txt2tags files'),('*.t2t','*.txt')),
    4296. 

  4296. 		         (_('All files'),'*')]
    4297. 

  4297. 		newfile = askopenfilename(filetypes=ftypes)
    4298. 

  4298. 		if newfile:
    4299. 

  4299. 			self.infile.set(newfile)
    4300. 

  4300. 			newconf = process_source_file(newfile)[0]
    4301. 

  4301. 			newconf = ConfigMaster().sanity(newconf, gui=1)
    4302. 

  4302. 			# restate all checkboxes after file selection
    4303. 

  4303. 			#TODO how to make a refresh without killing it?
    4304. 

  4304. 			self.root.destroy()
    4305. 

  4305. 			self.__init__(newconf)
    4306. 

  4306. 			self.mainwindow()
    4307. 

  4307. 	
    4308. 

  4308. 	def scrollwindow(self, txt='no text!', title=''):
    4309. 

  4309. 		# create components
    4310. 

  4310. 		win    = Tkinter.Toplevel() ; win.title(title)
    4311. 

  4311. 		frame  = Tkinter.Frame(win)
    4312. 

  4312. 		scroll = Tkinter.Scrollbar(frame)
    4313. 

  4313. 		text   = Tkinter.Text(frame,yscrollcommand=scroll.set)
    4314. 

  4314. 		button = Tkinter.Button(win)
    4315. 

  4315. 		# config
    4316. 

  4316. 		text.insert(Tkinter.END, string.join(txt,'\n'))
    4317. 

  4317. 		scroll.config(command=text.yview)
    4318. 

  4318. 		button.config(text=_('Close'), command=win.destroy)
    4319. 

  4319. 		button.focus_set()
    4320. 

  4320. 		# packing
    4321. 

  4321. 		text.pack(side='left', fill='both', expand=1)
    4322. 

  4322. 		scroll.pack(side='right', fill='y')
    4323. 

  4323. 		frame.pack(fill='both', expand=1)
    4324. 

  4324. 		button.pack(ipadx=30)
    4325. 

  4325. 	
    4326. 

  4326. 	def runprogram(self):
    4327. 

  4327. 		global CMDLINE_RAW
    4328. 

  4328. 		# prepare
    4329. 

  4329. 		self.target_name2key()
    4330. 

  4330. 		infile, target = self.infile.get(), self.target.get()
    4331. 

  4331. 		# sanity
    4332. 

  4332. 		if not target:
    4333. 

  4333. 			showwarning(my_name,_("You must select a target type!"))
    4334. 

  4334. 			return
    4335. 

  4335. 		if not infile:
    4336. 

  4336. 			showwarning(my_name,
    4337. 

  4337. 			   _("You must provide the source file location!"))
    4338. 

  4338. 			return
    4339. 

  4339. 		# compose cmdline
    4340. 

  4340. 		guiflags = []
    4341. 

  4341. 		real_cmdline_conf = ConfigMaster(CMDLINE_RAW).parse()
    4342. 

  4342. 		if real_cmdline_conf.has_key('infile'):
    4343. 

  4343. 			del real_cmdline_conf['infile']
    4344. 

  4344. 		if real_cmdline_conf.has_key('target'):
    4345. 

  4345. 			del real_cmdline_conf['target']
    4346. 

  4346. 		real_cmdline = CommandLine().compose_cmdline(real_cmdline_conf)
    4347. 

  4347. 		default_outfile = ConfigMaster().get_outfile_name(
    4348. 

  4348. 		     {'sourcefile':infile, 'outfile':'', 'target':target})
    4349. 

  4349. 		for opt in self.checks:
    4350. 

  4350. 			val = int(getattr(self, 'f_%s'%opt).get() or "0")
    4351. 

  4351. 			if opt == 'stdout': opt = 'outfile'
    4352. 

  4352. 			on_config  = self.conf.get(opt) or 0
    4353. 

  4353. 			on_cmdline = real_cmdline_conf.get(opt) or 0
    4354. 

  4354. 			if opt == 'outfile':
    4355. 

  4355. 				if on_config  == STDOUT: on_config = 1
    4356. 

  4356. 				else: on_config = 0
    4357. 

  4357. 				if on_cmdline == STDOUT: on_cmdline = 1
    4358. 

  4358. 				else: on_cmdline = 0
    4359. 

  4359. 			if val != on_config or (
    4360. 

  4360. 			  val == on_config == on_cmdline and
    4361. 

  4361. 			  real_cmdline_conf.has_key(opt)):
    4362. 

  4362. 				if val:
    4363. 

  4363. 					# was not set, but user selected on GUI
    4364. 

  4364. 					Debug("user turned  ON: %s"%opt)
    4365. 

  4365. 					if opt == 'outfile': opt = '-o-'
    4366. 

  4366. 					else: opt = '--%s'%opt
    4367. 

  4367. 				else:
    4368. 

  4368. 					# was set, but user deselected on GUI
    4369. 

  4369. 					Debug("user turned OFF: %s"%opt)
    4370. 

  4370. 					if opt == 'outfile':
    4371. 

  4371. 						opt = "-o%s"%default_outfile
    4372. 

  4372. 					else: opt = '--no-%s'%opt
    4373. 

  4373. 				guiflags.append(opt)
    4374. 

  4374. 		cmdline = [my_name, '-t', target] +real_cmdline \
    4375. 

  4375. 		          +guiflags +[infile]
    4376. 

  4376. 		Debug('Gui/Tk cmdline: %s'%cmdline,5)
    4377. 

  4377. 		# run!
    4378. 

  4378. 		cmdline_raw_orig = CMDLINE_RAW
    4379. 

  4379. 		try:
    4380. 

  4380. 			# fake the GUI cmdline as the real one, and parse file
    4381. 

  4381. 			CMDLINE_RAW = CommandLine().get_raw_config(cmdline[1:])
    4382. 

  4382. 			data = process_source_file(infile)
    4383. 

  4383. 			# on GUI, convert_* returns the data, not finish_him()
    4384. 

  4384. 			outlist, config = convert_this_files([data])
    4385. 

  4385. 			# on GUI and STDOUT, finish_him() returns the data
    4386. 

  4386. 			result = finish_him(outlist, config)
    4387. 

  4387. 			# show outlist in s a nice new window
    4388. 

  4388. 			if result:
    4389. 

  4389. 				outlist, config = result
    4390. 

  4390. 				title = _('%s: %s converted to %s')%(
    4391. 

  4391. 				  my_name, os.path.basename(infile),
    4392. 

  4392. 				  string.upper(config['target']))
    4393. 

  4393. 				self.scrollwindow(outlist, title)
    4394. 

  4394. 			# show the "file saved" message
    4395. 

  4395. 			else:
    4396. 

  4396. 				msg = "%s\n\n  %s\n%s\n\n  %s\n%s"%(
    4397. 

  4397. 				      _('Conversion done!'),
    4398. 

  4398. 				      _('FROM:'), infile,
    4399. 

  4399. 				      _('TO:'), config['outfile'])
    4400. 

  4400. 				showinfo(my_name, msg)
    4401. 

  4401. 		except error:         # common error (windowed), not quit
    4402. 

  4402. 			pass
    4403. 

  4403. 		except:               # fatal error (windowed and printed)
    4404. 

  4404. 			errormsg = getUnknownErrorMessage()
    4405. 

  4405. 			print errormsg
    4406. 

  4406. 			showerror(_('%s FATAL ERROR!')%my_name,errormsg)
    4407. 

  4407. 			self.exit()
    4408. 

  4408. 		CMDLINE_RAW = cmdline_raw_orig
    4409. 

  4409. 	
    4410. 

  4410. 	def mainwindow(self):
    4411. 

  4411. 		self.infile.set(self.conf.get('sourcefile') or '')
    4412. 

  4412. 		self.target.set(self.conf.get('target') or \
    4413. 

  4413. 		              _('-- select one --'))
    4414. 

  4414. 		outfile = self.conf.get('outfile')
    4415. 

  4415. 		if outfile == STDOUT:                  # map -o-
    4416. 

  4416. 			self.conf['stdout'] = 1
    4417. 

  4417. 		if self.conf.get('headers') == None:
    4418. 

  4418. 			self.conf['headers'] = 1       # map default
    4419. 

  4419. 		
    4420. 

  4420. 		action1 = _("Enter the source file location:")
    4421. 

  4421. 		action2 = _("Choose the target document type:")
    4422. 

  4422. 		action3 = _("Some options you may check:")
    4423. 

  4423. 		action4 = _("Some extra options:")
    4424. 

  4424. 		checks_txt = {
    4425. 

  4425. 		  'headers'   : _("Include headers on output"),
    4426. 

  4426. 		  'enum-title': _("Number titles (1, 1.1, 1.1.1, etc)"),
    4427. 

  4427. 		  'toc'       : _("Do TOC also (Table of Contents)"),
    4428. 

  4428. 		  'mask-email': _("Hide e-mails from SPAM robots"),
    4429. 

  4429. 		
    4430. 

  4430. 		  'toc-only'  : _("Just do TOC, nothing more"),
    4431. 

  4431. 		  'stdout'    : _("Dump to screen (Don't save target file)")
    4432. 

  4432. 		}
    4433. 

  4433. 		targets_menu = map(lambda x: TARGET_NAMES[x], TARGETS)
    4434. 

  4434. 		
    4435. 

  4435. 		# header
    4436. 

  4436. 		self.label("%s %s"%(string.upper(my_name), my_version),
    4437. 

  4437. 		     bg=self.bg2, fg=self.fg2).grid(columnspan=2, ipadx=10)
    4438. 

  4438. 		self.label(_("ONE source, MULTI targets")+'\n%s\n'%my_url,
    4439. 

  4439. 		     bg=self.bg1, fg=self.fg1).grid(columnspan=2)
    4440. 

  4440. 		self.row = 2
    4441. 

  4441. 		# choose input file
    4442. 

  4442. 		self.action(action1) ; self.frame_open()
    4443. 

  4443. 		e_infile = self.entry(textvariable=self.infile,width=25)
    4444. 

  4444. 		e_infile.grid(row=self.row, column=0, sticky='e')
    4445. 

  4445. 		if not self.infile.get(): e_infile.focus_set()
    4446. 

  4446. 		self.button(_("Browse"), self.askfile).grid(
    4447. 

  4447. 		    row=self.row, column=1, sticky='w', padx=10)
    4448. 

  4448. 		# show outfile name, style and encoding (if any)
    4449. 

  4449. 		txt = ''
    4450. 

  4450. 		if outfile:
    4451. 

  4451. 			txt = outfile
    4452. 

  4452. 			if outfile == STDOUT: txt = _('<screen>')
    4453. 

  4453. 			l_output = self.label(_('Output: ')+txt,
    4454. 

  4454. 			                fg=self.fg2,bg=self.bg2)
    4455. 

  4455. 			l_output.grid(columnspan=2, sticky='w')
    4456. 

  4456. 		for setting in ['style','encoding']:
    4457. 

  4457. 			if self.conf.get(setting):
    4458. 

  4458. 				name = string.capitalize(setting)
    4459. 

  4459. 				val  = self.conf[setting]
    4460. 

  4460. 				self.label('%s: %s'%(name, val),
    4461. 

  4461. 				     fg=self.fg2, bg=self.bg2).grid(
    4462. 

  4462. 				     columnspan=2, sticky='w')
    4463. 

  4463. 		# choose target
    4464. 

  4464. 		self.frame_close() ; self.action(action2)
    4465. 

  4465. 		self.frame_open()
    4466. 

  4466. 		self.target_key2name()
    4467. 

  4467. 		self.menu(self.target_name, targets_menu).grid(
    4468. 

  4468. 		     columnspan=2, sticky='w')
    4469. 

  4469. 		# options checkboxes label
    4470. 

  4470. 		self.frame_close() ; self.action(action3)
    4471. 

  4471. 		self.frame_open()
    4472. 

  4472. 		# compose options check boxes, example:
    4473. 

  4473. 		# self.check(checks_txt['toc'],1,variable=self.f_toc)
    4474. 

  4474. 		for check in self.checks:
    4475. 

  4475. 			# extra options label
    4476. 

  4476. 			if check == 'toc-only':
    4477. 

  4477. 				self.frame_close() ; self.action(action4)
    4478. 

  4478. 				self.frame_open()
    4479. 

  4479. 			txt = checks_txt[check]
    4480. 

  4480. 			var = getattr(self, 'f_'+check)
    4481. 

  4481. 			checked = self.conf.get(check)
    4482. 

  4482. 			self.check(txt,checked,variable=var)
    4483. 

  4483. 		self.frame_close()
    4484. 

  4484. 		# spacer and buttons
    4485. 

  4485. 		self.label('').grid() ; self.row = self.row + 1
    4486. 

  4486. 		b_quit = self.button(_("Quit"), self.exit)
    4487. 

  4487. 		b_quit.grid(row=self.row, column=0, sticky='w', padx=30)
    4488. 

  4488. 		b_conv = self.button(_("Convert!"), self.runprogram)
    4489. 

  4489. 		b_conv.grid(row=self.row, column=1, sticky='e', padx=30)
    4490. 

  4490. 		if self.target.get() and self.infile.get():
    4491. 

  4491. 			b_conv.focus_set()
    4492. 

  4492. 		
    4493. 

  4493. 		# as documentation told me
    4494. 

  4494. 		if sys.platform[:3] == 'win':
    4495. 

  4495. 			self.root.iconify()
    4496. 

  4496. 			self.root.update()
    4497. 

  4497. 			self.root.deiconify()
    4498. 

  4498. 		
    4499. 

  4499. 		self.root.mainloop()
    4500. 

  4500. 

  4501. 

  4502. ##############################################################################
    4503. 

  4503. ##############################################################################
    4504. 

  4504. 

  4505. def exec_command_line(user_cmdline=[]):
    4506. 

  4506. 	global CMDLINE_RAW, RC_RAW, DEBUG, VERBOSE, QUIET, GUI, Error
    4507. 

  4507. 	
    4508. 

  4508. 	# extract command line data
    4509. 

  4509. 	cmdline_data = user_cmdline or sys.argv[1:]
    4510. 

  4510. 	CMDLINE_RAW = CommandLine().get_raw_config(cmdline_data, relative=1)
    4511. 

  4511. 	cmdline_parsed = ConfigMaster(CMDLINE_RAW).parse()
    4512. 

  4512. 	DEBUG   = cmdline_parsed.get('debug'  ) or 0
    4513. 

  4513. 	VERBOSE = cmdline_parsed.get('verbose') or 0
    4514. 

  4514. 	QUIET   = cmdline_parsed.get('quiet'  ) or 0
    4515. 

  4515. 	GUI     = cmdline_parsed.get('gui'    ) or 0
    4516. 

  4516. 	infiles = cmdline_parsed.get('infile' ) or []
    4517. 

  4517. 	
    4518. 

  4518. 	Message(_("Txt2tags %s processing begins")%my_version,1)
    4519. 

  4519. 	
    4520. 

  4520. 	# the easy ones
    4521. 

  4521. 	if cmdline_parsed.get('help'   ): Quit(USAGE)
    4522. 

  4522. 	if cmdline_parsed.get('version'): Quit(VERSIONSTR)
    4523. 

  4523. 	
    4524. 

  4524. 	# multifile haters
    4525. 

  4525. 	if len(infiles) > 1:
    4526. 

  4526. 		errmsg=_("Option --%s can't be used with multiple input files")
    4527. 

  4527. 		for option in NO_MULTI_INPUT:
    4528. 

  4528. 			if cmdline_parsed.get(option):
    4529. 

  4529. 				Error(errmsg%option)
    4530. 

  4530. 	
    4531. 

  4531. 	Debug("system platform: %s"%sys.platform)
    4532. 

  4532. 	Debug("python version: %s"%(string.split(sys.version,'(')[0]))
    4533. 

  4533. 	Debug("line break char: %s"%repr(LB))
    4534. 

  4534. 	Debug("command line: %s"%sys.argv)
    4535. 

  4535. 	Debug("command line raw config: %s"%CMDLINE_RAW,1)
    4536. 

  4536. 	
    4537. 

  4537. 	# extract RC file config
    4538. 

  4538. 	if cmdline_parsed.get('rc') == 0:
    4539. 

  4539. 		Message(_("Ignoring user configuration file"),1)
    4540. 

  4540. 	else:
    4541. 

  4541. 		rc_file = get_rc_path()
    4542. 

  4542. 		if os.path.isfile(rc_file):
    4543. 

  4543. 			Message(_("Loading user configuration file"),1)
    4544. 

  4544. 			RC_RAW = ConfigLines(file=rc_file).get_raw_config()
    4545. 

  4545. 		
    4546. 

  4546. 		Debug("rc file: %s"%rc_file)
    4547. 

  4547. 		Debug("rc file raw config: %s"%RC_RAW,1)
    4548. 

  4548. 	
    4549. 

  4549. 	# get all infiles config (if any)
    4550. 

  4550. 	infiles_config = get_infiles_config(infiles)
    4551. 

  4551. 	
    4552. 

  4552. 	# is GUI available?
    4553. 

  4553. 	# try to load and start GUI interface for --gui
    4554. 

  4554. 	# if program was called with no arguments, try GUI also
    4555. 

  4555. 	if GUI or not infiles:
    4556. 

  4556. 		try:
    4557. 

  4557. 			load_GUI_resources()
    4558. 

  4558. 			Debug("GUI resources OK (Tk module is installed)")
    4559. 

  4559. 			winbox = Gui()
    4560. 

  4560. 			Debug("GUI display OK")
    4561. 

  4561. 			GUI = 1
    4562. 

  4562. 		except:
    4563. 

  4563. 			Debug("GUI Error: no Tk module or no DISPLAY")
    4564. 

  4564. 			GUI = 0
    4565. 

  4565. 	
    4566. 

  4566. 	# user forced --gui, but it's not available
    4567. 

  4567. 	if cmdline_parsed.get('gui') and not GUI:
    4568. 

  4568. 		print getTraceback(); print
    4569. 

  4569. 		Error("Sorry, I can't run my Graphical Interface - GUI\n"
    4570. 

  4570. 		      "- Check if Python Tcl/Tk module is installed (Tkinter)\n"
    4571. 

  4571. 		      "- Make sure you are in a graphical environment (like X)")
    4572. 

  4572. 	
    4573. 

  4573. 	# Okay, we will use GUI
    4574. 

  4574. 	if GUI:
    4575. 

  4575. 		Message(_("We are on GUI interface"),1)
    4576. 

  4576. 		
    4577. 

  4577. 		# redefine Error function to raise exception instead sys.exit()
    4578. 

  4578. 		def Error(msg):
    4579. 

  4579. 			showerror(_('txt2tags ERROR!'), msg)
    4580. 

  4580. 			raise error
    4581. 

  4581. 		
    4582. 

  4582. 		# if no input file, get RC+cmdline config, else full config
    4583. 

  4583. 		if not infiles:
    4584. 

  4584. 			gui_conf = ConfigMaster(RC_RAW+CMDLINE_RAW).parse()
    4585. 

  4585. 		else:
    4586. 

  4586. 			try   : gui_conf = infiles_config[0][0]
    4587. 

  4587. 			except: gui_conf = {}
    4588. 

  4588. 		
    4589. 

  4589. 		# sanity is needed to set outfile and other things
    4590. 

  4590. 		gui_conf = ConfigMaster().sanity(gui_conf, gui=1)
    4591. 

  4591. 		Debug("GUI config: %s"%gui_conf,5)
    4592. 

  4592. 		
    4593. 

  4593. 		# insert config and populate the nice window!
    4594. 

  4594. 		winbox.load_config(gui_conf)
    4595. 

  4595. 		winbox.mainwindow()
    4596. 

  4596. 	
    4597. 

  4597. 	# console mode rocks forever!
    4598. 

  4598. 	else:
    4599. 

  4599. 		Message(_("We are on Command Line interface"),1)
    4600. 

  4600. 		
    4601. 

  4601. 		# called with no arguments, show error
    4602. 

  4602. 		if not infiles: Error(_('Missing input file (try --help)'))
    4603. 

  4603. 		
    4604. 

  4604. 		convert_this_files(infiles_config)
    4605. 

  4605. 	
    4606. 

  4606. 	Message(_("Txt2tags finished sucessfuly"),1)
    4607. 

  4607. 

  4608. if __name__ == '__main__':
    4609. 

  4609. 	try:
    4610. 

  4610. 		exec_command_line()
    4611. 

  4611. 	except error, msg:
    4612. 

  4612. 		sys.stderr.write("%s\n"%msg)
    4613. 

  4613. 		sys.stderr.flush()
    4614. 

  4614. 		sys.exit(1)
    4615. 

  4615. 	except SystemExit:
    4616. 

  4616. 		pass
    4617. 

  4617. 	except:
    4618. 

  4618. 		print getUnknownErrorMessage()
    4619. 

  4619. 	Quit()
    4620. 

  4620. 

  4621. 

  4622. # vim: ts=8
    4623. 

  4623.