PageRenderTime 108ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 1ms

/markup/txt2tags.py

https://bitbucket.org/fgallaire/tornablog
Python | 5678 lines | 5118 code | 218 blank | 342 comment | 221 complexity | 48a2e3351921a057493fab5baa96a4a5 MD5 | raw file
Possible License(s): AGPL-3.0 
    

  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, 2006, 2007, 2008 Aurelio 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. #   BORING CODE EXPLANATION AHEAD
    22. 

  22. #
    23. 

  23. # Just read it if you wish to understand how the txt2tags code works.
    24. 

  24. #
    25. 

  25. ########################################################################
    26. 

  26. #
    27. 

  27. # The code that [1] parses the marked text is separated from the
    28. 

  28. # code that [2] insert the target tags.
    29. 

  29. #
    30. 

  30. #   [1] made by: def convert()
    31. 

  31. #   [2] made by: class BlockMaster
    32. 

  32. #
    33. 

  33. # The structures of the marked text are identified and its contents are
    34. 

  34. # extracted into a data holder (Python lists and dictionaries).
    35. 

  35. #
    36. 

  36. # When parsing the source file, the blocks (para, lists, quote, table)
    37. 

  37. # are opened with BlockMaster, right when found. Then its contents,
    38. 

  38. # which spans on several lines, are feeded into a special holder on the
    39. 

  39. # BlockMaster instance. Just when the block is closed, the target tags
    40. 

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

  41. # have a better control on blocks. Much better than the previous line by
    42. 

  42. # line approach.
    43. 

  43. #
    44. 

  44. # In other words, whenever inside a block, the parser *holds* the tag
    45. 

  45. # insertion process, waiting until the full block is read. That was
    46. 

  46. # needed primary to close paragraphs for the XHTML target, but
    47. 

  47. # proved to be a very good adding, improving many other processing.
    48. 

  48. #
    49. 

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

  50. #
    51. 

  51. # These important classes are all documented:
    52. 

  52. # CommandLine, SourceDocument, ConfigMaster, ConfigLines.
    53. 

  53. #
    54. 

  54. # There is a RAW Config format and all kind of configuration is first
    55. 

  55. # converted to this format. Then a generic method parses it.
    56. 

  56. #
    57. 

  57. # These functions get information about the input file(s) and take
    58. 

  58. # care of the init processing:
    59. 

  59. # get_infiles_config(), process_source_file() and convert_this_files()
    60. 

  60. #
    61. 

  61. ########################################################################
    62. 

  62. 

  63. #XXX Python coding warning
    64. 

  64. # Avoid common mistakes:
    65. 

  65. # - do NOT use newlist=list instead newlist=list[:]
    66. 

  66. # - do NOT use newdic=dic   instead newdic=dic.copy()
    67. 

  67. # - do NOT use dic[key]     instead dic.get(key)
    68. 

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

  69. 

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

  71. # Can't fix that because the image is expanded together with the
    72. 

  72. # link, at the linkbank filling moment. Only the image is passed
    73. 

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

  74. 

  75. #XXX Paragraph separation not valid inside Quote
    76. 

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

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

  78. # different background color. Still don't know how to fix it.
    79. 

    80. 

  80. #XXX TODO (maybe)
    81. 

  81. # New mark or macro which expands to an anchor full title.
    82. 

  82. # It is necessary to parse the full document in this order:
    83. 

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

  84. #  DONE  2nd scan: BODY: expand includes & apply %!preproc
    85. 

  85. #        3rd scan: BODY: read titles and compose TOC info
    86. 

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

  87. # Steps 2 and 3 can be made together, with no tag adding.
    88. 

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

  89. # One solution may be add the titles as postproc rules
    90. 

  90. 

  91. 

  92. ##############################################################################
    93. 

  93. 

  94. # User config (1=ON, 0=OFF)
    95. 

  95. 

  96. USE_I18N    = 1   # use gettext for i18ned messages?        (default is 1)
    97. 

  97. COLOR_DEBUG = 1   # show debug messages in colors?          (default is 1)
    98. 

  98. BG_LIGHT    = 0   # your terminal background color is light (default is 0)
    99. 

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

  100. 

  101. ##############################################################################
    102. 

  102. 

  103. 

  104. # These are all the core Python modules used by txt2tags (KISS!)
    105. 

  105. import re, os, sys, time, getopt
    106. 

  106. 

  107. # Program information
    108. 

  108. my_url = 'http://txt2tags.sf.net'
    109. 

  109. my_name = 'txt2tags'
    110. 

  110. my_email = 'verde@aurelio.net'
    111. 

  111. my_version = '2.6b'
    112. 

  112. 

  113. # i18n - just use if available
    114. 

  114. if USE_I18N:
    115. 

  115. 	try:
    116. 

  116. 		import gettext
    117. 

  117. 		# If your locale dir is different, change it here
    118. 

  118. 		cat = gettext.Catalog('txt2tags',localedir='/usr/share/locale/')
    119. 

  119. 		_ = cat.gettext
    120. 

  120. 	except:
    121. 

  121. 		_ = lambda x:x
    122. 

  122. else:
    123. 

  123. 	_ = lambda x:x
    124. 

  124. 

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

  126. # OPTIONS : the conversion related options, may be used in %!options
    127. 

  127. # ACTIONS : the other behavior modifiers, valid on command line only
    128. 

  128. # MACROS  : the valid macros with their default values for formatting
    129. 

  129. # SETTINGS: global miscellaneous settings, valid on RC file only
    130. 

  130. # NO_TARGET: actions that don't require a target specification
    131. 

  131. # NO_MULTI_INPUT: actions that don't accept more than one input file
    132. 

  132. # CONFIG_KEYWORDS: the valid %!key:val keywords
    133. 

  133. #
    134. 

  134. # FLAGS and OPTIONS are configs that affect the converted document.
    135. 

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

  136. #
    137. 

  137. # ACTIONS are needed because when doing multiple input files, strange
    138. 

  138. # behavior would be found, as use command line interface for the
    139. 

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

  140. # --version and --help inside %!options are also odd
    141. 

  141. #
    142. 

  142. TARGETS  = 'html xhtml sgml dbk tex lout man mgp wiki gwiki doku pmw moin pm6 txt art adoc'.split()
    143. 

  143. 

  144. FLAGS    = {'headers'    :1 , 'enum-title' :0 , 'mask-email' :0 ,
    145. 

  145.             'toc-only'   :0 , 'toc'        :0 , 'rc'         :1 ,
    146. 

  146.             'css-sugar'  :0 , 'css-suggar' :0 , 'css-inside' :0 ,
    147. 

  147.             'quiet'      :0 }
    148. 

  148. OPTIONS  = {'target'     :'', 'toc-level'  :3 , 'style'      :'',
    149. 

  149.             'infile'     :'', 'outfile'    :'', 'encoding'   :'',
    150. 

  150.             'config-file':'', 'split'      :0 , 'lang'       :'',
    151. 

  151.             'show-config-value':'', 'ascii-art' :''} 
    152. 

  152. ACTIONS  = {'help'       :0 , 'version'    :0 , 'gui'        :0 ,
    153. 

  153.             'verbose'    :0 , 'debug'      :0 , 'dump-config':0 ,
    154. 

  154.             'dump-source':0 }
    155. 

  155. MACROS   = {'date' : '%Y%m%d',  'infile': '%f',
    156. 

  156.             'mtime': '%Y%m%d', 'outfile': '%f'}
    157. 

  157. SETTINGS = {}         # for future use
    158. 

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

  159. NO_MULTI_INPUT = ['gui','dump-config','dump-source']
    160. 

  160. CONFIG_KEYWORDS = [
    161. 

  161.             'target', 'encoding', 'style', 'options', 'preproc','postproc',
    162. 

  162.             'guicolors']
    163. 

  163. 

  164. TARGET_NAMES = {
    165. 

  165.   'html' : _('HTML page'),
    166. 

  166.   'xhtml': _('XHTML page'),
    167. 

  167.   'sgml' : _('SGML document'),
    168. 

  168.   'dbk'  : _('DocBook document'),
    169. 

  169.   'tex'  : _('LaTeX document'),
    170. 

  170.   'lout' : _('Lout document'),
    171. 

  171.   'man'  : _('UNIX Manual page'),
    172. 

  172.   'mgp'  : _('MagicPoint presentation'),
    173. 

  173.   'wiki' : _('Wikipedia page'),
    174. 

  174.   'gwiki': _('Google Wiki page'),
    175. 

  175.   'doku' : _('DokuWiki page'),
    176. 

  176.   'pmw'  : _('pmWiki page'),
    177. 

  177.   'moin' : _('MoinMoin page'),
    178. 

  178.   'pm6'  : _('PageMaker document'),
    179. 

  179.   'txt'  : _('Plain Text'),
    180. 

  180.   'art'  : _('Ascii Art'),
    181. 

  181.   'adoc' : _('AsciiDoc'),
    182. 

  182. }
    183. 

  183. 

  184. DEBUG = 0     # do not edit here, please use --debug
    185. 

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

  186. QUIET = 0     # do not edit here, please use --quiet
    187. 

  187. GUI = 0       # do not edit here, please use --gui
    188. 

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

  189. 

  190. AA_LCHARS = ['coin','line','border','bar1','bar2','level2','level3','level4','level5']
    191. 

  191. AA_CHARS = dict(zip(AA_LCHARS,'+-|-==-^"')) # do not edit here, please use --ascii-art or -a
    192. 

  192. 

  193. RC_RAW = []
    194. 

  194. CMDLINE_RAW = []
    195. 

  195. CONF = {}
    196. 

  196. BLOCK = None
    197. 

  197. regex = {}
    198. 

  198. TAGS = {}
    199. 

  199. rules = {}
    200. 

  200. 

  201. lang = 'english'
    202. 

  202. TARGET = ''
    203. 

  203. 

  204. STDIN = STDOUT = '-'
    205. 

  205. MODULEIN = MODULEOUT = '-module-'
    206. 

  206. ESCCHAR   = '\x00'
    207. 

  207. SEPARATOR = '\x01'
    208. 

  208. LISTNAMES = {'-':'list', '+':'numlist', ':':'deflist'}
    209. 

  209. LINEBREAK = {'default':'\n', 'win':'\r\n', 'mac':'\r'}
    210. 

  210. 

  211. # Platform specific settings
    212. 

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

  213. 

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

  215. 

  216. USAGE =  '\n'.join([
    217. 

  217. '',
    218. 

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

  219. '',
    220. 

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

  221. '                      %s,' % ', '.join(TARGETS[:8]),
    222. 

  222. '                      %s'  % ', '.join(TARGETS[8:]),
    223. 

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

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

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

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

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

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

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

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

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

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

  233. _("      --toc-only      print document TOC and exit"),
    234. 

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

  235. _("  -n, --enum-title    enumerate all titles as 1, 1.1, 1.1.1, etc"),
    236. 

  236. _("  -a, --ascii-art=S   set the ascii art chars with the string S. in the order:"),
    237. 

  237. '                      %s' % ', '.join(AA_LCHARS),
    238. 

  238. _("  -C, --config-file=F read config from file F"),
    239. 

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

  240. _("      --gui           invoke Graphical Tk Interface"),
    241. 

  241. _("  -q, --quiet         quiet mode, suppress all output (except errors)"),
    242. 

  242. _("  -v, --verbose       print informative messages during conversion"),
    243. 

  243. _("  -h, --help          print this help information and exit"),
    244. 

  244. _("  -V, --version       print program version and exit"),
    245. 

  245. _("      --dump-config   print all the config found and exit"),
    246. 

  246. _("      --dump-source   print the document source, with includes expanded"),
    247. 

  247. '',
    248. 

  248. _("Turn OFF options:"),
    249. 

  249. "     --no-outfile, --no-infile, --no-style, --no-encoding, --no-headers",
    250. 

  250. "     --no-toc, --no-toc-only, --no-mask-email, --no-enum-title, --no-rc",
    251. 

  251. "     --no-css-sugar, --no-css-inside, --no-quiet, --no-dump-config",
    252. 

  252. "     --no-dump-source",
    253. 

  253. '',
    254. 

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

  255. '',
    256. 

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

  257. _("Use --outfile to force an output file name."),
    258. 

  258. _("If  input file is '-', reads from STDIN."),
    259. 

  259. _("If output file is '-', dumps output to STDOUT."),
    260. 

  260. '',
    261. 

  261. 'http://txt2tags.sourceforge.net',
    262. 

  262. ''
    263. 

  263. ])
    264. 

  264. 

  265. 

  266. ##############################################################################
    267. 

  267. 

  268. 

  269. # Here is all the target's templates
    270. 

  270. # You may edit them to fit your needs
    271. 

  271. #  - the %(HEADERn)s strings represent the Header lines
    272. 

  272. #  - the %(STYLE)s string is changed by --style contents
    273. 

  273. #  - the %(ENCODING)s string is changed by --encoding contents
    274. 

  274. #  - if any of the above is empty, the full line is removed
    275. 

  275. #  - use %% to represent a literal %
    276. 

  276. #
    277. 

  277. HEADER_TEMPLATE = {
    278. 

  278. 	'art':"""
    279. 

  279. Fake template to respect the general process.
    280. 

  280. """,
    281. 

  281. 	'txt': """\
    282. 

  282. %(HEADER1)s
    283. 

  283. %(HEADER2)s
    284. 

  284. %(HEADER3)s
    285. 

  285. """,
    286. 

    287. 

  287. 	'sgml': """\
    288. 

  288. <!doctype linuxdoc system>
    289. 

  289. <article>
    290. 

  290. <title>%(HEADER1)s
    291. 

  291. <author>%(HEADER2)s
    292. 

  292. <date>%(HEADER3)s
    293. 

  293. """,
    294. 

    295. 

  295. 	'html': """\
    296. 

  296. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    297. 

  297. <HTML>
    298. 

  298. <HEAD>
    299. 

  299. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    300. 

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

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

  302. <TITLE>%(HEADER1)s</TITLE>
    303. 

  303. </HEAD><BODY BGCOLOR="white" TEXT="black">
    304. 

  304. <CENTER>
    305. 

  305. <H1>%(HEADER1)s</H1>
    306. 

  306. <FONT SIZE="4"><I>%(HEADER2)s</I></FONT><BR>
    307. 

  307. <FONT SIZE="4">%(HEADER3)s</FONT>
    308. 

  308. </CENTER>
    309. 

  309. """,
    310. 

    311. 

  311. 	'htmlcss': """\
    312. 

  312. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    313. 

  313. <HTML>
    314. 

  314. <HEAD>
    315. 

  315. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    316. 

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

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

  318. <TITLE>%(HEADER1)s</TITLE>
    319. 

  319. </HEAD>
    320. 

  320. <BODY>
    321. 

  321. 

  322. <DIV CLASS="header" ID="header">
    323. 

  323. <H1>%(HEADER1)s</H1>
    324. 

  324. <H2>%(HEADER2)s</H2>
    325. 

  325. <H3>%(HEADER3)s</H3>
    326. 

  326. </DIV>
    327. 

  327. """,
    328. 

    329. 

  329. 	'xhtml': """\
    330. 

  330. <?xml version="1.0"
    331. 

  331.       encoding="%(ENCODING)s"
    332. 

  332. ?>
    333. 

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

  334.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    335. 

  335. <html xmlns="http://www.w3.org/1999/xhtml">
    336. 

  336. <head>
    337. 

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

  338. <meta name="generator" content="http://txt2tags.sf.net" />
    339. 

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

  340. </head>
    341. 

  341. <body bgcolor="white" text="black">
    342. 

  342. <div align="center">
    343. 

  343. <h1>%(HEADER1)s</h1>
    344. 

  344. <h2>%(HEADER2)s</h2>
    345. 

  345. <h3>%(HEADER3)s</h3>
    346. 

  346. </div>
    347. 

  347. """,
    348. 

    349. 

  349. 	'xhtmlcss': """\
    350. 

  350. <?xml version="1.0"
    351. 

  351.       encoding="%(ENCODING)s"
    352. 

  352. ?>
    353. 

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

  354.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    355. 

  355. <html xmlns="http://www.w3.org/1999/xhtml">
    356. 

  356. <head>
    357. 

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

  358. <meta name="generator" content="http://txt2tags.sf.net" />
    359. 

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

  360. </head>
    361. 

  361. <body>
    362. 

  362. 

  363. <div class="header" id="header">
    364. 

  364. <h1>%(HEADER1)s</h1>
    365. 

  365. <h2>%(HEADER2)s</h2>
    366. 

  366. <h3>%(HEADER3)s</h3>
    367. 

  367. </div>
    368. 

  368. """,
    369. 

    370. 

  370. 	'dbk': """\
    371. 

  371. <?xml version="1.0"
    372. 

  372.       encoding="%(ENCODING)s"
    373. 

  373. ?>
    374. 

  374. <!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"\
    375. 

  375.  "docbook/dtd/xml/4.5/docbookx.dtd">
    376. 

  376. <article lang="en">
    377. 

  377.   <articleinfo>
    378. 

  378.     <title>%(HEADER1)s</title>
    379. 

  379.     <authorgroup>
    380. 

  380.       <author><othername>%(HEADER2)s</othername></author>
    381. 

  381.     </authorgroup>
    382. 

  382.     <date>%(HEADER3)s</date>
    383. 

  383.   </articleinfo>
    384. 

  384. """,
    385. 

    386. 

  386. 	'man': """\
    387. 

  387. .TH "%(HEADER1)s" 1 "%(HEADER3)s" "%(HEADER2)s"
    388. 

  388. """,
    389. 

    390. 

  390. # TODO style to <HR>
    391. 

  391. 	'pm6': """\
    392. 

  392. <PMTags1.0 win><C-COLORTABLE ("Preto" 1 0 0 0)
    393. 

  393. ><@Normal=
    394. 

  394.   <FONT "Times New Roman"><CCOLOR "Preto"><SIZE 11>
    395. 

  395.   <HORIZONTAL 100><LETTERSPACE 0><CTRACK 127><CSSIZE 70><C+SIZE 58.3>
    396. 

  396.   <C-POSITION 33.3><C+POSITION 33.3><P><CBASELINE 0><CNOBREAK 0><CLEADING -0.05>
    397. 

  397.   <GGRID 0><GLEFT 7.2><GRIGHT 0><GFIRST 0><G+BEFORE 7.2><G+AFTER 0>
    398. 

  398.   <GALIGNMENT "justify"><GMETHOD "proportional"><G& "ENGLISH">
    399. 

  399.   <GPAIRS 12><G%% 120><GKNEXT 0><GKWIDOW 0><GKORPHAN 0><GTABS $>
    400. 

  400.   <GHYPHENATION 2 34 0><GWORDSPACE 75 100 150><GSPACE -5 0 25>
    401. 

  401. ><@Bullet=<@-PARENT "Normal"><FONT "Abadi MT Condensed Light">
    402. 

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

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

  404.   <GLEFT 0><G+BEFORE 0><GALIGNMENT "left"><GWORDSPACE 100 100 100><GSPACE 0 0 0>
    405. 

  405. ><@Title1=<@-PARENT "Normal"><FONT "Arial"><SIZE 14><B>
    406. 

  406.   <GCONTENTS><GLEFT 0><G+BEFORE 0><GALIGNMENT "left">
    407. 

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

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

  409. ><@Title4=<@-PARENT "Title3">
    410. 

  410. ><@Title5=<@-PARENT "Title3">
    411. 

  411. ><@Quote=<@-PARENT "Normal"><SIZE 10><I>>
    412. 

  412. 

  413. %(HEADER1)s
    414. 

  414. %(HEADER2)s
    415. 

  415. %(HEADER3)s
    416. 

  416. """,
    417. 

    418. 

  418. 	'mgp': """\
    419. 

  419. #!/usr/X11R6/bin/mgp -t 90
    420. 

  420. %%deffont "normal"    xfont  "utopia-medium-r", charset "iso8859-1"
    421. 

  421. %%deffont "normal-i"  xfont  "utopia-medium-i", charset "iso8859-1"
    422. 

  422. %%deffont "normal-b"  xfont  "utopia-bold-r"  , charset "iso8859-1"
    423. 

  423. %%deffont "normal-bi" xfont  "utopia-bold-i"  , charset "iso8859-1"
    424. 

  424. %%deffont "mono"      xfont "courier-medium-r", charset "iso8859-1"
    425. 

  425. %%default 1 size 5
    426. 

  426. %%default 2 size 8, fore "yellow", font "normal-b", center
    427. 

  427. %%default 3 size 5, fore "white",  font "normal", left, prefix "  "
    428. 

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

  429. %%tab 2 prefix "            ", icon arc "orange" 40, leftfill
    430. 

  430. %%tab 3 prefix "                   ", icon arc "brown" 40, leftfill
    431. 

  431. %%tab 4 prefix "                          ", icon arc "darkmagenta" 40, leftfill
    432. 

  432. %%tab 5 prefix "                                ", icon arc "magenta" 40, leftfill
    433. 

  433. %%%%------------------------- end of headers -----------------------------
    434. 

  434. %%page
    435. 

  435. 

  436. 

  437. 

  438. 

  439. 

  440. %%size 10, center, fore "yellow"
    441. 

  441. %(HEADER1)s
    442. 

  442. 

  443. %%font "normal-i", size 6, fore "white", center
    444. 

  444. %(HEADER2)s
    445. 

  445. 

  446. %%font "mono", size 7, center
    447. 

  447. %(HEADER3)s
    448. 

  448. """,
    449. 

    450. 

  450. 	'moin': """\
    451. 

  451. '''%(HEADER1)s'''
    452. 

  452. 

  453. ''%(HEADER2)s''
    454. 

  454. 

  455. %(HEADER3)s
    456. 

  456. """,
    457. 

    458. 

  458. 	'gwiki': """\
    459. 

  459. *%(HEADER1)s*
    460. 

  460. 

  461. %(HEADER2)s
    462. 

  462. 

  463. _%(HEADER3)s_
    464. 

  464. """,
    465. 

    466. 

  466. 	'adoc': """\
    467. 

  467. %(HEADER1)s
    468. 

  468. %(HEADER2)s
    469. 

  469. %(HEADER3)s
    470. 

  470. """,
    471. 

    472. 

  472. 	'doku': """\
    473. 

  473. ===== %(HEADER1)s =====
    474. 

  474. 

  475. **//%(HEADER2)s//**
    476. 

  476. 

  477. //%(HEADER3)s//
    478. 

  478. """,
    479. 

    480. 

  480. 	'pmw': """\
    481. 

  481. (:Title %(HEADER1)s:)
    482. 

  482. 

  483. (:Description %(HEADER2)s:)
    484. 

  484. 

  485. (:Summary %(HEADER3)s:)
    486. 

  486. """,
    487. 

    488. 

  488. 	'wiki': """\
    489. 

  489. '''%(HEADER1)s'''
    490. 

  490. 

  491. %(HEADER2)s
    492. 

  492. 

  493. ''%(HEADER3)s''
    494. 

  494. """,
    495. 

    496. 

  496. 	'tex': \
    497. 

  497. r"""\documentclass{article}
    498. 

  498. \usepackage{graphicx}
    499. 

  499. \usepackage{paralist} %% needed for compact lists
    500. 

  500. \usepackage[normalem]{ulem} %% needed by strike
    501. 

  501. \usepackage[urlcolor=blue,colorlinks=true]{hyperref}
    502. 

  502. \usepackage[%(ENCODING)s]{inputenc}  %% char encoding
    503. 

  503. \usepackage{%(STYLE)s}  %% user defined
    504. 

  504. 

  505. \title{%(HEADER1)s}
    506. 

  506. \author{%(HEADER2)s}
    507. 

  507. \begin{document}
    508. 

  508. \date{%(HEADER3)s}
    509. 

  509. \maketitle
    510. 

  510. \clearpage
    511. 

  511. """,
    512. 

    513. 

  513. 	'lout': """\
    514. 

  514. @SysInclude { doc }
    515. 

  515. @Document
    516. 

  516.   @InitialFont { Times Base 12p }  # Times, Courier, Helvetica, ...
    517. 

  517.   @PageOrientation { Portrait }    # Portrait, Landscape
    518. 

  518.   @ColumnNumber { 1 }              # Number of columns (2, 3, ...)
    519. 

  519.   @PageHeaders { Simple }          # None, Simple, Titles, NoTitles
    520. 

  520.   @InitialLanguage { English }     # German, French, Portuguese, ...
    521. 

  521.   @OptimizePages { Yes }           # Yes/No smart page break feature
    522. 

  522. //
    523. 

  523. @Text @Begin
    524. 

  524. @Display @Heading { %(HEADER1)s }
    525. 

  525. @Display @I { %(HEADER2)s }
    526. 

  526. @Display { %(HEADER3)s }
    527. 

  527. #@NP                               # Break page after Headers
    528. 

  528. """
    529. 

  529. # @SysInclude { tbl }                   # Tables support
    530. 

  530. # setup: @MakeContents { Yes }          # show TOC
    531. 

  531. # setup: @SectionGap                    # break page at each section
    532. 

  532. }
    533. 

  533. 

  534. 

  535. ##############################################################################
    536. 

  536. 

  537. 

  538. def getTags(config):
    539. 

  539. 	"Returns all the known tags for the specified target"
    540. 

  540. 	
    541. 

  541. 	keys = """
    542. 

  542. 	title1              numtitle1
    543. 

  543. 	title2              numtitle2
    544. 

  544. 	title3              numtitle3
    545. 

  545. 	title4              numtitle4
    546. 

  546. 	title5              numtitle5
    547. 

  547. 	title1Open          title1Close
    548. 

  548. 	title2Open          title2Close
    549. 

  549. 	title3Open          title3Close
    550. 

  550. 	title4Open          title4Close
    551. 

  551. 	title5Open          title5Close
    552. 

  552. 	blocktitle1Open     blocktitle1Close
    553. 

  553. 	blocktitle2Open     blocktitle2Close
    554. 

  554. 	blocktitle3Open     blocktitle3Close
    555. 

  555. 

  556. 	paragraphOpen       paragraphClose
    557. 

  557. 	blockVerbOpen       blockVerbClose
    558. 

  558. 	blockQuoteOpen      blockQuoteClose blockQuoteLine
    559. 

  559. 	blockCommentOpen    blockCommentClose
    560. 

  560. 

  561. 	fontMonoOpen        fontMonoClose
    562. 

  562. 	fontBoldOpen        fontBoldClose
    563. 

  563. 	fontItalicOpen      fontItalicClose
    564. 

  564. 	fontUnderlineOpen   fontUnderlineClose
    565. 

  565. 	fontStrikeOpen      fontStrikeClose
    566. 

  566. 

  567. 	listOpen            listClose
    568. 

  568. 	listOpenCompact     listCloseCompact
    569. 

  569. 	listItemOpen        listItemClose     listItemLine
    570. 

  570. 	numlistOpen         numlistClose
    571. 

  571. 	numlistOpenCompact  numlistCloseCompact
    572. 

  572. 	numlistItemOpen     numlistItemClose  numlistItemLine
    573. 

  573. 	deflistOpen         deflistClose
    574. 

  574. 	deflistOpenCompact  deflistCloseCompact
    575. 

  575. 	deflistItem1Open    deflistItem1Close
    576. 

  576. 	deflistItem2Open    deflistItem2Close deflistItem2LinePrefix
    577. 

  577. 

  578. 	bar1                bar2
    579. 

  579. 	url                 urlMark
    580. 

  580. 	email               emailMark
    581. 

  581. 	img                 imgAlignLeft  imgAlignRight  imgAlignCenter
    582. 

  582. 	                   _imgAlignLeft _imgAlignRight _imgAlignCenter
    583. 

  583. 

  584. 	tableOpen           tableClose
    585. 

  585. 	_tableBorder        _tableAlignLeft      _tableAlignCenter
    586. 

  586. 	tableRowOpen        tableRowClose        tableRowSep
    587. 

  587. 	tableTitleRowOpen   tableTitleRowClose
    588. 

  588. 	tableCellOpen       tableCellClose       tableCellSep
    589. 

  589. 	tableTitleCellOpen  tableTitleCellClose  tableTitleCellSep
    590. 

  590. 	_tableColAlignLeft  _tableColAlignRight  _tableColAlignCenter
    591. 

  591. 	_tableCellAlignLeft _tableCellAlignRight _tableCellAlignCenter
    592. 

  592. 	_tableCellColSpan   tableColAlignSep
    593. 

  593. 	_tableCellMulticolOpen
    594. 

  594. 	_tableCellMulticolClose
    595. 

  595. 

  596. 	bodyOpen            bodyClose
    597. 

  597. 	cssOpen             cssClose
    598. 

  598. 	tocOpen             tocClose             TOC
    599. 

  599. 	anchor
    600. 

  600. 	comment
    601. 

  601. 	pageBreak
    602. 

  602. 	EOD
    603. 

  603. 	""".split()
    604. 

  604. 	
    605. 

  605. 	# TIP: \a represents the current text on the mark
    606. 

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

  607. 	
    608. 

  608. 	alltags = {
    609. 

  609. 	
    610. 

  610. 	'art': {
    611. 

  611. 		'title1'               : '\a'                     ,
    612. 

  612. 		'title2'               : '\a'                     ,
    613. 

  613. 		'title3'               : '\a'                     ,
    614. 

  614. 		'title4'               : '\a'                     ,
    615. 

  615. 		'title5'               : '\a'                     ,
    616. 

  616. 		'blockQuoteLine'       : '\t'                     ,
    617. 

  617. 		'listItemOpen'         : '- '                     ,
    618. 

  618. 		'numlistItemOpen'      : '\a. '                   ,
    619. 

  619. 		'bar1'                 : aa_line(AA_CHARS['bar1']),
    620. 

  620. 		'bar2'                 : aa_line(AA_CHARS['bar2']),
    621. 

  621. 		'url'                  : '\a'                     ,
    622. 

  622. 		'urlMark'              : '\a (\a)'                ,
    623. 

  623. 		'email'                : '\a'                     ,
    624. 

  624. 		'emailMark'            : '\a (\a)'                ,
    625. 

  625. 		'img'                  : '[\a]'                   ,
    626. 

  626. 	},
    627. 

  627. 	
    628. 

  628. 	'txt': {
    629. 

  629. 		'title1'               : '  \a'      ,
    630. 

  630. 		'title2'               : '\t\a'      ,
    631. 

  631. 		'title3'               : '\t\t\a'    ,
    632. 

  632. 		'title4'               : '\t\t\t\a'  ,
    633. 

  633. 		'title5'               : '\t\t\t\t\a',
    634. 

  634. 		'blockQuoteLine'       : '\t'        ,
    635. 

  635. 		'listItemOpen'         : '- '        ,
    636. 

  636. 		'numlistItemOpen'      : '\a. '      ,
    637. 

  637. 		'bar1'                 : '\a'        ,
    638. 

  638. 		'url'                  : '\a'        ,
    639. 

  639. 		'urlMark'              : '\a (\a)'   ,
    640. 

  640. 		'email'                : '\a'        ,
    641. 

  641. 		'emailMark'            : '\a (\a)'   ,
    642. 

  642. 		'img'                  : '[\a]'      ,
    643. 

  643. 	},
    644. 

  644. 	
    645. 

  645. 	'html': {
    646. 

  646. 		'paragraphOpen'        : '<P>'            ,
    647. 

  647. 		'paragraphClose'       : '</P>'           ,
    648. 

  648. 		'title1'               : '~A~<H1>\a</H1>' ,
    649. 

  649. 		'title2'               : '~A~<H2>\a</H2>' ,
    650. 

  650. 		'title3'               : '~A~<H3>\a</H3>' ,
    651. 

  651. 		'title4'               : '~A~<H4>\a</H4>' ,
    652. 

  652. 		'title5'               : '~A~<H5>\a</H5>' ,
    653. 

  653. 		'anchor'               : '<A NAME="\a"></A>\n',
    654. 

  654. 		'blockVerbOpen'        : '<PRE>'          ,
    655. 

  655. 		'blockVerbClose'       : '</PRE>'         ,
    656. 

  656. 		'blockQuoteOpen'       : '<BLOCKQUOTE>'   ,
    657. 

  657. 		'blockQuoteClose'      : '</BLOCKQUOTE>'  ,
    658. 

  658. 		'fontMonoOpen'         : '<CODE>'         ,
    659. 

  659. 		'fontMonoClose'        : '</CODE>'        ,
    660. 

  660. 		'fontBoldOpen'         : '<B>'            ,
    661. 

  661. 		'fontBoldClose'        : '</B>'           ,
    662. 

  662. 		'fontItalicOpen'       : '<I>'            ,
    663. 

  663. 		'fontItalicClose'      : '</I>'           ,
    664. 

  664. 		'fontUnderlineOpen'    : '<U>'            ,
    665. 

  665. 		'fontUnderlineClose'   : '</U>'           ,
    666. 

  666. 		'fontStrikeOpen'       : '<S>'            ,
    667. 

  667. 		'fontStrikeClose'      : '</S>'           ,
    668. 

  668. 		'listOpen'             : '<UL>'           ,
    669. 

  669. 		'listClose'            : '</UL>'          ,
    670. 

  670. 		'listItemOpen'         : '<LI>'           ,
    671. 

  671. 		'numlistOpen'          : '<OL>'           ,
    672. 

  672. 		'numlistClose'         : '</OL>'          ,
    673. 

  673. 		'numlistItemOpen'      : '<LI>'           ,
    674. 

  674. 		'deflistOpen'          : '<DL>'           ,
    675. 

  675. 		'deflistClose'         : '</DL>'          ,
    676. 

  676. 		'deflistItem1Open'     : '<DT>'           ,
    677. 

  677. 		'deflistItem1Close'    : '</DT>'          ,
    678. 

  678. 		'deflistItem2Open'     : '<DD>'           ,
    679. 

  679. 		'bar1'                 : '<HR NOSHADE SIZE=1>'        ,
    680. 

  680. 		'bar2'                 : '<HR NOSHADE SIZE=5>'        ,
    681. 

  681. 		'url'                  : '<A HREF="\a">\a</A>'        ,
    682. 

  682. 		'urlMark'              : '<A HREF="\a">\a</A>'        ,
    683. 

  683. 		'email'                : '<A HREF="mailto:\a">\a</A>' ,
    684. 

  684. 		'emailMark'            : '<A HREF="mailto:\a">\a</A>' ,
    685. 

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

  686. 		'_imgAlignLeft'        : ' ALIGN="left"'  ,
    687. 

  687. 		'_imgAlignCenter'      : ' ALIGN="middle"',
    688. 

  688. 		'_imgAlignRight'       : ' ALIGN="right"' ,
    689. 

  689. 		'tableOpen'            : '<TABLE~A~~B~ CELLPADDING="4">',
    690. 

  690. 		'tableClose'           : '</TABLE>'       ,
    691. 

  691. 		'tableRowOpen'         : '<TR>'           ,
    692. 

  692. 		'tableRowClose'        : '</TR>'          ,
    693. 

  693. 		'tableCellOpen'        : '<TD~A~~S~>'     ,
    694. 

  694. 		'tableCellClose'       : '</TD>'          ,
    695. 

  695. 		'tableTitleCellOpen'   : '<TH~S~>'        ,
    696. 

  696. 		'tableTitleCellClose'  : '</TH>'          ,
    697. 

  697. 		'_tableBorder'         : ' BORDER="1"'    ,
    698. 

  698. 		'_tableAlignCenter'    : ' ALIGN="center"',
    699. 

  699. 		'_tableCellAlignRight' : ' ALIGN="right"' ,
    700. 

  700. 		'_tableCellAlignCenter': ' ALIGN="center"',
    701. 

  701. 		'_tableCellColSpan'    : ' COLSPAN="\a"'  ,
    702. 

  702. 		'cssOpen'              : '<STYLE TYPE="text/css">',
    703. 

  703. 		'cssClose'             : '</STYLE>'       ,
    704. 

  704. 		'comment'              : '<!-- \a -->'    ,
    705. 

  705. 		'EOD'                  : '</BODY></HTML>'
    706. 

  706. 	},
    707. 

  707. 	
    708. 

  708. 	#TIP xhtml inherits all HTML definitions (lowercased)
    709. 

  709. 	#TIP http://www.w3.org/TR/xhtml1/#guidelines
    710. 

  710. 	#TIP http://www.htmlref.com/samples/Chapt17/17_08.htm
    711. 

  711. 	'xhtml': {
    712. 

  712. 		'listItemClose'        : '</li>'          ,
    713. 

  713. 		'numlistItemClose'     : '</li>'          ,
    714. 

  714. 		'deflistItem2Close'    : '</dd>'          ,
    715. 

  715. 		'bar1'                 : '<hr class="light" />',
    716. 

  716. 		'bar2'                 : '<hr class="heavy" />',
    717. 

  717. 		'anchor'               : '<a id="\a" name="\a"></a>\n',
    718. 

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

  719. 	},
    720. 

  720. 	
    721. 

  721. 	'sgml': {
    722. 

  722. 		'paragraphOpen'        : '<p>'                ,
    723. 

  723. 		'title1'               : '<sect>\a~A~<p>'     ,
    724. 

  724. 		'title2'               : '<sect1>\a~A~<p>'    ,
    725. 

  725. 		'title3'               : '<sect2>\a~A~<p>'    ,
    726. 

  726. 		'title4'               : '<sect3>\a~A~<p>'    ,
    727. 

  727. 		'title5'               : '<sect4>\a~A~<p>'    ,
    728. 

  728. 		'anchor'               : '<label id="\a">'    ,
    729. 

  729. 		'blockVerbOpen'        : '<tscreen><verb>'    ,
    730. 

  730. 		'blockVerbClose'       : '</verb></tscreen>'  ,
    731. 

  731. 		'blockQuoteOpen'       : '<quote>'            ,
    732. 

  732. 		'blockQuoteClose'      : '</quote>'           ,
    733. 

  733. 		'fontMonoOpen'         : '<tt>'               ,
    734. 

  734. 		'fontMonoClose'        : '</tt>'              ,
    735. 

  735. 		'fontBoldOpen'         : '<bf>'               ,
    736. 

  736. 		'fontBoldClose'        : '</bf>'              ,
    737. 

  737. 		'fontItalicOpen'       : '<em>'               ,
    738. 

  738. 		'fontItalicClose'      : '</em>'              ,
    739. 

  739. 		'fontUnderlineOpen'    : '<bf><em>'           ,
    740. 

  740. 		'fontUnderlineClose'   : '</em></bf>'         ,
    741. 

  741. 		'listOpen'             : '<itemize>'          ,
    742. 

  742. 		'listClose'            : '</itemize>'         ,
    743. 

  743. 		'listItemOpen'         : '<item>'             ,
    744. 

  744. 		'numlistOpen'          : '<enum>'             ,
    745. 

  745. 		'numlistClose'         : '</enum>'            ,
    746. 

  746. 		'numlistItemOpen'      : '<item>'             ,
    747. 

  747. 		'deflistOpen'          : '<descrip>'          ,
    748. 

  748. 		'deflistClose'         : '</descrip>'         ,
    749. 

  749. 		'deflistItem1Open'     : '<tag>'              ,
    750. 

  750. 		'deflistItem1Close'    : '</tag>'             ,
    751. 

  751. 		'bar1'                 : '<!-- \a -->'        ,
    752. 

  752. 		'url'                  : '<htmlurl url="\a" name="\a">'        ,
    753. 

  753. 		'urlMark'              : '<htmlurl url="\a" name="\a">'        ,
    754. 

  754. 		'email'                : '<htmlurl url="mailto:\a" name="\a">' ,
    755. 

  755. 		'emailMark'            : '<htmlurl url="mailto:\a" name="\a">' ,
    756. 

  756. 		'img'                  : '<figure><ph vspace=""><img src="\a"></figure>',
    757. 

  757. 		'tableOpen'            : '<table><tabular ca="~C~">'           ,
    758. 

  758. 		'tableClose'           : '</tabular></table>' ,
    759. 

  759. 		'tableRowSep'          : '<rowsep>'           ,
    760. 

  760. 		'tableCellSep'         : '<colsep>'           ,
    761. 

  761. 		'_tableColAlignLeft'   : 'l'                  ,
    762. 

  762. 		'_tableColAlignRight'  : 'r'                  ,
    763. 

  763. 		'_tableColAlignCenter' : 'c'                  ,
    764. 

  764. 		'comment'              : '<!-- \a -->'        ,
    765. 

  765. 		'TOC'                  : '<toc>'              ,
    766. 

  766. 		'EOD'                  : '</article>'
    767. 

  767. 	},
    768. 

  768. 	
    769. 

  769. 	'dbk': {
    770. 

  770. 		'paragraphOpen'        : '<para>'                            ,
    771. 

  771. 		'paragraphClose'       : '</para>'                           ,
    772. 

  772. 		'title1Open'           : '~A~<sect1><title>\a</title>'       ,
    773. 

  773. 		'title1Close'          : '</sect1>'                          ,
    774. 

  774. 		'title2Open'           : '~A~  <sect2><title>\a</title>'     ,
    775. 

  775. 		'title2Close'          : '  </sect2>'                        ,
    776. 

  776. 		'title3Open'           : '~A~    <sect3><title>\a</title>'   ,
    777. 

  777. 		'title3Close'          : '    </sect3>'                      ,
    778. 

  778. 		'title4Open'           : '~A~      <sect4><title>\a</title>' ,
    779. 

  779. 		'title4Close'          : '      </sect4>'                    ,
    780. 

  780. 		'title5Open'           : '~A~        <sect5><title>\a</title>',
    781. 

  781. 		'title5Close'          : '        </sect5>'                  ,
    782. 

  782. 		'anchor'               : '<anchor id="\a"/>\n'               ,
    783. 

  783. 		'blockVerbOpen'        : '<programlisting>'                  ,
    784. 

  784. 		'blockVerbClose'       : '</programlisting>'                 ,
    785. 

  785. 		'blockQuoteOpen'       : '<blockquote><para>'                ,
    786. 

  786. 		'blockQuoteClose'      : '</para></blockquote>'              ,
    787. 

  787. 		'fontMonoOpen'         : '<code>'                            ,
    788. 

  788. 		'fontMonoClose'        : '</code>'                           ,
    789. 

  789. 		'fontBoldOpen'         : '<emphasis role="bold">'            ,
    790. 

  790. 		'fontBoldClose'        : '</emphasis>'                       ,
    791. 

  791. 		'fontItalicOpen'       : '<emphasis>'                        ,
    792. 

  792. 		'fontItalicClose'      : '</emphasis>'                       ,
    793. 

  793. 		'fontUnderlineOpen'    : '<emphasis role="underline">'       ,
    794. 

  794. 		'fontUnderlineClose'   : '</emphasis>'                       ,
    795. 

  795. 		# 'fontStrikeOpen'       : '<emphasis role="strikethrough">'   , # Don't know
    796. 

  796. 		# 'fontStrikeClose'      : '</emphasis>'                       ,
    797. 

  797. 		'listOpen'             : '<itemizedlist>'                    ,
    798. 

  798. 		'listClose'            : '</itemizedlist>'                   ,
    799. 

  799. 		'listItemOpen'         : '<listitem><para>'                  ,
    800. 

  800. 		'listItemClose'        : '</para></listitem>'                ,
    801. 

  801. 		'numlistOpen'          : '<orderedlist numeration="arabic">' ,
    802. 

  802. 		'numlistClose'         : '</orderedlist>'                    ,
    803. 

  803. 		'numlistItemOpen'      : '<listitem><para>'                  ,
    804. 

  804. 		'numlistItemClose'     : '</para></listitem>'                ,
    805. 

  805. 		'deflistOpen'          : '<variablelist>'                    ,
    806. 

  806. 		'deflistClose'         : '</variablelist>'                   ,
    807. 

  807. 		'deflistItem1Open'     : '<varlistentry><term>'              ,
    808. 

  808. 		'deflistItem1Close'    : '</term>'                           ,
    809. 

  809. 		'deflistItem2Open'     : '<listitem><para>'                  ,
    810. 

  810. 		'deflistItem2Close'    : '</para></listitem></varlistentry>' ,
    811. 

  811. 		# 'bar1'                 : '<>'                                , # Don't know
    812. 

  812. 		# 'bar2'                 : '<>'                                , # Don't know
    813. 

  813. 		'url'                  : '<ulink url="\a">\a</ulink>'        ,
    814. 

  814. 		'urlMark'              : '<ulink url="\a">\a</ulink>'        ,
    815. 

  815. 		'email'                : '<email>\a</email>'                 ,
    816. 

  816. 		'emailMark'            : '<email>\a</email>'                 ,
    817. 

  817. 		'img'                  : '<mediaobject><imageobject><imagedata fileref="\a"/></imageobject></mediaobject>',
    818. 

  818. 		# '_imgAlignLeft'        : ''                                 , # Don't know
    819. 

  819. 		# '_imgAlignCenter'      : ''                                 , # Don't know
    820. 

  820. 		# '_imgAlignRight'       : ''                                 , # Don't know
    821. 

  821. 		'tableOpen'            : '<para>', # just to have something...
    822. 

  822. 		'tableClose'           : '</para>',
    823. 

  823. 		# 'tableOpen'            : '<informaltable><tgroup cols=""><tbody>', # Don't work, need to know number of cols
    824. 

  824. 		# 'tableClose'           : '</tbody></tgroup></informaltable>' ,
    825. 

  825. 		# 'tableRowOpen'         : '<row>'                             ,
    826. 

  826. 		# 'tableRowClose'        : '</row>'                            ,
    827. 

  827. 		# 'tableCellOpen'        : '<entry>'                           ,
    828. 

  828. 		# 'tableCellClose'       : '</entry>'                          ,
    829. 

  829. 		# 'tableTitleRowOpen'    : '<thead>'                           ,
    830. 

  830. 		# 'tableTitleRowClose'   : '</thead>'                          ,
    831. 

  831. 		# '_tableBorder'         : ' frame="all"'                      ,
    832. 

  832. 		# '_tableAlignCenter'    : ' align="center"'                   ,
    833. 

  833. 		# '_tableCellAlignRight' : ' align="right"'                    ,
    834. 

  834. 		# '_tableCellAlignCenter': ' align="center"'                   ,
    835. 

  835. 		# '_tableCellColSpan'    : ' COLSPAN="\a"'                     ,
    836. 

  836. 		'TOC'                  : '</index>'                          ,
    837. 

  837. 		'comment'              : '<!-- \a -->'                       ,
    838. 

  838. 		'EOD'                  : '</article>'
    839. 

  839. 	},
    840. 

  840. 	
    841. 

  841. 	'tex': {
    842. 

  842. 		'title1'               : '~A~\section*{\a}'     ,
    843. 

  843. 		'title2'               : '~A~\\subsection*{\a}'   ,
    844. 

  844. 		'title3'               : '~A~\\subsubsection*{\a}',
    845. 

  845. 		# title 4/5: DIRTY: para+BF+\\+\n
    846. 

  846. 		'title4'               : '~A~\\paragraph{}\\textbf{\a}\\\\\n',
    847. 

  847. 		'title5'               : '~A~\\paragraph{}\\textbf{\a}\\\\\n',
    848. 

  848. 		'numtitle1'            : '\n~A~\section{\a}'      ,
    849. 

  849. 		'numtitle2'            : '~A~\\subsection{\a}'    ,
    850. 

  850. 		'numtitle3'            : '~A~\\subsubsection{\a}' ,
    851. 

  851. 		'anchor'               : '\\hypertarget{\a}{}\n'  ,
    852. 

  852. 		'blockVerbOpen'        : '\\begin{verbatim}'   ,
    853. 

  853. 		'blockVerbClose'       : '\\end{verbatim}'     ,
    854. 

  854. 		'blockQuoteOpen'       : '\\begin{quotation}'  ,
    855. 

  855. 		'blockQuoteClose'      : '\\end{quotation}'    ,
    856. 

  856. 		'fontMonoOpen'         : '\\texttt{'           ,
    857. 

  857. 		'fontMonoClose'        : '}'                   ,
    858. 

  858. 		'fontBoldOpen'         : '\\textbf{'           ,
    859. 

  859. 		'fontBoldClose'        : '}'                   ,
    860. 

  860. 		'fontItalicOpen'       : '\\textit{'           ,
    861. 

  861. 		'fontItalicClose'      : '}'                   ,
    862. 

  862. 		'fontUnderlineOpen'    : '\\underline{'        ,
    863. 

  863. 		'fontUnderlineClose'   : '}'                   ,
    864. 

  864. 		'fontStrikeOpen'       : '\\sout{'             ,
    865. 

  865. 		'fontStrikeClose'      : '}'                   ,
    866. 

  866. 		'listOpen'             : '\\begin{itemize}'    ,
    867. 

  867. 		'listClose'            : '\\end{itemize}'      ,
    868. 

  868. 		'listOpenCompact'      : '\\begin{compactitem}',
    869. 

  869. 		'listCloseCompact'     : '\\end{compactitem}'  ,
    870. 

  870. 		'listItemOpen'         : '\\item '             ,
    871. 

  871. 		'numlistOpen'          : '\\begin{enumerate}'  ,
    872. 

  872. 		'numlistClose'         : '\\end{enumerate}'    ,
    873. 

  873. 		'numlistOpenCompact'   : '\\begin{compactenum}',
    874. 

  874. 		'numlistCloseCompact'  : '\\end{compactenum}'  ,
    875. 

  875. 		'numlistItemOpen'      : '\\item '             ,
    876. 

  876. 		'deflistOpen'          : '\\begin{description}',
    877. 

  877. 		'deflistClose'         : '\\end{description}'  ,
    878. 

  878. 		'deflistOpenCompact'   : '\\begin{compactdesc}',
    879. 

  879. 		'deflistCloseCompact'  : '\\end{compactdesc}'  ,
    880. 

  880. 		'deflistItem1Open'     : '\\item['             ,
    881. 

  881. 		'deflistItem1Close'    : ']'                   ,
    882. 

  882. 		'bar1'                 : '\\hrulefill{}'       ,
    883. 

  883. 		'bar2'                 : '\\rule{\linewidth}{1mm}',
    884. 

  884. 		'url'                  : '\\htmladdnormallink{\a}{\a}',
    885. 

  885. 		'urlMark'              : '\\htmladdnormallink{\a}{\a}',
    886. 

  886. 		'email'                : '\\htmladdnormallink{\a}{mailto:\a}',
    887. 

  887. 		'emailMark'            : '\\htmladdnormallink{\a}{mailto:\a}',
    888. 

  888. 		'img'                  : '\\includegraphics{\a}',
    889. 

  889. 		'tableOpen'            : '\\begin{center}\\begin{tabular}{|~C~|}',
    890. 

  890. 		'tableClose'           : '\\end{tabular}\\end{center}',
    891. 

  891. 		'tableRowOpen'         : '\\hline ' ,
    892. 

  892. 		'tableRowClose'        : ' \\\\'    ,
    893. 

  893. 		'tableCellSep'         : ' & '      ,
    894. 

  894. 		'_tableColAlignLeft'   : 'l'        ,
    895. 

  895. 		'_tableColAlignRight'  : 'r'        ,
    896. 

  896. 		'_tableColAlignCenter' : 'c'        ,
    897. 

  897. 		'_tableCellAlignLeft'  : 'l'        ,
    898. 

  898. 		'_tableCellAlignRight' : 'r'        ,
    899. 

  899. 		'_tableCellAlignCenter': 'c'        ,
    900. 

  900. 		'_tableCellColSpan'    : '\a'       ,
    901. 

  901. 		'_tableCellMulticolOpen'  : '\\multicolumn{\a}{|~C~|}{',
    902. 

  902. 		'_tableCellMulticolClose' : '}',
    903. 

  903. 		'tableColAlignSep'     : '|'        ,
    904. 

  904. 		'comment'              : '% \a'     ,
    905. 

  905. 		'TOC'                  : '\\tableofcontents',
    906. 

  906. 		'pageBreak'            : '\\clearpage',
    907. 

  907. 		'EOD'                  : '\\end{document}'
    908. 

  908. 	},
    909. 

  909. 	
    910. 

  910. 	'lout': {
    911. 

  911. 		'paragraphOpen'        : '@LP'                     ,
    912. 

  912. 		'blockTitle1Open'      : '@BeginSections'          ,
    913. 

  913. 		'blockTitle1Close'     : '@EndSections'            ,
    914. 

  914. 		'blockTitle2Open'      : ' @BeginSubSections'      ,
    915. 

  915. 		'blockTitle2Close'     : ' @EndSubSections'        ,
    916. 

  916. 		'blockTitle3Open'      : '  @BeginSubSubSections'  ,
    917. 

  917. 		'blockTitle3Close'     : '  @EndSubSubSections'    ,
    918. 

  918. 		'title1Open'           : '~A~@Section @Title { \a } @Begin',
    919. 

  919. 		'title1Close'          : '@End @Section'           ,
    920. 

  920. 		'title2Open'           : '~A~ @SubSection @Title { \a } @Begin',
    921. 

  921. 		'title2Close'          : ' @End @SubSection'       ,
    922. 

  922. 		'title3Open'           : '~A~  @SubSubSection @Title { \a } @Begin',
    923. 

  923. 		'title3Close'          : '  @End @SubSubSection'   ,
    924. 

  924. 		'title4Open'           : '~A~@LP @LeftDisplay @B { \a }',
    925. 

  925. 		'title5Open'           : '~A~@LP @LeftDisplay @B { \a }',
    926. 

  926. 		'anchor'               : '@Tag { \a }\n'       ,
    927. 

  927. 		'blockVerbOpen'        : '@LP @ID @F @RawVerbatim @Begin',
    928. 

  928. 		'blockVerbClose'       : '@End @RawVerbatim'   ,
    929. 

  929. 		'blockQuoteOpen'       : '@QD {'               ,
    930. 

  930. 		'blockQuoteClose'      : '}'                   ,
    931. 

  931. 		# enclosed inside {} to deal with joined**words**
    932. 

  932. 		'fontMonoOpen'         : '{@F {'               ,
    933. 

  933. 		'fontMonoClose'        : '}}'                  ,
    934. 

  934. 		'fontBoldOpen'         : '{@B {'               ,
    935. 

  935. 		'fontBoldClose'        : '}}'                  ,
    936. 

  936. 		'fontItalicOpen'       : '{@II {'              ,
    937. 

  937. 		'fontItalicClose'      : '}}'                  ,
    938. 

  938. 		'fontUnderlineOpen'    : '{@Underline{'        ,
    939. 

  939. 		'fontUnderlineClose'   : '}}'                  ,
    940. 

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

  941. 		'listOpen'             : '@BulletList'         ,
    942. 

  942. 		'listClose'            : '@EndList'            ,
    943. 

  943. 		'listItemOpen'         : '@ListItem{'          ,
    944. 

  944. 		'listItemClose'        : '}'                   ,
    945. 

  945. 		'numlistOpen'          : '@NumberedList'       ,
    946. 

  946. 		'numlistClose'         : '@EndList'            ,
    947. 

  947. 		'numlistItemOpen'      : '@ListItem{'          ,
    948. 

  948. 		'numlistItemClose'     : '}'                   ,
    949. 

  949. 		'deflistOpen'          : '@TaggedList'         ,
    950. 

  950. 		'deflistClose'         : '@EndList'            ,
    951. 

  951. 		'deflistItem1Open'     : '@DropTagItem {'      ,
    952. 

  952. 		'deflistItem1Close'    : '}'                   ,
    953. 

  953. 		'deflistItem2Open'     : '{'                   ,
    954. 

  954. 		'deflistItem2Close'    : '}'                   ,
    955. 

  955. 		'bar1'                 : '@DP @FullWidthRule'  ,
    956. 

  956. 		'url'                  : '{blue @Colour { \a }}'      ,
    957. 

  957. 		'urlMark'              : '\a ({blue @Colour { \a }})' ,
    958. 

  958. 		'email'                : '{blue @Colour { \a }}'      ,
    959. 

  959. 		'emailMark'            : '\a ({blue Colour{ \a }})'   ,
    960. 

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

  961. 		'_imgAlignLeft'        : '@LeftDisplay '              ,
    962. 

  962. 		'_imgAlignRight'       : '@RightDisplay '             ,
    963. 

  963. 		'_imgAlignCenter'      : '@CentredDisplay '           ,
    964. 

  964. 		# lout tables are *way* complicated, no support for now
    965. 

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

  966. 		#'tableClose'           : '}'     ,
    967. 

  967. 		#'tableRowOpen'         : '@Rowa\n'       ,
    968. 

  968. 		#'tableTitleRowOpen'    : '@HeaderRowa'       ,
    969. 

  969. 		#'tableCenterAlign'     : '@CentredDisplay '         ,
    970. 

  970. 		#'tableCellOpen'        : '\a {'                     ,	# A, B, ...
    971. 

  971. 		#'tableCellClose'       : '}'                        ,
    972. 

  972. 		#'_tableBorder'         : '\nrule {yes}'             ,
    973. 

  973. 		'comment'              : '# \a'                     ,
    974. 

  974. 		# @MakeContents must be on the config file
    975. 

  975. 		'TOC'                  : '@DP @ContentsGoesHere @DP',
    976. 

  976. 		'pageBreak'            : '@NP'                      ,
    977. 

  977. 		'EOD'                  : '@End @Text'
    978. 

  978. 	},
    979. 

  979. 	
    980. 

  980. 	# http://moinmo.in/SyntaxReference
    981. 

  981. 	'moin': {
    982. 

  982. 		'title1'                : '= \a ='        ,
    983. 

  983. 		'title2'                : '== \a =='      ,
    984. 

  984. 		'title3'                : '=== \a ==='    ,
    985. 

  985. 		'title4'                : '==== \a ===='  ,
    986. 

  986. 		'title5'                : '===== \a =====',
    987. 

  987. 		'blockVerbOpen'         : '{{{'           ,
    988. 

  988. 		'blockVerbClose'        : '}}}'           ,
    989. 

  989. 		'blockQuoteLine'        : '  '            ,
    990. 

  990. 		'fontMonoOpen'          : '{{{'           ,
    991. 

  991. 		'fontMonoClose'         : '}}}'           ,
    992. 

  992. 		'fontBoldOpen'          : "'''"           ,
    993. 

  993. 		'fontBoldClose'         : "'''"           ,
    994. 

  994. 		'fontItalicOpen'        : "''"            ,
    995. 

  995. 		'fontItalicClose'       : "''"            ,
    996. 

  996. 		'fontUnderlineOpen'     : '__'            ,
    997. 

  997. 		'fontUnderlineClose'    : '__'            ,
    998. 

  998. 		'fontStrikeOpen'        : '--('           ,
    999. 

  999. 		'fontStrikeClose'       : ')--'           ,
    1000. 

  1000. 		'listItemOpen'          : ' * '           ,
    1001. 

  1001. 		'numlistItemOpen'       : ' \a. '         ,
    1002. 

  1002. 		'deflistItem1Open'      : ' '             ,
    1003. 

  1003. 		'deflistItem1Close'     : '::'            ,
    1004. 

  1004. 		'deflistItem2LinePrefix': ' :: '          ,
    1005. 

  1005. 		'bar1'                  : '----'          ,
    1006. 

  1006. 		'bar2'                  : '--------'      ,
    1007. 

  1007. 		'url'                   : '[\a]'          ,
    1008. 

  1008. 		'urlMark'               : '[\a \a]'       ,
    1009. 

  1009. 		'email'                 : '[\a]'          ,
    1010. 

  1010. 		'emailMark'             : '[\a \a]'       ,
    1011. 

  1011. 		'img'                   : '[\a]'          ,
    1012. 

  1012. 		'tableRowOpen'          : '||'            ,
    1013. 

  1013. 		'tableCellOpen'         : '~A~'           ,
    1014. 

  1014. 		'tableCellClose'        : '||'            ,
    1015. 

  1015. 		'tableTitleCellClose'   : '||'            ,
    1016. 

  1016. 		'_tableCellAlignRight'  : '<)>'           ,
    1017. 

  1017. 		'_tableCellAlignCenter' : '<:>'           ,
    1018. 

  1018. 		'comment'               : '/* \a */'      ,
    1019. 

  1019. 		'TOC'                   : '[[TableOfContents]]'
    1020. 

  1020. 	},
    1021. 

  1021. 

  1022. 	# http://code.google.com/p/support/wiki/WikiSyntax
    1023. 

  1023. 	'gwiki': {
    1024. 

  1024. 		'title1'               : '= \a ='        ,
    1025. 

  1025. 		'title2'               : '== \a =='      ,
    1026. 

  1026. 		'title3'               : '=== \a ==='    ,
    1027. 

  1027. 		'title4'               : '==== \a ===='  ,
    1028. 

  1028. 		'title5'               : '===== \a =====',
    1029. 

  1029. 		'blockVerbOpen'        : '{{{'           ,
    1030. 

  1030. 		'blockVerbClose'       : '}}}'           ,
    1031. 

  1031. 		'blockQuoteLine'       : '  '            ,
    1032. 

  1032. 		'fontMonoOpen'         : '{{{'           ,
    1033. 

  1033. 		'fontMonoClose'        : '}}}'           ,
    1034. 

  1034. 		'fontBoldOpen'         : '*'             ,
    1035. 

  1035. 		'fontBoldClose'        : '*'             ,
    1036. 

  1036. 		'fontItalicOpen'       : '_'             , # underline == italic
    1037. 

  1037. 		'fontItalicClose'      : '_'             ,
    1038. 

  1038. 		'fontStrikeOpen'       : '~~'            ,
    1039. 

  1039. 		'fontStrikeClose'      : '~~'            ,
    1040. 

  1040. 		'listItemOpen'         : ' * '           ,
    1041. 

  1041. 		'numlistItemOpen'      : ' # '           ,
    1042. 

  1042. 		'url'                  : '\a'            ,
    1043. 

  1043. 		'urlMark'              : '[\a \a]'       ,
    1044. 

  1044. 		'email'                : 'mailto:\a'     ,
    1045. 

  1045. 		'emailMark'            : '[mailto:\a \a]',
    1046. 

  1046. 		'img'                  : '[\a]'          ,
    1047. 

  1047. 		'tableRowOpen'         : '|| '           ,
    1048. 

  1048. 		'tableRowClose'        : ' ||'           ,
    1049. 

  1049. 		'tableCellSep'         : ' || '          ,
    1050. 

  1050. 	},
    1051. 

  1051. 

  1052. 	# http://powerman.name/doc/asciidoc
    1053. 

  1053. 	'adoc': {
    1054. 

  1054. 		'title1'               : '== \a'         ,
    1055. 

  1055. 		'title2'               : '=== \a'        ,
    1056. 

  1056. 		'title3'               : '==== \a'       ,
    1057. 

  1057. 		'title4'               : '===== \a'      ,
    1058. 

  1058. 		'title5'               : '===== \a'      ,
    1059. 

  1059. 		'blockVerbOpen'        : '----'          ,
    1060. 

  1060. 		'blockVerbClose'       : '----'          ,
    1061. 

  1061. 		'fontMonoOpen'         : '+'             ,
    1062. 

  1062. 		'fontMonoClose'        : '+'             ,
    1063. 

  1063. 		'fontBoldOpen'         : '*'             ,
    1064. 

  1064. 		'fontBoldClose'        : '*'             ,
    1065. 

  1065. 		'fontItalicOpen'       : '_'             ,
    1066. 

  1066. 		'fontItalicClose'      : '_'             ,
    1067. 

  1067. 		'listItemOpen'         : '- '            ,
    1068. 

  1068. 		'listItemLine'         : '\t'            ,
    1069. 

  1069. 		'numlistItemOpen'      : '. '            ,
    1070. 

  1070. 		'url'                  : '\a'            ,
    1071. 

  1071. 		'urlMark'              : '\a[\a]'        ,
    1072. 

  1072. 		'email'                : 'mailto:\a'     ,
    1073. 

  1073. 		'emailMark'            : 'mailto:\a[\a]' ,
    1074. 

  1074. 		'img'                  : 'image::\a[]'   ,
    1075. 

  1075. 	},
    1076. 

  1076. 

  1077. 	# http://wiki.splitbrain.org/wiki:syntax
    1078. 

  1078. 	# Hint: <br> is \\ $
    1079. 

  1079. 	# Hint: You can add footnotes ((This is a footnote))
    1080. 

  1080. 	'doku': {
    1081. 

  1081. 		'title1'               : '===== \a =====',
    1082. 

  1082. 		'title2'               : '==== \a ===='  ,
    1083. 

  1083. 		'title3'               : '=== \a ==='    ,
    1084. 

  1084. 		'title4'               : '== \a =='      ,
    1085. 

  1085. 		'title5'               : '= \a ='        ,
    1086. 

  1086. 		# DokuWiki uses '  ' identation to mark verb blocks (see indentverbblock)
    1087. 

  1087. 		'blockQuoteLine'       : '>'             ,
    1088. 

  1088. 		'fontMonoOpen'         : "''"            ,
    1089. 

  1089. 		'fontMonoClose'        : "''"            ,
    1090. 

  1090. 		'fontBoldOpen'         : "**"            ,
    1091. 

  1091. 		'fontBoldClose'        : "**"            ,
    1092. 

  1092. 		'fontItalicOpen'       : "//"            ,
    1093. 

  1093. 		'fontItalicClose'      : "//"            ,
    1094. 

  1094. 		'fontUnderlineOpen'    : "__"            ,
    1095. 

  1095. 		'fontUnderlineClose'   : "__"            ,
    1096. 

  1096. 		'fontStrikeOpen'       : '<del>'         ,
    1097. 

  1097. 		'fontStrikeClose'      : '</del>'        ,
    1098. 

  1098. 		'listItemOpen'         : '  * '          ,
    1099. 

  1099. 		'numlistItemOpen'      : '  - '          ,
    1100. 

  1100. 		'bar1'                 : '----'          ,
    1101. 

  1101. 		'url'                  : '[[\a]]'        ,
    1102. 

  1102. 		'urlMark'              : '[[\a|\a]]'     ,
    1103. 

  1103. 		'email'                : '[[\a]]'        ,
    1104. 

  1104. 		'emailMark'            : '[[\a|\a]]'     ,
    1105. 

  1105. 		'img'                  : '{{\a}}'        ,
    1106. 

  1106. 		'imgAlignLeft'         : '{{\a }}'       ,
    1107. 

  1107. 		'imgAlignRight'        : '{{ \a}}'       ,
    1108. 

  1108. 		'imgAlignCenter'       : '{{ \a }}'      ,
    1109. 

  1109. 		'tableTitleRowOpen'    : '^ '            ,
    1110. 

  1110. 		'tableTitleRowClose'   : ' ^'            ,
    1111. 

  1111. 		'tableTitleCellSep'    : ' ^ '           ,
    1112. 

  1112. 		'tableRowOpen'         : '| '            ,
    1113. 

  1113. 		'tableRowClose'        : ' |'            ,
    1114. 

  1114. 		'tableCellSep'         : ' | '           ,
    1115. 

  1115. 		# DokuWiki has no attributes. The content must be aligned!
    1116. 

  1116. 		# '_tableCellAlignRight' : '<)>'           , # ??
    1117. 

  1117. 		# '_tableCellAlignCenter': '<:>'           , # ??
    1118. 

  1118. 		# DokuWiki colspan is the same as txt2tags' with multiple |||
    1119. 

  1119. 		# 'comment'             : '## \a'         , # ??
    1120. 

  1120. 		# TOC is automatic
    1121. 

  1121. 	},
    1122. 

  1122. 	
    1123. 

  1123. 	# http://www.pmwiki.org/wiki/PmWiki/TextFormattingRules
    1124. 

  1124. 	'pmw': {
    1125. 

  1125. 		'title1'               : '~A~! \a '      ,
    1126. 

  1126. 		'title2'               : '~A~!! \a '  	 ,
    1127. 

  1127. 		'title3'               : '~A~!!! \a '    ,
    1128. 

  1128. 		'title4'               : '~A~!!!! \a '   ,
    1129. 

  1129. 		'title5'               : '~A~!!!!! \a '  ,
    1130. 

  1130. 		'blockQuoteOpen'       : '->'            ,
    1131. 

  1131. 		'blockQuoteClose'      : '\n'            ,
    1132. 

  1132. 		# In-text font 
    1133. 

  1133. 		'fontLargeOpen'        : "[+"            ,
    1134. 

  1134. 		'fontLargeClose'       : "+]"            ,
    1135. 

  1135. 		'fontLargerOpen'       : "[++"           ,
    1136. 

  1136. 		'fontLargerClose'      : "++]"           ,
    1137. 

  1137. 		'fontSmallOpen'        : "[-"            ,
    1138. 

  1138. 		'fontSmallClose'       : "-]"            ,
    1139. 

  1139. 		'fontLargerOpen'       : "[--"           ,
    1140. 

  1140. 		'fontLargerClose'      : "--]"           ,
    1141. 

  1141. 		'fontMonoOpen'         : "@@"            ,
    1142. 

  1142. 		'fontMonoClose'        : "@@"            ,
    1143. 

  1143. 		'fontBoldOpen'         : "'''"           ,
    1144. 

  1144. 		'fontBoldClose'        : "'''"           ,
    1145. 

  1145. 		'fontItalicOpen'       : "''"            ,
    1146. 

  1146. 		'fontItalicClose'      : "''"            ,
    1147. 

  1147. 		'fontUnderlineOpen'    : "{+"            ,
    1148. 

  1148. 		'fontUnderlineClose'   : "+}"            ,
    1149. 

  1149. 		'fontStrikeOpen'       : '{-'         	 ,
    1150. 

  1150. 		'fontStrikeClose'      : '-}'        	 ,
    1151. 

  1151. 		# Lists 
    1152. 

  1152. 		'listItemOpen'         	: '* '           ,
    1153. 

  1153. 		'numlistItemOpen'      	: '# '           ,
    1154. 

  1154. 		'deflistItem1Open'      : ': '           ,
    1155. 

  1155. 		'deflistItem1Close'     : ':'            ,
    1156. 

  1156. 		'deflistItem2LineOpen'  : '::'           ,
    1157. 

  1157. 		'deflistItem2LineClose' : ':'            ,
    1158. 

  1158. 		# Verbatim block 
    1159. 

  1159. 		'blockVerbOpen'        : '[@'          	 ,
    1160. 

  1160. 		'blockVerbClose'       : '@]'            ,
    1161. 

  1161. 		'bar1'                 : '----'          ,
    1162. 

  1162. 		# URL, email and anchor
    1163. 

  1163. 		'url'                   : '\a'           ,
    1164. 

  1164. 		'urlMark'               : '[[\a -> \a]]' ,
    1165. 

  1165. 		'email'                 : '\a'           ,
    1166. 

  1166. 		'emailMark'             : '[[\a -> mailto:\a]]',
    1167. 

  1167. 		'anchor'                : '[[#\a]]\n'    ,
    1168. 

  1168. 		# Image markup 
    1169. 

  1169. 		'img'                   : '\a'           ,
    1170. 

  1170. 		#'imgAlignLeft'         : '{{\a }}'       ,
    1171. 

  1171. 		#'imgAlignRight'        : '{{ \a}}'       ,
    1172. 

  1172. 		#'imgAlignCenter'       : '{{ \a }}'      ,
    1173. 

  1173. 		# Table attributes
    1174. 

  1174. 		'tableTitleRowOpen'    : '||! '          ,
    1175. 

  1175. 		'tableTitleRowClose'   : '||'            ,
    1176. 

  1176. 		'tableTitleCellSep'    : ' ||!'          ,
    1177. 

  1177. 		'tableRowOpen'         : '||'            ,
    1178. 

  1178. 		'tableRowClose'        : '||'            ,
    1179. 

  1179. 		'tableCellSep'         : ' ||'           ,
    1180. 

  1180. 	},
    1181. 

  1181. 	
    1182. 

  1182. 	# http://en.wikipedia.org/wiki/Help:Editing
    1183. 

  1183. 	'wiki': {
    1184. 

  1184. 		'title1'                : '== \a =='        ,
    1185. 

  1185. 		'title2'                : '=== \a ==='      ,
    1186. 

  1186. 		'title3'                : '==== \a ===='    ,
    1187. 

  1187. 		'title4'                : '===== \a ====='  ,
    1188. 

  1188. 		'title5'                : '====== \a ======',
    1189. 

  1189. 		'blockVerbOpen'         : '<pre>'           ,
    1190. 

  1190. 		'blockVerbClose'        : '</pre>'          ,
    1191. 

  1191. 		'blockQuoteOpen'        : '<blockquote>'    ,
    1192. 

  1192. 		'blockQuoteClose'       : '</blockquote>'   ,
    1193. 

  1193. 		'fontMonoOpen'          : '<tt>'            ,
    1194. 

  1194. 		'fontMonoClose'         : '</tt>'           ,
    1195. 

  1195. 		'fontBoldOpen'          : "'''"             ,
    1196. 

  1196. 		'fontBoldClose'         : "'''"             ,
    1197. 

  1197. 		'fontItalicOpen'        : "''"              ,
    1198. 

  1198. 		'fontItalicClose'       : "''"              ,
    1199. 

  1199. 		'fontUnderlineOpen'     : '<u>'             ,
    1200. 

  1200. 		'fontUnderlineClose'    : '</u>'            ,
    1201. 

  1201. 		'fontStrikeOpen'        : '<s>'             ,
    1202. 

  1202. 		'fontStrikeClose'       : '</s>'            ,
    1203. 

  1203. 		#XXX Mixed lists not working: *#* list inside numlist inside list
    1204. 

  1204. 		'listItemLine'          : '*'               ,
    1205. 

  1205. 		'numlistItemLine'       : '#'               ,
    1206. 

  1206. 		'deflistItem1Open'      : '; '              ,
    1207. 

  1207. 		'deflistItem2LinePrefix': ': '            ,
    1208. 

  1208. 		'bar1'                  : '----'            ,
    1209. 

  1209. 		'url'                   : '[\a]'            ,
    1210. 

  1210. 		'urlMark'               : '[\a \a]'         ,
    1211. 

  1211. 		'email'                 : 'mailto:\a'       ,
    1212. 

  1212. 		'emailMark'             : '[mailto:\a \a]'  ,
    1213. 

  1213. 		# [[Image:foo.png|right|Optional alt/caption text]] (right, left, center, none)
    1214. 

  1214. 		'img'                   : '[[Image:\a~A~]]' ,
    1215. 

  1215. 		'_imgAlignLeft'         : '|left'           ,
    1216. 

  1216. 		'_imgAlignCenter'       : '|center'         ,
    1217. 

  1217. 		'_imgAlignRight'        : '|right'          ,
    1218. 

  1218. 		# {| border="1" cellspacing="0" cellpadding="4" align="center"
    1219. 

  1219. 		'tableOpen'             : '{|~A~~B~ cellpadding="4"',
    1220. 

  1220. 		'tableClose'            : '|}'              ,
    1221. 

  1221. 		'tableRowOpen'          : '|-\n| '          ,
    1222. 

  1222. 		'tableTitleRowOpen'     : '|-\n! '          ,
    1223. 

  1223. 		'tableCellSep'          : ' || '            ,
    1224. 

  1224. 		'tableTitleCellSep'     : ' !! '            ,
    1225. 

  1225. 		'_tableBorder'          : ' border="1"'     ,
    1226. 

  1226. 		'_tableAlignCenter'     : ' align="center"' ,
    1227. 

  1227. 		'comment'               : '<!-- \a -->'     ,
    1228. 

  1228. 		'TOC'                   : '__TOC__'         ,
    1229. 

  1229. 	},
    1230. 

  1230. 	
    1231. 

  1231. 	# http://www.inference.phy.cam.ac.uk/mackay/mgp/SYNTAX
    1232. 

  1232. 	# http://en.wikipedia.org/wiki/MagicPoint
    1233. 

  1233. 	'mgp': {
    1234. 

  1234. 		'paragraphOpen'         : '%font "normal", size 5'     ,
    1235. 

  1235. 		'title1'                : '%page\n\n\a\n'              ,
    1236. 

  1236. 		'title2'                : '%page\n\n\a\n'              ,
    1237. 

  1237. 		'title3'                : '%page\n\n\a\n'              ,
    1238. 

  1238. 		'title4'                : '%page\n\n\a\n'              ,
    1239. 

  1239. 		'title5'                : '%page\n\n\a\n'              ,
    1240. 

  1240. 		'blockVerbOpen'         : '%font "mono"'               ,
    1241. 

  1241. 		'blockVerbClose'        : '%font "normal"'             ,
    1242. 

  1242. 		'blockQuoteOpen'        : '%prefix "       "'          ,
    1243. 

  1243. 		'blockQuoteClose'       : '%prefix "  "'               ,
    1244. 

  1244. 		'fontMonoOpen'          : '\n%cont, font "mono"\n'     ,
    1245. 

  1245. 		'fontMonoClose'         : '\n%cont, font "normal"\n'   ,
    1246. 

  1246. 		'fontBoldOpen'          : '\n%cont, font "normal-b"\n' ,
    1247. 

  1247. 		'fontBoldClose'         : '\n%cont, font "normal"\n'   ,
    1248. 

  1248. 		'fontItalicOpen'        : '\n%cont, font "normal-i"\n' ,
    1249. 

  1249. 		'fontItalicClose'       : '\n%cont, font "normal"\n'   ,
    1250. 

  1250. 		'fontUnderlineOpen'     : '\n%cont, fore "cyan"\n'     ,
    1251. 

  1251. 		'fontUnderlineClose'    : '\n%cont, fore "white"\n'    ,
    1252. 

  1252. 		'listItemLine'          : '\t'                         ,
    1253. 

  1253. 		'numlistItemLine'       : '\t'                         ,
    1254. 

  1254. 		'numlistItemOpen'       : '\a. '                       ,
    1255. 

  1255. 		'deflistItem1Open'      : '\t\n%cont, font "normal-b"\n',
    1256. 

  1256. 		'deflistItem1Close'     : '\n%cont, font "normal"\n'   ,
    1257. 

  1257. 		'bar1'                  : '%bar "white" 5'             ,
    1258. 

  1258. 		'bar2'                  : '%pause'                     ,
    1259. 

  1259. 		'url'                   : '\n%cont, fore "cyan"\n\a'   +\
    1260. 

  1260. 		                          '\n%cont, fore "white"\n'    ,
    1261. 

  1261. 		'urlMark'               : '\a \n%cont, fore "cyan"\n\a'+\
    1262. 

  1262. 		                          '\n%cont, fore "white"\n'    ,
    1263. 

  1263. 		'email'                 : '\n%cont, fore "cyan"\n\a'   +\
    1264. 

  1264. 		                          '\n%cont, fore "white"\n'    ,
    1265. 

  1265. 		'emailMark'             : '\a \n%cont, fore "cyan"\n\a'+\
    1266. 

  1266. 		                          '\n%cont, fore "white"\n'    ,
    1267. 

  1267. 		'img'                   : '~A~\n%newimage "\a"\n%left\n',
    1268. 

  1268. 		'_imgAlignLeft'         : '\n%left'                    ,
    1269. 

  1269. 		'_imgAlignRight'        : '\n%right'                   ,
    1270. 

  1270. 		'_imgAlignCenter'       : '\n%center'                  ,
    1271. 

  1271. 		'comment'               : '%% \a'                      ,
    1272. 

  1272. 		'pageBreak'             : '%page\n\n\n'                ,
    1273. 

  1273. 		'EOD'                   : '%%EOD'
    1274. 

  1274. 	},
    1275. 

  1275. 	
    1276. 

  1276. 	# man groff_man ; man 7 groff
    1277. 

  1277. 	'man': {
    1278. 

  1278. 		'paragraphOpen'         : '.P'     ,
    1279. 

  1279. 		'title1'                : '.SH \a' ,
    1280. 

  1280. 		'title2'                : '.SS \a' ,
    1281. 

  1281. 		'title3'                : '.SS \a' ,
    1282. 

  1282. 		'title4'                : '.SS \a' ,
    1283. 

  1283. 		'title5'                : '.SS \a' ,
    1284. 

  1284. 		'blockVerbOpen'         : '.nf'    ,
    1285. 

  1285. 		'blockVerbClose'        : '.fi\n'  ,
    1286. 

  1286. 		'blockQuoteOpen'        : '.RS'    ,
    1287. 

  1287. 		'blockQuoteClose'       : '.RE'    ,
    1288. 

  1288. 		'fontBoldOpen'          : '\\fB'   ,
    1289. 

  1289. 		'fontBoldClose'         : '\\fR'   ,
    1290. 

  1290. 		'fontItalicOpen'        : '\\fI'   ,
    1291. 

  1291. 		'fontItalicClose'       : '\\fR'   ,
    1292. 

  1292. 		'listOpen'              : '.RS'    ,
    1293. 

  1293. 		'listItemOpen'          : '.IP \(bu 3\n',
    1294. 

  1294. 		'listClose'             : '.RE'    ,
    1295. 

  1295. 		'numlistOpen'           : '.RS'    ,
    1296. 

  1296. 		'numlistItemOpen'       : '.IP \a. 3\n',
    1297. 

  1297. 		'numlistClose'          : '.RE'    ,
    1298. 

  1298. 		'deflistItem1Open'      : '.TP\n'  ,
    1299. 

  1299. 		'bar1'                  : '\n\n'   ,
    1300. 

  1300. 		'url'                   : '\a'     ,
    1301. 

  1301. 		'urlMark'               : '\a (\a)',
    1302. 

  1302. 		'email'                 : '\a'     ,
    1303. 

  1303. 		'emailMark'             : '\a (\a)',
    1304. 

  1304. 		'img'                   : '\a'     ,
    1305. 

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

  1306. 		'tableClose'            : '.TE'     ,
    1307. 

  1307. 		'tableRowOpen'          : ' '       ,
    1308. 

  1308. 		'tableCellSep'          : '^'       ,
    1309. 

  1309. 		'_tableAlignCenter'     : 'center, ',
    1310. 

  1310. 		'_tableBorder'          : 'allbox, ',
    1311. 

  1311. 		'_tableColAlignLeft'    : 'l'       ,
    1312. 

  1312. 		'_tableColAlignRight'   : 'r'       ,
    1313. 

  1313. 		'_tableColAlignCenter'  : 'c'       ,
    1314. 

  1314. 		'comment'               : '.\\" \a'
    1315. 

  1315. 	},
    1316. 

  1316. 	
    1317. 

  1317. 	'pm6': {
    1318. 

  1318. 		'paragraphOpen'         : '<@Normal:>'    ,
    1319. 

  1319. 		'title1'                : '<@Title1:>\a',
    1320. 

  1320. 		'title2'                : '<@Title2:>\a',
    1321. 

  1321. 		'title3'                : '<@Title3:>\a',
    1322. 

  1322. 		'title4'                : '<@Title4:>\a',
    1323. 

  1323. 		'title5'                : '<@Title5:>\a',
    1324. 

  1324. 		'blockVerbOpen'         : '<@PreFormat:>' ,
    1325. 

  1325. 		'blockQuoteLine'        : '<@Quote:>'     ,
    1326. 

  1326. 		'fontMonoOpen'          : '<FONT "Lucida Console"><SIZE 9>' ,
    1327. 

  1327. 		'fontMonoClose'         : '<SIZE$><FONT$>',
    1328. 

  1328. 		'fontBoldOpen'          : '<B>'           ,
    1329. 

  1329. 		'fontBoldClose'         : '<P>'           ,
    1330. 

  1330. 		'fontItalicOpen'        : '<I>'           ,
    1331. 

  1331. 		'fontItalicClose'       : '<P>'           ,
    1332. 

  1332. 		'fontUnderlineOpen'     : '<U>'           ,
    1333. 

  1333. 		'fontUnderlineClose'    : '<P>'           ,
    1334. 

  1334. 		'listOpen'              : '<@Bullet:>'    ,
    1335. 

  1335. 		'listItemOpen'          : '\x95\t'        ,  # \x95 == ~U
    1336. 

  1336. 		'numlistOpen'           : '<@Bullet:>'    ,
    1337. 

  1337. 		'numlistItemOpen'       : '\x95\t'        ,
    1338. 

  1338. 		'bar1'                  : '\a'            ,
    1339. 

  1339. 		'url'                   : '<U>\a<P>'      ,  # underline
    1340. 

  1340. 		'urlMark'               : '\a <U>\a<P>'   ,
    1341. 

  1341. 		'email'                 : '\a'            ,
    1342. 

  1342. 		'emailMark'             : '\a \a'         ,
    1343. 

  1343. 		'img'                   : '\a'
    1344. 

  1344. 	}
    1345. 

  1345. 	}
    1346. 

  1346. 	
    1347. 

  1347. 	# Exceptions for --css-sugar
    1348. 

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

  1349. 		# Change just HTML because XHTML inherits it
    1350. 

  1350. 		htmltags = alltags['html']
    1351. 

  1351. 		# Table with no cellpadding
    1352. 

  1352. 		htmltags['tableOpen'] = htmltags['tableOpen'].replace(' CELLPADDING="4"', '')
    1353. 

  1353. 		# DIVs
    1354. 

  1354. 		htmltags['tocOpen' ] = '<DIV CLASS="toc" ID="toc">'
    1355. 

  1355. 		htmltags['tocClose'] = '</DIV>'
    1356. 

  1356. 		htmltags['bodyOpen'] = '<DIV CLASS="body" ID="body">'
    1357. 

  1357. 		htmltags['bodyClose']= '</DIV>'
    1358. 

  1358. 	
    1359. 

  1359. 	# Make the HTML -> XHTML inheritance
    1360. 

  1360. 	xhtml = alltags['html'].copy()
    1361. 

  1361. 	for key in xhtml.keys(): xhtml[key] = xhtml[key].lower()
    1362. 

  1362. 	# Some like HTML tags as lowercase, some don't... (headers out)
    1363. 

  1363. 	if HTML_LOWER: alltags['html'] = xhtml.copy()
    1364. 

  1364. 	xhtml.update(alltags['xhtml'])
    1365. 

  1365. 	alltags['xhtml'] = xhtml.copy()
    1366. 

  1366. 	
    1367. 

  1367. 	# Compose the target tags dictionary
    1368. 

  1368. 	tags = {}
    1369. 

  1369. 	target_tags = alltags[config['target']].copy()
    1370. 

  1370. 	
    1371. 

  1371. 	for key in keys: tags[key] = '' # create empty keys
    1372. 

  1372. 	for key in target_tags.keys():
    1373. 

  1373. 		tags[key] = maskEscapeChar(target_tags[key]) # populate
    1374. 

  1374. 

  1375. 	# Map strong line to pagebreak
    1376. 

  1376. 	if rules['mapbar2pagebreak'] and tags['pageBreak']:
    1377. 

  1377. 		tags['bar2'] = tags['pageBreak']
    1378. 

  1378. 

  1379. 	# Map strong line to separator if not defined
    1380. 

  1380. 	if not tags['bar2'] and tags['bar1']:
    1381. 

  1381. 		tags['bar2'] = tags['bar1']
    1382. 

  1382. 

  1383. 	return tags
    1384. 

  1384. 

  1385. 

  1386. ##############################################################################
    1387. 

  1387. 

  1388. 

  1389. def getRules(config):
    1390. 

  1390. 	"Returns all the target-specific syntax rules"
    1391. 

  1391. 	
    1392. 

  1392. 	ret = {}
    1393. 

  1393. 	allrules = [
    1394. 

  1394. 	
    1395. 

  1395. 		# target rules (ON/OFF)
    1396. 

  1396. 		'linkable',             # target supports external links
    1397. 

  1397. 		'tableable',            # target supports tables
    1398. 

  1398. 		'imglinkable',          # target supports images as links
    1399. 

  1399. 		'imgalignable',         # target supports image alignment
    1400. 

  1400. 		'imgasdefterm',         # target supports image as definition term
    1401. 

  1401. 		'autonumberlist',       # target supports numbered lists natively
    1402. 

  1402. 		'autonumbertitle',      # target supports numbered titles natively
    1403. 

  1403. 		'stylable',             # target supports external style files
    1404. 

  1404. 		'parainsidelist',       # lists items supports paragraph
    1405. 

  1405. 		'compactlist',          # separate enclosing tags for compact lists
    1406. 

  1406. 		'spacedlistitem',       # lists support blank lines between items
    1407. 

  1407. 		'listnotnested',        # lists cannot be nested
    1408. 

  1408. 		'quotenotnested',       # quotes cannot be nested
    1409. 

  1409. 		'verbblocknotescaped',  # don't escape specials in verb block
    1410. 

  1410. 		'verbblockfinalescape', # do final escapes in verb block
    1411. 

  1411. 		'escapeurl',            # escape special in link URL
    1412. 

  1412. 		'labelbeforelink',      # label comes before the link on the tag
    1413. 

  1413. 		'onelinepara',          # dump paragraph as a single long line
    1414. 

  1414. 		'tabletitlerowinbold',  # manually bold any cell on table titles
    1415. 

  1415. 		'tablecellstrip',       # strip extra spaces from each table cell
    1416. 

  1416. 		'tablecellspannable',   # the table cells can have span attribute
    1417. 

  1417. 		'tablecellmulticol',    # separate open+close tags for multicol cells
    1418. 

  1418. 		'barinsidequote',       # bars are allowed inside quote blocks
    1419. 

  1419. 		'finalescapetitle',     # perform final escapes on title lines
    1420. 

  1420. 		'autotocnewpagebefore', # break page before automatic TOC
    1421. 

  1421. 		'autotocnewpageafter',  # break page after automatic TOC
    1422. 

  1422. 		'autotocwithbars',      # automatic TOC surrounded by bars
    1423. 

  1423. 		'mapbar2pagebreak',     # map the strong bar to a page break
    1424. 

  1424. 		'titleblocks',          # titles must be on open/close section blocks
    1425. 

  1425. 	
    1426. 

  1426. 		# Target code beautify (ON/OFF)
    1427. 

  1427. 		'indentverbblock',      # add leading spaces to verb block lines
    1428. 

  1428. 		'breaktablecell',       # break lines after any table cell
    1429. 

  1429. 		'breaktablelineopen',   # break line after opening table line
    1430. 

  1430. 		'notbreaklistopen',     # don't break line after opening a new list
    1431. 

  1431. 		'keepquoteindent',      # don't remove the leading TABs on quotes
    1432. 

  1432. 		'keeplistindent',       # don't remove the leading spaces on lists
    1433. 

  1433. 		'blankendautotoc',      # append a blank line at the auto TOC end
    1434. 

  1434. 		'tagnotindentable',     # tags must be placed at the line begining
    1435. 

  1435. 		'spacedlistitemopen',   # append a space after the list item open tag
    1436. 

  1436. 		'spacednumlistitemopen',# append a space after the numlist item open tag
    1437. 

  1437. 		'deflisttextstrip',     # strip the contents of the deflist text
    1438. 

  1438. 		'blanksaroundpara',     # put a blank line before and after paragraphs
    1439. 

  1439. 		'blanksaroundverb',     # put a blank line before and after verb blocks
    1440. 

  1440. 		'blanksaroundquote',    # put a blank line before and after quotes
    1441. 

  1441. 		'blanksaroundlist',     # put a blank line before and after lists
    1442. 

  1442. 		'blanksaroundnumlist',  # put a blank line before and after numlists
    1443. 

  1443. 		'blanksarounddeflist',  # put a blank line before and after deflists
    1444. 

  1444. 		'blanksaroundtable',    # put a blank line before and after tables
    1445. 

  1445. 		'blanksaroundbar',      # put a blank line before and after bars
    1446. 

  1446. 		'blanksaroundtitle',    # put a blank line before and after titles
    1447. 

  1447. 		'blanksaroundnumtitle', # put a blank line before and after numtitles
    1448. 

  1448. 	
    1449. 

  1449. 		# Value settings
    1450. 

  1450. 		'listmaxdepth',         # maximum depth for lists
    1451. 

  1451. 		'quotemaxdepth',        # maximum depth for quotes
    1452. 

  1452. 		'tablecellaligntype',   # type of table cell align: cell, column
    1453. 

  1453. 	]
    1454. 

  1454. 	
    1455. 

  1455. 	rules_bank = {
    1456. 

  1456. 		'txt': {
    1457. 

  1457. 			'indentverbblock':1,
    1458. 

  1458. 			'spacedlistitem':1,
    1459. 

  1459. 			'parainsidelist':1,
    1460. 

  1460. 			'keeplistindent':1,
    1461. 

  1461. 			'barinsidequote':1,
    1462. 

  1462. 			'autotocwithbars':1,
    1463. 

  1463. 

  1464. 			'blanksaroundpara':1,
    1465. 

  1465. 			'blanksaroundverb':1,
    1466. 

  1466. 			'blanksaroundquote':1,
    1467. 

  1467. 			'blanksaroundlist':1,
    1468. 

  1468. 			'blanksaroundnumlist':1,
    1469. 

  1469. 			'blanksarounddeflist':1,
    1470. 

  1470. 			'blanksaroundtable':1,
    1471. 

  1471. 			'blanksaroundbar':1,
    1472. 

  1472. 			'blanksaroundtitle':1,
    1473. 

  1473. 			'blanksaroundnumtitle':1,
    1474. 

  1474. 		},
    1475. 

  1475. 		'art': {
    1476. 

  1476. 			#TIP art inherits all TXT rules
    1477. 

  1477. 		},
    1478. 

  1478. 		'html': {
    1479. 

  1479. 			'indentverbblock':1,
    1480. 

  1480. 			'linkable':1,
    1481. 

  1481. 			'stylable':1,
    1482. 

  1482. 			'escapeurl':1,
    1483. 

  1483. 			'imglinkable':1,
    1484. 

  1484. 			'imgalignable':1,
    1485. 

  1485. 			'imgasdefterm':1,
    1486. 

  1486. 			'autonumberlist':1,
    1487. 

  1487. 			'spacedlistitem':1,
    1488. 

  1488. 			'parainsidelist':1,
    1489. 

  1489. 			'tableable':1,
    1490. 

  1490. 			'tablecellstrip':1,
    1491. 

  1491. 			'breaktablecell':1,
    1492. 

  1492. 			'breaktablelineopen':1,
    1493. 

  1493. 			'keeplistindent':1,
    1494. 

  1494. 			'keepquoteindent':1,
    1495. 

  1495. 			'barinsidequote':1,
    1496. 

  1496. 			'autotocwithbars':1,
    1497. 

  1497. 			'tablecellspannable':1,
    1498. 

  1498. 			'tablecellaligntype':'cell',
    1499. 

  1499. 

  1500. 			# 'blanksaroundpara':1,
    1501. 

  1501. 			'blanksaroundverb':1,
    1502. 

  1502. 			# 'blanksaroundquote':1,
    1503. 

  1503. 			'blanksaroundlist':1,
    1504. 

  1504. 			'blanksaroundnumlist':1,
    1505. 

  1505. 			'blanksarounddeflist':1,
    1506. 

  1506. 			'blanksaroundtable':1,
    1507. 

  1507. 			'blanksaroundbar':1,
    1508. 

  1508. 			'blanksaroundtitle':1,
    1509. 

  1509. 			'blanksaroundnumtitle':1,
    1510. 

  1510. 		},
    1511. 

  1511. 		'xhtml': {
    1512. 

  1512. 			#TIP xhtml inherits all HTML rules
    1513. 

  1513. 		},
    1514. 

  1514. 		'sgml': {
    1515. 

  1515. 			'linkable':1,
    1516. 

  1516. 			'escapeurl':1,
    1517. 

  1517. 			'autonumberlist':1,
    1518. 

  1518. 			'spacedlistitem':1,
    1519. 

  1519. 			'tableable':1,
    1520. 

  1520. 			'tablecellstrip':1,
    1521. 

  1521. 			'blankendautotoc':1,
    1522. 

  1522. 			'quotenotnested':1,
    1523. 

  1523. 			'keeplistindent':1,
    1524. 

  1524. 			'keepquoteindent':1,
    1525. 

  1525. 			'barinsidequote':1,
    1526. 

  1526. 			'finalescapetitle':1,
    1527. 

  1527. 			'tablecellaligntype':'column',
    1528. 

  1528. 

  1529. 			'blanksaroundpara':1,
    1530. 

  1530. 			'blanksaroundverb':1,
    1531. 

  1531. 			'blanksaroundquote':1,
    1532. 

  1532. 			'blanksaroundlist':1,
    1533. 

  1533. 			'blanksaroundnumlist':1,
    1534. 

  1534. 			'blanksarounddeflist':1,
    1535. 

  1535. 			'blanksaroundtable':1,
    1536. 

  1536. 			'blanksaroundbar':1,
    1537. 

  1537. 			'blanksaroundtitle':1,
    1538. 

  1538. 			'blanksaroundnumtitle':1,
    1539. 

  1539. 		},
    1540. 

  1540. 		'dbk': {
    1541. 

  1541. 			'linkable':1,
    1542. 

  1542. 			'tableable':1,
    1543. 

  1543. 			'imglinkable':1,
    1544. 

  1544. 			'imgalignable':1,
    1545. 

  1545. 			'imgasdefterm':1,
    1546. 

  1546. 			'autonumberlist':1,
    1547. 

  1547. 			'autonumbertitle':1,
    1548. 

  1548. 			'parainsidelist':1,
    1549. 

  1549. 			'spacedlistitem':1,
    1550. 

  1550. 			'titleblocks':1,
    1551. 

  1551. 		},
    1552. 

  1552. 		'mgp': {
    1553. 

  1553. 			'tagnotindentable':1,
    1554. 

  1554. 			'spacedlistitem':1,
    1555. 

  1555. 			'imgalignable':1,
    1556. 

  1556. 			'autotocnewpagebefore':1,
    1557. 

  1557. 

  1558. 			'blanksaroundpara':1,
    1559. 

  1559. 			'blanksaroundverb':1,
    1560. 

  1560. 			# 'blanksaroundquote':1,
    1561. 

  1561. 			'blanksaroundlist':1,
    1562. 

  1562. 			'blanksaroundnumlist':1,
    1563. 

  1563. 			'blanksarounddeflist':1,
    1564. 

  1564. 			'blanksaroundtable':1,
    1565. 

  1565. 			'blanksaroundbar':1,
    1566. 

  1566. 			# 'blanksaroundtitle':1,
    1567. 

  1567. 			# 'blanksaroundnumtitle':1,
    1568. 

  1568. 		},
    1569. 

  1569. 		'tex': {
    1570. 

  1570. 			'stylable':1,
    1571. 

  1571. 			'escapeurl':1,
    1572. 

  1572. 			'autonumberlist':1,
    1573. 

  1573. 			'autonumbertitle':1,
    1574. 

  1574. 			'spacedlistitem':1,
    1575. 

  1575. 			'compactlist':1,
    1576. 

  1576. 			'parainsidelist':1,
    1577. 

  1577. 			'tableable':1,
    1578. 

  1578. 			'tablecellstrip':1,
    1579. 

  1579. 			'tabletitlerowinbold':1,
    1580. 

  1580. 			'verbblocknotescaped':1,
    1581. 

  1581. 			'keeplistindent':1,
    1582. 

  1582. 			'listmaxdepth':4,  # deflist is 6
    1583. 

  1583. 			'quotemaxdepth':6,
    1584. 

  1584. 			'barinsidequote':1,
    1585. 

  1585. 			'finalescapetitle':1,
    1586. 

  1586. 			'autotocnewpageafter':1,
    1587. 

  1587. 			'mapbar2pagebreak':1,
    1588. 

  1588. 			'tablecellaligntype':'column',
    1589. 

  1589. 			'tablecellmulticol':1,
    1590. 

  1590. 

  1591. 			'blanksaroundpara':1,
    1592. 

  1592. 			'blanksaroundverb':1,
    1593. 

  1593. 			# 'blanksaroundquote':1,
    1594. 

  1594. 			'blanksaroundlist':1,
    1595. 

  1595. 			'blanksaroundnumlist':1,
    1596. 

  1596. 			'blanksarounddeflist':1,
    1597. 

  1597. 			'blanksaroundtable':1,
    1598. 

  1598. 			'blanksaroundbar':1,
    1599. 

  1599. 			'blanksaroundtitle':1,
    1600. 

  1600. 			'blanksaroundnumtitle':1,
    1601. 

  1601. 		},
    1602. 

  1602. 		'lout': {
    1603. 

  1603. 			'keepquoteindent':1,
    1604. 

  1604. 			'deflisttextstrip':1,
    1605. 

  1605. 			'escapeurl':1,
    1606. 

  1606. 			'verbblocknotescaped':1,
    1607. 

  1607. 			'imgalignable':1,
    1608. 

  1608. 			'mapbar2pagebreak':1,
    1609. 

  1609. 			'titleblocks':1,
    1610. 

  1610. 			'autonumberlist':1,
    1611. 

  1611. 			'parainsidelist':1,
    1612. 

  1612. 

  1613. 			'blanksaroundpara':1,
    1614. 

  1614. 			'blanksaroundverb':1,
    1615. 

  1615. 			# 'blanksaroundquote':1,
    1616. 

  1616. 			'blanksaroundlist':1,
    1617. 

  1617. 			'blanksaroundnumlist':1,
    1618. 

  1618. 			'blanksarounddeflist':1,
    1619. 

  1619. 			'blanksaroundtable':1,
    1620. 

  1620. 			'blanksaroundbar':1,
    1621. 

  1621. 			'blanksaroundtitle':1,
    1622. 

  1622. 			'blanksaroundnumtitle':1,	
    1623. 

  1623. 		},
    1624. 

  1624. 		'moin': {
    1625. 

  1625. 			'spacedlistitem':1,
    1626. 

  1626. 			'linkable':1,
    1627. 

  1627. 			'keeplistindent':1,
    1628. 

  1628. 			'tableable':1,
    1629. 

  1629. 			'barinsidequote':1,
    1630. 

  1630. 			'tabletitlerowinbold':1,
    1631. 

  1631. 			'tablecellstrip':1,
    1632. 

  1632. 			'autotocwithbars':1,
    1633. 

  1633. 			'tablecellaligntype':'cell',
    1634. 

  1634. 			'deflisttextstrip':1,
    1635. 

  1635. 

  1636. 			'blanksaroundpara':1,
    1637. 

  1637. 			'blanksaroundverb':1,
    1638. 

  1638. 			# 'blanksaroundquote':1,
    1639. 

  1639. 			'blanksaroundlist':1,
    1640. 

  1640. 			'blanksaroundnumlist':1,
    1641. 

  1641. 			'blanksarounddeflist':1,
    1642. 

  1642. 			'blanksaroundtable':1,
    1643. 

  1643. 			# 'blanksaroundbar':1,
    1644. 

  1644. 			'blanksaroundtitle':1,
    1645. 

  1645. 			'blanksaroundnumtitle':1,
    1646. 

  1646. 		},
    1647. 

  1647. 		'gwiki': {
    1648. 

  1648. 			'spacedlistitem':1,
    1649. 

  1649. 			'linkable':1,
    1650. 

  1650. 			'keeplistindent':1,
    1651. 

  1651. 			'tableable':1,
    1652. 

  1652. 			'tabletitlerowinbold':1,
    1653. 

  1653. 			'tablecellstrip':1,
    1654. 

  1654. 			'autonumberlist':1,
    1655. 

  1655. 

  1656. 			'blanksaroundpara':1,
    1657. 

  1657. 			'blanksaroundverb':1,
    1658. 

  1658. 			# 'blanksaroundquote':1,
    1659. 

  1659. 			'blanksaroundlist':1,
    1660. 

  1660. 			'blanksaroundnumlist':1,
    1661. 

  1661. 			'blanksarounddeflist':1,
    1662. 

  1662. 			'blanksaroundtable':1,
    1663. 

  1663. 			# 'blanksaroundbar':1,
    1664. 

  1664. 			'blanksaroundtitle':1,
    1665. 

  1665. 			'blanksaroundnumtitle':1,
    1666. 

  1666. 		},
    1667. 

  1667. 		'adoc': {
    1668. 

  1668. 			'spacedlistitem':1,
    1669. 

  1669. 			'linkable':1,
    1670. 

  1670. 			'keeplistindent':1,
    1671. 

  1671. 			'autonumberlist':1,
    1672. 

  1672. 			'autonumbertitle':1,
    1673. 

  1673. 			'listnotnested':1,
    1674. 

  1674. 			'blanksaroundpara':1,
    1675. 

  1675. 			'blanksaroundverb':1,
    1676. 

  1676. 			'blanksaroundlist':1,
    1677. 

  1677. 			'blanksaroundnumlist':1,
    1678. 

  1678. 			'blanksarounddeflist':1,
    1679. 

  1679. 			'blanksaroundtable':1,
    1680. 

  1680. 			'blanksaroundtitle':1,
    1681. 

  1681. 			'blanksaroundnumtitle':1,
    1682. 

  1682. 		},
    1683. 

  1683. 		'doku': {
    1684. 

  1684. 			'indentverbblock':1, # DokuWiki uses '  ' to mark verb blocks
    1685. 

  1685. 			'spacedlistitem':1,
    1686. 

  1686. 			'linkable':1,
    1687. 

  1687. 			'keeplistindent':1,
    1688. 

  1688. 			'tableable':1,
    1689. 

  1689. 			'barinsidequote':1,
    1690. 

  1690. 			'tablecellstrip':1,
    1691. 

  1691. 			'autotocwithbars':1,
    1692. 

  1692. 			'autonumberlist':1,
    1693. 

  1693. 			'imgalignable':1,
    1694. 

  1694. 			'tablecellaligntype':'cell',
    1695. 

  1695. 

  1696. 			'blanksaroundpara':1,
    1697. 

  1697. 			'blanksaroundverb':1,
    1698. 

  1698. 			# 'blanksaroundquote':1,
    1699. 

  1699. 			'blanksaroundlist':1,
    1700. 

  1700. 			'blanksaroundnumlist':1,
    1701. 

  1701. 			'blanksarounddeflist':1,
    1702. 

  1702. 			'blanksaroundtable':1,
    1703. 

  1703. 			'blanksaroundbar':1,
    1704. 

  1704. 			'blanksaroundtitle':1,
    1705. 

  1705. 			'blanksaroundnumtitle':1,
    1706. 

  1706. 		},
    1707. 

  1707. 		'pmw': {
    1708. 

  1708. 			'indentverbblock':1, 
    1709. 

  1709. 			'spacedlistitem':1,
    1710. 

  1710. 			'linkable':1,
    1711. 

  1711. 			'labelbeforelink':1,
    1712. 

  1712. 			'keeplistindent':1,
    1713. 

  1713. 			'tableable':1,
    1714. 

  1714. 			'barinsidequote':1,
    1715. 

  1715. 			'tablecellstrip':1,
    1716. 

  1716. 			'autotocwithbars':1,
    1717. 

  1717. 			'autonumberlist':1,
    1718. 

  1718. 			'imgalignable':1,
    1719. 

  1719. 			'tabletitlerowinbold':1,
    1720. 

  1720. 			'tablecellaligntype':'cell',
    1721. 

  1721. 

  1722. 			'blanksaroundpara':1,
    1723. 

  1723. 			'blanksaroundverb':1,
    1724. 

  1724. 			'blanksaroundquote':1,
    1725. 

  1725. 			'blanksaroundlist':1,
    1726. 

  1726. 			'blanksaroundnumlist':1,
    1727. 

  1727. 			'blanksarounddeflist':1,
    1728. 

  1728. 			'blanksaroundtable':1,
    1729. 

  1729. 			'blanksaroundbar':1,
    1730. 

  1730. 			'blanksaroundtitle':1,
    1731. 

  1731. 			'blanksaroundnumtitle':1,
    1732. 

  1732. 		},
    1733. 

  1733. 		'wiki': {
    1734. 

  1734. 			'linkable':1,
    1735. 

  1735. 			'tableable':1,
    1736. 

  1736. 			'tablecellstrip':1,
    1737. 

  1737. 			'autotocwithbars':1,
    1738. 

  1738. 			'spacedlistitemopen':1,
    1739. 

  1739. 			'spacednumlistitemopen':1,
    1740. 

  1740. 			'deflisttextstrip':1,
    1741. 

  1741. 			'autonumberlist':1,
    1742. 

  1742. 			'imgalignable':1,
    1743. 

  1743. 

  1744. 			'blanksaroundpara':1,
    1745. 

  1745. 			'blanksaroundverb':1,
    1746. 

  1746. 			# 'blanksaroundquote':1,
    1747. 

  1747. 			'blanksaroundlist':1,
    1748. 

  1748. 			'blanksaroundnumlist':1,
    1749. 

  1749. 			'blanksarounddeflist':1,
    1750. 

  1750. 			'blanksaroundtable':1,
    1751. 

  1751. 			'blanksaroundbar':1,
    1752. 

  1752. 			'blanksaroundtitle':1,
    1753. 

  1753. 			'blanksaroundnumtitle':1,
    1754. 

  1754. 		},
    1755. 

  1755. 		'man': {
    1756. 

  1756. 			'spacedlistitem':1,
    1757. 

  1757. 			'indentverbblock':1,
    1758. 

  1758. 			'tagnotindentable':1,
    1759. 

  1759. 			'tableable':1,
    1760. 

  1760. 			'tablecellaligntype':'column',
    1761. 

  1761. 			'tabletitlerowinbold':1,
    1762. 

  1762. 			'tablecellstrip':1,
    1763. 

  1763. 			'barinsidequote':1,
    1764. 

  1764. 			'parainsidelist':0,
    1765. 

  1765. 

  1766. 			'blanksaroundpara':1,
    1767. 

  1767. 			'blanksaroundverb':1,
    1768. 

  1768. 			# 'blanksaroundquote':1,
    1769. 

  1769. 			'blanksaroundlist':1,
    1770. 

  1770. 			'blanksaroundnumlist':1,
    1771. 

  1771. 			'blanksarounddeflist':1,
    1772. 

  1772. 			'blanksaroundtable':1,
    1773. 

  1773. 			# 'blanksaroundbar':1,
    1774. 

  1774. 			'blanksaroundtitle':1,
    1775. 

  1775. 			'blanksaroundnumtitle':1,
    1776. 

  1776. 		},
    1777. 

  1777. 		'pm6': {
    1778. 

  1778. 			'keeplistindent':1,
    1779. 

  1779. 			'verbblockfinalescape':1,
    1780. 

  1780. 			#TODO add support for these
    1781. 

  1781. 			# maybe set a JOINNEXT char and do it on addLineBreaks()
    1782. 

  1782. 			'notbreaklistopen':1,
    1783. 

  1783. 			'barinsidequote':1,
    1784. 

  1784. 			'autotocwithbars':1,
    1785. 

  1785. 			'onelinepara':1,
    1786. 

  1786. 

  1787. 			'blanksaroundpara':1,
    1788. 

  1788. 			'blanksaroundverb':1,
    1789. 

  1789. 			# 'blanksaroundquote':1,
    1790. 

  1790. 			'blanksaroundlist':1,
    1791. 

  1791. 			'blanksaroundnumlist':1,
    1792. 

  1792. 			'blanksarounddeflist':1,
    1793. 

  1793. 			# 'blanksaroundtable':1,
    1794. 

  1794. 			# 'blanksaroundbar':1,
    1795. 

  1795. 			'blanksaroundtitle':1,
    1796. 

  1796. 			'blanksaroundnumtitle':1,
    1797. 

  1797. 		}
    1798. 

  1798. 	}
    1799. 

  1799. 	
    1800. 

  1800. 	# Exceptions for --css-sugar
    1801. 

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

  1802. 		rules_bank['html']['indentverbblock'] = 0
    1803. 

  1803. 		rules_bank['html']['autotocwithbars'] = 0
    1804. 

  1804. 	
    1805. 

  1805. 	# Get the target specific rules
    1806. 

  1806. 	if config['target'] == 'xhtml':
    1807. 

  1807. 		myrules = rules_bank['html'].copy()   # inheritance
    1808. 

  1808. 		myrules.update(rules_bank['xhtml'])   # get XHTML specific
    1809. 

  1809. 	elif config['target'] == 'art':
    1810. 

  1810. 		myrules = rules_bank['txt'].copy()    # inheritance
    1811. 

  1811. 	else:
    1812. 

  1812. 		myrules = rules_bank[config['target']].copy()
    1813. 

  1813. 	
    1814. 

  1814. 	# Populate return dictionary
    1815. 

  1815. 	for key in allrules: ret[key] = 0        # reset all
    1816. 

  1816. 	ret.update(myrules)                      # get rules
    1817. 

  1817. 	
    1818. 

  1818. 	return ret
    1819. 

  1819. 

  1820. 

  1821. ##############################################################################
    1822. 

  1822. 

  1823. 

  1824. def getRegexes():
    1825. 

  1825. 	"Returns all the regexes used to find the t2t marks"
    1826. 

  1826. 	
    1827. 

  1827. 	bank = {
    1828. 

  1828. 	'blockVerbOpen':
    1829. 

  1829. 		re.compile(r'^```\s*$'),
    1830. 

  1830. 	'blockVerbClose':
    1831. 

  1831. 		re.compile(r'^```\s*$'),
    1832. 

  1832. 	'blockRawOpen':
    1833. 

  1833. 		re.compile(r'^"""\s*$'),
    1834. 

  1834. 	'blockRawClose':
    1835. 

  1835. 		re.compile(r'^"""\s*$'),
    1836. 

  1836. 	'blockTaggedOpen':
    1837. 

  1837. 		re.compile(r"^'''\s*$"),
    1838. 

  1838. 	'blockTaggedClose':
    1839. 

  1839. 		re.compile(r"^'''\s*$"),
    1840. 

  1840. 	'blockCommentOpen':
    1841. 

  1841. 		re.compile(r'^%%%\s*$'),
    1842. 

  1842. 	'blockCommentClose':
    1843. 

  1843. 		re.compile(r'^%%%\s*$'),
    1844. 

  1844. 	'quote':
    1845. 

  1845. 		re.compile(r'^\t+'),
    1846. 

  1846. 	'1lineVerb':
    1847. 

  1847. 		re.compile(r'^``` (?=.)'),
    1848. 

  1848. 	'1lineRaw':
    1849. 

  1849. 		re.compile(r'^""" (?=.)'),
    1850. 

  1850. 	'1lineTagged':
    1851. 

  1851. 		re.compile(r"^''' (?=.)"),
    1852. 

  1852. 	# mono, raw, bold, italic, underline:
    1853. 

  1853. 	# - marks must be glued with the contents, no boundary spaces
    1854. 

  1854. 	# - they are greedy, so in ****bold****, turns to <b>**bold**</b>
    1855. 

  1855. 	'fontMono':
    1856. 

  1856. 		re.compile(  r'``([^\s](|.*?[^\s])`*)``'),
    1857. 

  1857. 	'raw':
    1858. 

  1858. 		re.compile(  r'""([^\s](|.*?[^\s])"*)""'),
    1859. 

  1859. 	'tagged':
    1860. 

  1860. 		re.compile(  r"''([^\s](|.*?[^\s])'*)''"),
    1861. 

  1861. 	'fontBold':
    1862. 

  1862. 		re.compile(r'\*\*([^\s](|.*?[^\s])\**)\*\*'),
    1863. 

  1863. 	'fontItalic':
    1864. 

  1864. 		re.compile(  r'//([^\s](|.*?[^\s])/*)//'),
    1865. 

  1865. 	'fontUnderline':
    1866. 

  1866. 		re.compile(  r'__([^\s](|.*?[^\s])_*)__'),
    1867. 

  1867. 	'fontStrike':
    1868. 

  1868. 		re.compile(  r'--([^\s](|.*?[^\s])-*)--'),
    1869. 

  1869. 	'list':
    1870. 

  1870. 		re.compile(r'^( *)(-) (?=[^ ])'),
    1871. 

  1871. 	'numlist':
    1872. 

  1872. 		re.compile(r'^( *)(\+) (?=[^ ])'),
    1873. 

  1873. 	'deflist':
    1874. 

  1874. 		re.compile(r'^( *)(:) (.*)$'),
    1875. 

  1875. 	'listclose':
    1876. 

  1876. 		re.compile(r'^( *)([-+:])\s*$'),
    1877. 

  1877. 	'bar':
    1878. 

  1878. 		re.compile(r'^(\s*)([_=-]{20,})\s*$'),
    1879. 

  1879. 	'table':
    1880. 

  1880. 		re.compile(r'^ *\|\|? '),
    1881. 

  1881. 	'blankline':
    1882. 

  1882. 		re.compile(r'^\s*$'),
    1883. 

  1883. 	'comment':
    1884. 

  1884. 		re.compile(r'^%'),
    1885. 

  1885. 	
    1886. 

  1886. 	# Auxiliary tag regexes
    1887. 

  1887. 	'_imgAlign'        : re.compile(r'~A~', re.I),
    1888. 

  1888. 	'_tableAlign'      : re.compile(r'~A~', re.I),
    1889. 

  1889. 	'_anchor'          : re.compile(r'~A~', re.I),
    1890. 

  1890. 	'_tableBorder'     : re.compile(r'~B~', re.I),
    1891. 

  1891. 	'_tableColAlign'   : re.compile(r'~C~', re.I),
    1892. 

  1892. 	'_tableCellColSpan': re.compile(r'~S~', re.I),
    1893. 

  1893. 	'_tableCellAlign'  : re.compile(r'~A~', re.I),
    1894. 

  1894. 	}
    1895. 

  1895. 	
    1896. 

  1896. 	# Special char to place data on TAGs contents  (\a == bell)
    1897. 

  1897. 	bank['x'] = re.compile('\a')
    1898. 

  1898. 	
    1899. 

  1899. 	# %%macroname [ (formatting) ]
    1900. 

  1900. 	bank['macros'] = re.compile(r'%%%%(?P<name>%s)\b(\((?P<fmt>.*?)\))?' % (
    1901. 

  1901. 		'|'.join(MACROS.keys())), re.I)
    1902. 

  1902. 	
    1903. 

  1903. 	# %%TOC special macro for TOC positioning
    1904. 

  1904. 	bank['toc'] = re.compile(r'^ *%%toc\s*$', re.I)
    1905. 

  1905. 	
    1906. 

  1906. 	# Almost complicated title regexes ;)
    1907. 

  1907. 	titskel = r'^ *(?P<id>%s)(?P<txt>%s)\1(\[(?P<label>[\w-]*)\])?\s*$'
    1908. 

  1908. 	bank[   'title'] = re.compile(titskel%('[=]{1,5}','[^=](|.*[^=])'))
    1909. 

  1909. 	bank['numtitle'] = re.compile(titskel%('[+]{1,5}','[^+](|.*[^+])'))
    1910. 

  1910. 	
    1911. 

  1911. 	### Complicated regexes begin here ;)
    1912. 

  1912. 	#
    1913. 

  1913. 	# Textual descriptions on --help's style: [...] is optional, | is OR
    1914. 

  1914. 	
    1915. 

  1915. 	
    1916. 

  1916. 	### First, some auxiliary variables
    1917. 

  1917. 	#
    1918. 

  1918. 	
    1919. 

  1919. 	# [image.EXT]
    1920. 

  1920. 	patt_img = r'\[([\w_,.+%$#@!?+~/-]+\.(png|jpe?g|gif|eps|bmp))\]'
    1921. 

  1921. 	
    1922. 

  1922. 	# Link things
    1923. 

  1923. 	# http://www.gbiv.com/protocols/uri/rfc/rfc3986.html
    1924. 

  1924. 	# pchar: A-Za-z._~- / %FF / !$&'()*+,;= / :@
    1925. 

  1925. 	# Recomended order: scheme://user:pass@domain/path?query=foo#anchor
    1926. 

  1926. 	# Also works      : scheme://user:pass@domain/path#anchor?query=foo
    1927. 

  1927. 	# TODO form: !'():
    1928. 

  1928. 	urlskel = {
    1929. 

  1929. 		'proto' : r'(https?|ftp|news|telnet|gopher|wais)://',
    1930. 

  1930. 		'guess' : r'(www[23]?|ftp)\.',         # w/out proto, try to guess
    1931. 

  1931. 		'login' : r'A-Za-z0-9_.-',             # for ftp://login@domain.com
    1932. 

  1932. 		'pass'  : r'[^ @]*',                   # for ftp://login:pass@dom.com
    1933. 

  1933. 		'chars' : r'A-Za-z0-9%._/~:,=$@&+-',   # %20(space), :80(port), D&D
    1934. 

  1934. 		'anchor': r'A-Za-z0-9%._-',            # %nn(encoded)
    1935. 

  1935. 		'form'  : r'A-Za-z0-9/%&=+;.,$@*_-',   # .,@*_-(as is)
    1936. 

  1936. 		'punct' : r'.,;:!?'
    1937. 

  1937. 	}
    1938. 

  1938. 	
    1939. 

  1939. 	# username [ :password ] @
    1940. 

  1940. 	patt_url_login = r'([%s]+(:%s)?@)?'%(urlskel['login'],urlskel['pass'])
    1941. 

  1941. 	
    1942. 

  1942. 	# [ http:// ] [ username:password@ ] domain.com [ / ]
    1943. 

  1943. 	#     [ #anchor | ?form=data ]
    1944. 

  1944. 	retxt_url = r'\b(%s%s|%s)[%s]+\b/*(\?[%s]+)?(#[%s]*)?'%(
    1945. 

  1945. 		urlskel['proto'],patt_url_login, urlskel['guess'],
    1946. 

  1946. 		urlskel['chars'],urlskel['form'],urlskel['anchor'])
    1947. 

  1947. 	
    1948. 

  1948. 	# filename | [ filename ] #anchor
    1949. 

  1949. 	retxt_url_local = r'[%s]+|[%s]*(#[%s]*)'%(
    1950. 

  1950. 		urlskel['chars'],urlskel['chars'],urlskel['anchor'])
    1951. 

  1951. 	
    1952. 

  1952. 	# user@domain [ ?form=data ]
    1953. 

  1953. 	patt_email = r'\b[%s]+@([A-Za-z0-9_-]+\.)+[A-Za-z]{2,4}\b(\?[%s]+)?'%(
    1954. 

  1954. 		urlskel['login'],urlskel['form'])
    1955. 

  1955. 	
    1956. 

  1956. 	# Saving for future use
    1957. 

  1957. 	bank['_urlskel'] = urlskel
    1958. 

  1958. 	
    1959. 

  1959. 	### And now the real regexes
    1960. 

  1960. 	#
    1961. 

  1961. 	
    1962. 

  1962. 	bank['email'] = re.compile(patt_email,re.I)
    1963. 

  1963. 	
    1964. 

  1964. 	# email | url
    1965. 

  1965. 	bank['link'] = re.compile(r'%s|%s'%(retxt_url,patt_email), re.I)
    1966. 

  1966. 	
    1967. 

  1967. 	# \[ label | imagetag    url | email | filename \]
    1968. 

  1968. 	bank['linkmark'] = re.compile(
    1969. 

  1969. 		r'\[(?P<label>%s|[^]]+) (?P<link>%s|%s|%s)\]'%(
    1970. 

  1970. 			patt_img, retxt_url, patt_email, retxt_url_local),
    1971. 

  1971. 		re.L+re.I)
    1972. 

  1972. 	
    1973. 

  1973. 	# Image
    1974. 

  1974. 	bank['img'] = re.compile(patt_img, re.L+re.I)
    1975. 

  1975. 	
    1976. 

  1976. 	# Special things
    1977. 

  1977. 	bank['special'] = re.compile(r'^%!\s*')
    1978. 

  1978. 	return bank
    1979. 

  1979. ### END OF regex nightmares
    1980. 

  1980. 

  1981. ################# functions for the Ascii Art backend ########################
    1982. 

  1982. 

  1983. def aa_line(char):
    1984. 

  1984. 	return char*72 + LB
    1985. 

  1985. 

  1986. def aa_box(txt):
    1987. 

  1987. 	len_txt = len(txt)
    1988. 

  1988. 	nspace = (72-len_txt-4)/2
    1989. 

  1989. 	line_box = " "*nspace + AA_CHARS['coin'] + AA_CHARS['line']*(len_txt+2) + AA_CHARS['coin'] + LB
    1990. 

  1990. 	# <----- nspace " " -----> "+" <----- len_txt+2 "-" -----> "+" 
    1991. 

  1991. 	#                           +-------------------------------+
    1992. 

  1992. 	#                           | all theeeeeeeeeeeeeeeeee text |
    1993. 

  1993. 	# <----- nspace " " -----> "| " <--------- txt ---------> " |" 
    1994. 

  1994. 	line_txt = " "*nspace + AA_CHARS['border'] + ' ' + txt + ' ' + AA_CHARS['border'] + LB
    1995. 

  1995. 	return line_box + line_txt + line_box
    1996. 

  1996. 

  1997. def aa_header(header_data):
    1998. 

  1998. 	header= aa_line(AA_CHARS['bar2'])+\
    1999. 

  1999. 		LB+\
    2000. 

  2000. 		LB
    2001. 

  2001. 	for h in 'HEADER1', 'HEADER2', 'HEADER3' :
    2002. 

  2002. 		if header_data[h]: header +=\
    2003. 

  2003. 		aa_box(header_data[h])+\
    2004. 

  2004. 		LB+\
    2005. 

  2005. 		LB
    2006. 

  2006. 	header+=aa_line(AA_CHARS['bar2'])
    2007. 

  2007. 	return header
    2008. 

  2008. 

  2009. ##############################################################################
    2010. 

  2010. 

  2011. class error(Exception):
    2012. 

  2012. 	pass
    2013. 

  2013. def echo(msg):   # for quick debug
    2014. 

  2014. 	print '\033[32;1m%s\033[m'%msg
    2015. 

  2015. def Quit(msg=''):
    2016. 

  2016. 	if msg: print msg
    2017. 

  2017. 	sys.exit(0)
    2018. 

  2018. def Error(msg):
    2019. 

  2019. 	msg = _("%s: Error: ")%my_name + msg
    2020. 

  2020. 	raise error, msg
    2021. 

  2021. def getTraceback():
    2022. 

  2022. 	try:
    2023. 

  2023. 		from traceback import format_exception
    2024. 

  2024. 		etype, value, tb = sys.exc_info()
    2025. 

  2025. 		return ''.join(format_exception(etype, value, tb))
    2026. 

  2026. 	except: pass
    2027. 

  2027. def getUnknownErrorMessage():
    2028. 

  2028. 	msg = '%s\n%s (%s):\n\n%s'%(
    2029. 

  2029. 		_('Sorry! Txt2tags aborted by an unknown error.'),
    2030. 

  2030. 		_('Please send the following Error Traceback to the author'),
    2031. 

  2031. 		my_email, getTraceback())
    2032. 

  2032. 	return msg
    2033. 

  2033. def Message(msg,level):
    2034. 

  2034. 	if level <= VERBOSE and not QUIET:
    2035. 

  2035. 		prefix = '-'*5
    2036. 

  2036. 		print "%s %s"%(prefix*level, msg)
    2037. 

  2037. def Debug(msg,id=0,linenr=None):
    2038. 

  2038. 	"Show debug messages, categorized (colored or not)"
    2039. 

  2039. 	if QUIET or not DEBUG: return
    2040. 

  2040. 	if int(id) not in range(8): id = 0
    2041. 

  2041. 	# 0:black 1:red 2:green 3:yellow 4:blue 5:pink 6:cyan 7:white ;1:light
    2042. 

  2042. 	ids            = ['INI','CFG','SRC','BLK','HLD','GUI','OUT','DET']
    2043. 

  2043. 	colors_bgdark  = ['7;1','1;1','3;1','6;1','4;1','5;1','2;1','7;1']
    2044. 

  2044. 	colors_bglight = ['0'  ,'1'  ,'3'  ,'6'  ,'4'  ,'5'  ,'2'  ,'0'  ]
    2045. 

  2045. 	if linenr is not None: msg = "LINE %04d: %s"%(linenr,msg)
    2046. 

  2046. 	if COLOR_DEBUG:
    2047. 

  2047. 		if BG_LIGHT: color = colors_bglight[id]
    2048. 

  2048. 		else       : color = colors_bgdark[id]
    2049. 

  2049. 		msg = '\033[3%sm%s\033[m'%(color,msg)
    2050. 

  2050. 	print "++ %s: %s"%(ids[id],msg)
    2051. 

  2051. def Readfile(file, remove_linebreaks=0, ignore_error=0):
    2052. 

  2052. 	data = []
    2053. 

  2053. 	if file == '-':
    2054. 

  2054. 		try: data = sys.stdin.readlines()
    2055. 

  2055. 		except:
    2056. 

  2056. 			if not ignore_error:
    2057. 

  2057. 				Error(_('You must feed me with data on STDIN!'))
    2058. 

  2058. 	else:
    2059. 

  2059. 		try: f = open(file); data = f.readlines() ; f.close()
    2060. 

  2060. 		except:
    2061. 

  2061. 			if not ignore_error:
    2062. 

  2062. 				Error(_("Cannot read file:")+" %s"%file)
    2063. 

  2063. 	if remove_linebreaks:
    2064. 

  2064. 		data = map(lambda x:re.sub('[\n\r]+$','',x), data)
    2065. 

  2065. 	Message(_("File read (%d lines): %s")%(len(data),file),2)
    2066. 

  2066. 	return data
    2067. 

  2067. def Savefile(file, contents):
    2068. 

  2068. 	try: f = open(file, 'wb')
    2069. 

  2069. 	except: Error(_("Cannot open file for writing:")+" %s"%file)
    2070. 

  2070. 	if type(contents) == type([]): doit = f.writelines
    2071. 

  2071. 	else: doit = f.write
    2072. 

  2072. 	doit(contents) ; f.close()
    2073. 

  2073. 

  2074. def showdic(dic):
    2075. 

  2075. 	for k in dic.keys(): print "%15s : %s" % (k,dic[k])
    2076. 

  2076. def dotted_spaces(txt=''):
    2077. 

  2077. 	return txt.replace(' ', '.')
    2078. 

  2078. 

  2079. # TIP: win env vars http://www.winnetmag.com/Article/ArticleID/23873/23873.html
    2080. 

  2080. def get_rc_path():
    2081. 

  2081. 	"Return the full path for the users' RC file"
    2082. 

  2082. 	# Try to get the path from an env var. if yes, we're done
    2083. 

  2083. 	user_defined = os.environ.get('T2TCONFIG')
    2084. 

  2084. 	if user_defined: return user_defined
    2085. 

  2085. 	# Env var not found, so perform automatic path composing
    2086. 

  2086. 	# Set default filename according system platform
    2087. 

  2087. 	rc_names = {'default':'.txt2tagsrc', 'win':'_t2trc'}
    2088. 

  2088. 	rc_file = rc_names.get(sys.platform[:3]) or rc_names['default']
    2089. 

  2089. 	# The file must be on the user directory, but where is this dir?
    2090. 

  2090. 	rc_dir_search = ['HOME', 'HOMEPATH']
    2091. 

  2091. 	for var in rc_dir_search:
    2092. 

  2092. 		rc_dir = os.environ.get(var)
    2093. 

  2093. 		if rc_dir: break
    2094. 

  2094. 	# rc dir found, now we must join dir+file to compose the full path
    2095. 

  2095. 	if rc_dir:
    2096. 

  2096. 		# Compose path and return it if the file exists
    2097. 

  2097. 		rc_path = os.path.join(rc_dir, rc_file)
    2098. 

  2098. 		# On windows, prefix with the drive (%homedrive%: 2k/XP/NT)
    2099. 

  2099. 		if sys.platform.startswith('win'):
    2100. 

  2100. 			rc_drive = os.environ.get('HOMEDRIVE')
    2101. 

  2101. 			rc_path = os.path.join(rc_drive,rc_path)
    2102. 

  2102. 		return rc_path
    2103. 

  2103. 	# Sorry, not found
    2104. 

  2104. 	return ''
    2105. 

  2105. 

  2106. 

  2107. 

  2108. ##############################################################################
    2109. 

  2109. 

  2110. class CommandLine:
    2111. 

  2111. 	"""
    2112. 

  2112. 	Command Line class - Masters command line
    2113. 

  2113. 

  2114. 	This class checks and extract data from the provided command line.
    2115. 

  2115. 	The --long options and flags are taken from the global OPTIONS,
    2116. 

  2116. 	FLAGS and ACTIONS dictionaries. The short options are registered
    2117. 

  2117. 	here, and also their equivalence to the long ones.
    2118. 

  2118. 

  2119. 	_compose_short_opts() -> str
    2120. 

  2120. 	_compose_long_opts() -> list
    2121. 

  2121. 		Compose the valid short and long options list, on the
    2122. 

  2122. 		'getopt' format.
    2123. 

  2123. 

  2124. 	parse() -> (opts, args)
    2125. 

  2125. 		Call getopt to check and parse the command line.
    2126. 

  2126. 		It expects to receive the command line as a list, and
    2127. 

  2127. 		without the program name (sys.argv[1:]).
    2128. 

  2128. 

  2129. 	get_raw_config() -> [RAW config]
    2130. 

  2130. 		Scans command line and convert the data to the RAW config
    2131. 

  2131. 		format. See ConfigMaster class to the RAW format description.
    2132. 

  2132. 		Optional 'ignore' and 'filter' arguments are used to filter
    2133. 

  2133. 		in or out specified keys.
    2134. 

  2134. 

  2135. 	compose_cmdline(dict) -> [Command line]
    2136. 

  2136. 		Compose a command line list from an already parsed config
    2137. 

  2137. 		dictionary, generated from RAW by ConfigMaster(). Use
    2138. 

  2138. 		this to compose an optimal command line for a group of
    2139. 

  2139. 		options.
    2140. 

  2140. 	
    2141. 

  2141. 	The get_raw_config() calls parse(), so the tipical use of this
    2142. 

  2142. 	class is:
    2143. 

  2143. 	
    2144. 

  2144.             raw = CommandLine().get_raw_config(sys.argv[1:])
    2145. 

  2145. 	"""
    2146. 

  2146. 	def __init__(self):
    2147. 

  2147. 		self.all_options = OPTIONS.keys()
    2148. 

  2148. 		self.all_flags   = FLAGS.keys()
    2149. 

  2149. 		self.all_actions = ACTIONS.keys()
    2150. 

  2150. 		
    2151. 

  2151. 		# short:long options equivalence
    2152. 

  2152. 		self.short_long = {
    2153. 

  2153. 			'a':'ascii-art',
    2154. 

  2154. 			'C':'config-file',
    2155. 

  2155. 			'h':'help',
    2156. 

  2156. 			'H':'no-headers',
    2157. 

  2157. 			'i':'infile',
    2158. 

  2158. 			'n':'enum-title',
    2159. 

  2159. 			'o':'outfile',
    2160. 

  2160. 			'q':'quiet',
    2161. 

  2161. 			't':'target',
    2162. 

  2162. 			'v':'verbose',
    2163. 

  2163. 			'V':'version',
    2164. 

  2164. 		}
    2165. 

  2165. 		
    2166. 

  2166. 		# Compose valid short and long options data for getopt
    2167. 

  2167. 		self.short_opts = self._compose_short_opts()
    2168. 

  2168. 		self.long_opts  = self._compose_long_opts()
    2169. 

  2169. 	
    2170. 

  2170. 	def _compose_short_opts(self):
    2171. 

  2171. 		"Returns a string like 'hVt:o' with all short options/flags"
    2172. 

  2172. 		ret = []
    2173. 

  2173. 		for opt in self.short_long.keys():
    2174. 

  2174. 			long = self.short_long[opt]
    2175. 

  2175. 			if long in self.all_options: # is flag or option?
    2176. 

  2176. 				opt = opt+':'        # option: have param
    2177. 

  2177. 			ret.append(opt)
    2178. 

  2178. 		#Debug('Valid SHORT options: %s'%ret)
    2179. 

  2179. 		return ''.join(ret)
    2180. 

  2180. 	
    2181. 

  2181. 	def _compose_long_opts(self):
    2182. 

  2182. 		"Returns a list with all the valid long options/flags"
    2183. 

  2183. 		ret = map(lambda x:x+'=', self.all_options)          # add =
    2184. 

  2184. 		ret.extend(self.all_flags)                           # flag ON
    2185. 

  2185. 		ret.extend(self.all_actions)                         # acts
    2186. 

  2186. 		ret.extend(map(lambda x:'no-'+x, self.all_flags))    # add no-*
    2187. 

  2187. 		ret.extend(['no-style','no-encoding'])               # turn OFF
    2188. 

  2188. 		ret.extend(['no-outfile','no-infile'])               # turn OFF
    2189. 

  2189. 		ret.extend(['no-dump-config', 'no-dump-source'])     # turn OFF
    2190. 

  2190. 		#Debug('Valid LONG options: %s'%ret)
    2191. 

  2191. 		return ret
    2192. 

  2192. 	
    2193. 

  2193. 	def _tokenize(self, cmd_string=''):
    2194. 

  2194. 		"Convert a command line string to a list"
    2195. 

  2195. 		#TODO protect quotes contents -- Don't use it, pass cmdline as list
    2196. 

  2196. 		return cmd_string.split()
    2197. 

  2197. 	
    2198. 

  2198. 	def parse(self, cmdline=[]):
    2199. 

  2199. 		"Check/Parse a command line list     TIP: no program name!"
    2200. 

  2200. 		# Get the valid options
    2201. 

  2201. 		short, long = self.short_opts, self.long_opts
    2202. 

  2202. 		# Parse it!
    2203. 

  2203. 		try:
    2204. 

  2204. 			opts, args = getopt.getopt(cmdline, short, long)
    2205. 

  2205. 		except getopt.error, errmsg:
    2206. 

  2206. 			Error(_("%s (try --help)")%errmsg)
    2207. 

  2207. 		return (opts, args)
    2208. 

  2208. 	
    2209. 

  2209. 	def get_raw_config(self, cmdline=[], ignore=[], filter=[], relative=0):
    2210. 

  2210. 		"Returns the options/arguments found as RAW config"
    2211. 

  2211. 		if not cmdline: return []
    2212. 

  2212. 		ret = []
    2213. 

  2213. 		# We need lists, not strings
    2214. 

  2214. 		if type(cmdline) in (type(''), type(u'')):
    2215. 

  2215. 			cmdline = self._tokenize(cmdline)
    2216. 

  2216. 		opts, args = self.parse(cmdline[:])
    2217. 

  2217. 		# Parse all options
    2218. 

  2218. 		for name,value in opts:
    2219. 

  2219. 			# Remove leading - and --
    2220. 

  2220. 			name = re.sub('^--?', '', name)
    2221. 

  2221. 			# Alias to old misspelled 'suGGar'
    2222. 

  2222. 			if   name ==    'css-suggar': name =    'css-sugar'
    2223. 

  2223. 			elif name == 'no-css-suggar': name = 'no-css-sugar'
    2224. 

  2224. 			# Translate short opt to long
    2225. 

  2225. 			if len(name) == 1: name = self.short_long.get(name)
    2226. 

  2226. 			# Outfile exception: path relative to PWD
    2227. 

  2227. 			if name == 'outfile' and relative \
    2228. 

  2228. 			   and value not in [STDOUT, MODULEOUT]:
    2229. 

  2229. 				value = os.path.abspath(value)
    2230. 

  2230. 			# config-file inclusion, path relative to PWD
    2231. 

  2231. 			if name == 'config-file':
    2232. 

  2232. 				configs = ConfigLines().include_config_file(value)
    2233. 

  2233. 				# Remove the 'target' item of all configs
    2234. 

  2234. 				configs = map(lambda c: [c[1],c[2]], configs)
    2235. 

  2235. 				ret.extend(configs)
    2236. 

  2236. 				continue
    2237. 

  2237. 			# Save it
    2238. 

  2238. 			ret.append([name, value])
    2239. 

  2239. 		# Get infile, if any
    2240. 

  2240. 		while args:
    2241. 

  2241. 			infile = args.pop(0)
    2242. 

  2242. 			ret.append(['infile', infile])
    2243. 

  2243. 		# Apply 'ignore' and 'filter' rules (filter is stronger)
    2244. 

  2244. 		temp = ret[:] ; ret = []
    2245. 

  2245. 		for name,value in temp:
    2246. 

  2246. 			if (not filter and not ignore) or \
    2247. 

  2247. 			   (filter and name in filter) or \
    2248. 

  2248. 			   (ignore and name not in ignore):
    2249. 

  2249. 				ret.append( ['all', name, value] )
    2250. 

  2250. 		# Add the original command line string as 'realcmdline'
    2251. 

  2251. 		ret.append( ['all', 'realcmdline', cmdline] )
    2252. 

  2252. 		return ret
    2253. 

  2253. 	
    2254. 

  2254. 	def compose_cmdline(self, conf={}, no_check=0):
    2255. 

  2255. 		"compose a full (and diet) command line from CONF dict"
    2256. 

  2256. 		if not conf: return []
    2257. 

  2257. 		args = []
    2258. 

  2258. 		dft_options = OPTIONS.copy()
    2259. 

  2259. 		cfg = conf.copy()
    2260. 

  2260. 		valid_opts = self.all_options + self.all_flags
    2261. 

  2261. 		use_short = {'no-headers':'H', 'enum-title':'n'}
    2262. 

  2262. 		# Remove useless options
    2263. 

  2263. 		if not no_check and cfg.get('toc-only'):
    2264. 

  2264. 			if cfg.has_key('no-headers'):
    2265. 

  2265. 				del cfg['no-headers']
    2266. 

  2266. 			if cfg.has_key('outfile'):
    2267. 

  2267. 				del cfg['outfile']      # defaults to STDOUT
    2268. 

  2268. 			if cfg.get('target') == 'txt':
    2269. 

  2269. 				del cfg['target']       # already default
    2270. 

  2270. 			args.append('--toc-only')  # must be the first
    2271. 

  2271. 			del cfg['toc-only']
    2272. 

  2272. 		# Add target type
    2273. 

  2273. 		if cfg.has_key('target'):
    2274. 

  2274. 			args.append('-t '+cfg['target'])
    2275. 

  2275. 			del cfg['target']
    2276. 

  2276. 		# Add other options
    2277. 

  2277. 		for key in cfg.keys():
    2278. 

  2278. 			if key not in valid_opts: continue  # may be a %!setting
    2279. 

  2279. 			if key == 'outfile' or key == 'infile': continue # later
    2280. 

  2280. 			val = cfg[key]
    2281. 

  2281. 			if not val: continue
    2282. 

  2282. 			# Default values are useless on cmdline
    2283. 

  2283. 			if val == dft_options.get(key): continue
    2284. 

  2284. 			# -short format
    2285. 

  2285. 			if key in use_short.keys():
    2286. 

  2286. 				args.append('-'+use_short[key])
    2287. 

  2287. 				continue
    2288. 

  2288. 			# --long format
    2289. 

  2289. 			if key in self.all_flags: # add --option
    2290. 

  2290. 				args.append('--'+key)
    2291. 

  2291. 			else:                     # add --option=value
    2292. 

  2292. 				args.append('--%s=%s'%(key,val))
    2293. 

  2293. 		# The outfile using -o
    2294. 

  2294. 		if cfg.has_key('outfile') and \
    2295. 

  2295. 		   cfg['outfile'] != dft_options.get('outfile'):
    2296. 

  2296. 			args.append('-o '+cfg['outfile'])
    2297. 

  2297. 		# Place input file(s) always at the end
    2298. 

  2298. 		if cfg.has_key('infile'):
    2299. 

  2299. 			args.append(' '.join(cfg['infile']))
    2300. 

  2300. 		# Return as a nice list
    2301. 

  2301. 		Debug("Diet command line: %s"%' '.join(args), 1)
    2302. 

  2302. 		return args
    2303. 

  2303. 

  2304. ##############################################################################
    2305. 

  2305. 

  2306. class SourceDocument:
    2307. 

  2307. 	"""
    2308. 

  2308. 	SourceDocument class - scan document structure, extract data
    2309. 

  2309. 	
    2310. 

  2310. 	It knows about full files. It reads a file and identify all
    2311. 

  2311. 	the areas begining (Head,Conf,Body). With this info it can
    2312. 

  2312. 	extract each area contents.
    2313. 

  2313. 	Note: the original line break is removed.
    2314. 

  2314. 	
    2315. 

  2315. 	DATA:
    2316. 

  2316. 	  self.arearef - Save Head, Conf, Body init line number
    2317. 

  2317. 	  self.areas   - Store the area names which are not empty
    2318. 

  2318. 	  self.buffer  - The full file contents (with NO \\r, \\n)
    2319. 

  2319. 

  2320. 	METHODS:
    2321. 

  2321. 	  get()   - Access the contents of an Area. Example:
    2322. 

  2322. 	            config = SourceDocument(file).get('conf')
    2323. 

  2323. 	
    2324. 

  2324. 	  split() - Get all the document Areas at once. Example:
    2325. 

  2325. 	            head, conf, body = SourceDocument(file).split()
    2326. 

  2326. 	
    2327. 

  2327. 	RULES:
    2328. 

  2328. 	    * The document parts are sequential: Head, Conf and Body.
    2329. 

  2329. 	    * One ends when the next begins.
    2330. 

  2330. 	    * The Conf Area is optional, so a document can have just
    2331. 

  2331. 	      Head and Body Areas.
    2332. 

  2332. 	
    2333. 

  2333. 	    These are the Areas limits:
    2334. 

  2334. 	      - Head Area: the first three lines
    2335. 

  2335. 	      - Body Area: from the first valid text line to the end
    2336. 

  2336. 	      - Conf Area: the comments between Head and Body Areas
    2337. 

  2337. 

  2338. 	    Exception: If the first line is blank, this means no
    2339. 

  2339. 	    header info, so the Head Area is just the first line.
    2340. 

  2340. 	"""
    2341. 

  2341. 	def __init__(self, filename='', contents=[]):
    2342. 

  2342. 		self.areas = ['head','conf','body']
    2343. 

  2343. 		self.arearef = []
    2344. 

  2344. 		self.areas_fancy = ''
    2345. 

  2345. 		self.filename = filename
    2346. 

  2346. 		self.buffer = []
    2347. 

  2347. 		if filename:
    2348. 

  2348. 			self.scan_file(filename)
    2349. 

  2349. 		elif contents:
    2350. 

  2350. 			self.scan(contents)
    2351. 

  2351. 	
    2352. 

  2352. 	def split(self):
    2353. 

  2353. 		"Returns all document parts, splitted into lists."
    2354. 

  2354. 		return self.get('head'), self.get('conf'), self.get('body')
    2355. 

  2355. 	
    2356. 

  2356. 	def get(self, areaname):
    2357. 

  2357. 		"Returns head|conf|body contents from self.buffer"
    2358. 

  2358. 		# Sanity
    2359. 

  2359. 		if areaname not in self.areas: return []
    2360. 

  2360. 		if not self.buffer           : return []
    2361. 

  2361. 		# Go get it
    2362. 

  2362. 		bufini = 1
    2363. 

  2363. 		bufend = len(self.buffer)
    2364. 

  2364. 		if   areaname == 'head':
    2365. 

  2365. 			ini = bufini
    2366. 

  2366. 			end = self.arearef[1] or self.arearef[2] or bufend
    2367. 

  2367. 		elif areaname == 'conf':
    2368. 

  2368. 			ini = self.arearef[1]
    2369. 

  2369. 			end = self.arearef[2] or bufend
    2370. 

  2370. 		elif areaname == 'body':
    2371. 

  2371. 			ini = self.arearef[2]
    2372. 

  2372. 			end = bufend
    2373. 

  2373. 		else:
    2374. 

  2374. 			Error("Unknown Area name '%s'"%areaname)
    2375. 

  2375. 		lines = self.buffer[ini:end]
    2376. 

  2376. 		# Make sure head will always have 3 lines
    2377. 

  2377. 		while areaname == 'head' and len(lines) < 3:
    2378. 

  2378. 			lines.append('')
    2379. 

  2379. 		return lines
    2380. 

  2380. 	
    2381. 

  2381. 	def scan_file(self, filename):
    2382. 

  2382. 		Debug("source file: %s"%filename)
    2383. 

  2383. 		Message(_("Loading source document"),1)
    2384. 

  2384. 		buf = Readfile(filename, remove_linebreaks=1)
    2385. 

  2385. 		self.scan(buf)
    2386. 

  2386. 	
    2387. 

  2387. 	def scan(self, lines):
    2388. 

  2388. 		"Run through source file and identify head/conf/body areas"
    2389. 

  2389. 		buf = lines
    2390. 

  2390. 		if len(buf) == 0:
    2391. 

  2391. 			Error(_('The input file is empty: %s')%self.filename)
    2392. 

  2392. 		cfg_parser = ConfigLines().parse_line
    2393. 

  2393. 		buf.insert(0, '')                         # text start at pos 1
    2394. 

  2394. 		ref = [1,4,0]
    2395. 

  2395. 		if not buf[1].strip():                    # no header
    2396. 

  2396. 			ref[0] = 0 ; ref[1] = 2
    2397. 

  2397. 		rgx = getRegexes()
    2398. 

  2398. 		on_comment_block = 0
    2399. 

  2399. 		for i in xrange(ref[1],len(buf)):         # find body init:
    2400. 

  2400. 			# Handle comment blocks inside config area
    2401. 

  2401. 			if not on_comment_block \
    2402. 

  2402. 			   and rgx['blockCommentOpen'].search(buf[i]):
    2403. 

  2403. 				on_comment_block = 1
    2404. 

  2404. 				continue
    2405. 

  2405. 			if on_comment_block \
    2406. 

  2406. 			   and rgx['blockCommentOpen'].search(buf[i]):
    2407. 

  2407. 				on_comment_block = 0
    2408. 

  2408. 				continue
    2409. 

  2409. 			if on_comment_block: continue
    2410. 

  2410. 			
    2411. 

  2411. 			if buf[i].strip() and (           # ... not blank and
    2412. 

  2412. 			   buf[i][0] != '%' or            # ... not comment or
    2413. 

  2413. 			   rgx['macros'].match(buf[i]) or # ... %%macro
    2414. 

  2414. 			   rgx['toc'].match(buf[i])    or # ... %%toc
    2415. 

  2415. 			   cfg_parser(buf[i],'include')[1]): # ... %!include
    2416. 

  2416. 				ref[2] = i ; break
    2417. 

  2417. 		if ref[1] == ref[2]: ref[1] = 0           # no conf area
    2418. 

  2418. 		for i in 0,1,2:                           # del !existent
    2419. 

  2419. 			if ref[i] >= len(buf): ref[i] = 0 # title-only
    2420. 

  2420. 			if not ref[i]: self.areas[i] = ''
    2421. 

  2421. 		Debug('Head,Conf,Body start line: %s'%ref)
    2422. 

  2422. 		self.arearef = ref                        # save results
    2423. 

  2423. 		self.buffer  = buf
    2424. 

  2424. 		# Fancyness sample: head conf body (1 4 8)
    2425. 

  2425. 		self.areas_fancy = "%s (%s)"%(
    2426. 

  2426. 			' '.join(self.areas),
    2427. 

  2427. 			' '.join(map(str, map(lambda x:x or '', ref))))
    2428. 

  2428. 		Message(_("Areas found: %s")%self.areas_fancy, 2)
    2429. 

  2429. 	
    2430. 

  2430. 	def get_raw_config(self):
    2431. 

  2431. 		"Handy method to get the CONF area RAW config (if any)"
    2432. 

  2432. 		if not self.areas.count('conf'): return []
    2433. 

  2433. 		Message(_("Scanning source document CONF area"),1)
    2434. 

  2434. 		raw = ConfigLines(
    2435. 

  2435. 			file=self.filename, lines=self.get('conf'),
    2436. 

  2436. 			first_line=self.arearef[1]).get_raw_config()
    2437. 

  2437. 		Debug("document raw config: %s"%raw, 1)
    2438. 

  2438. 		return raw
    2439. 

  2439. 

  2440. ##############################################################################
    2441. 

  2441. 

  2442. class ConfigMaster:
    2443. 

  2443. 	"""
    2444. 

  2444. 	ConfigMaster class - the configuration wizard
    2445. 

  2445. 	
    2446. 

  2446. 	This class is the configuration master. It knows how to handle
    2447. 

  2447. 	the RAW and PARSED config format. It also performs the sanity
    2448. 

  2448. 	checking for a given configuration.
    2449. 

  2449. 	
    2450. 

  2450. 	DATA:
    2451. 

  2451. 	  self.raw         - Stores the config on the RAW format
    2452. 

  2452. 	  self.parsed      - Stores the config on the PARSED format
    2453. 

  2453. 	  self.defaults    - Stores the default values for all keys
    2454. 

  2454. 	  self.off         - Stores the OFF values for all keys
    2455. 

  2455. 	  self.multi       - List of keys which can have multiple values
    2456. 

  2456. 	  self.numeric     - List of keys which value must be a number
    2457. 

  2457. 	  self.incremental - List of keys which are incremental
    2458. 

  2458. 	
    2459. 

  2459.         RAW FORMAT:
    2460. 

  2460. 	  The RAW format is a list of lists, being each mother list item
    2461. 

  2461. 	  a full configuration entry. Any entry is a 3 item list, on
    2462. 

  2462. 	  the following format: [ TARGET, KEY, VALUE ]
    2463. 

  2463. 	  Being a list, the order is preserved, so it's easy to use
    2464. 

  2464. 	  different kinds of configs, as CONF area and command line,
    2465. 

  2465. 	  respecting the precedence.
    2466. 

  2466. 	  The special target 'all' is used when no specific target was
    2467. 

  2467. 	  defined on the original config.
    2468. 

  2468. 	
    2469. 

  2469. 	PARSED FORMAT:
    2470. 

  2470. 	  The PARSED format is a dictionary, with all the 'key : value'
    2471. 

  2471. 	  found by reading the RAW config. The self.target contents
    2472. 

  2472. 	  matters, so this dictionary only contains the target's
    2473. 

  2473. 	  config. The configs of other targets are ignored.
    2474. 

  2474. 	
    2475. 

  2475. 	The CommandLine and ConfigLines classes have the get_raw_config()
    2476. 

  2476. 	method which convert the configuration found to the RAW format.
    2477. 

  2477. 	Just feed it to parse() and get a brand-new ready-to-use config
    2478. 

  2478. 	dictionary. Example:
    2479. 

  2479. 	
    2480. 

  2480. 	    >>> raw = CommandLine().get_raw_config(['-n', '-H'])
    2481. 

  2481. 	    >>> print raw
    2482. 

  2482. 	    [['all', 'enum-title', ''], ['all', 'no-headers', '']]
    2483. 

  2483. 	    >>> parsed = ConfigMaster(raw).parse()
    2484. 

  2484. 	    >>> print parsed
    2485. 

  2485. 	    {'enum-title': 1, 'headers': 0}
    2486. 

  2486. 	"""
    2487. 

  2487. 	def __init__(self, raw=[], target=''):
    2488. 

  2488. 		self.raw          = raw
    2489. 

  2489. 		self.target       = target
    2490. 

  2490. 		self.parsed       = {}
    2491. 

  2491. 		self.dft_options  = OPTIONS.copy()
    2492. 

  2492. 		self.dft_flags    = FLAGS.copy()
    2493. 

  2493. 		self.dft_actions  = ACTIONS.copy()
    2494. 

  2494. 		self.dft_settings = SETTINGS.copy()
    2495. 

  2495. 		self.defaults     = self._get_defaults()
    2496. 

  2496. 		self.off          = self._get_off()
    2497. 

  2497. 		self.incremental  = ['verbose']
    2498. 

  2498. 		self.numeric      = ['toc-level','split']
    2499. 

  2499. 		self.multi        = ['infile', 'preproc', 'postproc', 'options', 'style']
    2500. 

  2500. 	
    2501. 

  2501. 	def _get_defaults(self):
    2502. 

  2502. 		"Get the default values for all config/options/flags"
    2503. 

  2503. 		empty = {}
    2504. 

  2504. 		for kw in CONFIG_KEYWORDS: empty[kw] = ''
    2505. 

  2505. 		empty.update(self.dft_options)
    2506. 

  2506. 		empty.update(self.dft_flags)
    2507. 

  2507. 		empty.update(self.dft_actions)
    2508. 

  2508. 		empty.update(self.dft_settings)
    2509. 

  2509. 		empty['realcmdline'] = ''  # internal use only
    2510. 

  2510. 		empty['sourcefile']  = ''  # internal use only
    2511. 

  2511. 		return empty
    2512. 

  2512. 	
    2513. 

  2513. 	def _get_off(self):
    2514. 

  2514. 		"Turns OFF all the config/options/flags"
    2515. 

  2515. 		off = {}
    2516. 

  2516. 		for key in self.defaults.keys():
    2517. 

  2517. 			kind = type(self.defaults[key])
    2518. 

  2518. 			if kind == type(9):
    2519. 

  2519. 				off[key] = 0
    2520. 

  2520. 			elif kind == type('') or kind == type(u''):
    2521. 

  2521. 				off[key] = ''
    2522. 

  2522. 			elif kind == type([]):
    2523. 

  2523. 				off[key] = []
    2524. 

  2524. 			else:
    2525. 

  2525. 				Error('ConfigMaster: %s: Unknown type'+key)
    2526. 

  2526. 		return off
    2527. 

  2527. 	
    2528. 

  2528. 	def _check_target(self):
    2529. 

  2529. 		"Checks if the target is already defined. If not, do it"
    2530. 

  2530. 		if not self.target:
    2531. 

  2531. 			self.target = self.find_value('target')
    2532. 

  2532. 	
    2533. 

  2533. 	def get_target_raw(self):
    2534. 

  2534. 		"Returns the raw config for self.target or 'all'"
    2535. 

  2535. 		ret = []
    2536. 

  2536. 		self._check_target()
    2537. 

  2537. 		for entry in self.raw:
    2538. 

  2538. 			if entry[0] == self.target or entry[0] == 'all':
    2539. 

  2539. 				ret.append(entry)
    2540. 

  2540. 		return ret
    2541. 

  2541. 	
    2542. 

  2542. 	def add(self, key, val):
    2543. 

  2543. 		"Adds the key:value pair to the config dictionary (if needed)"
    2544. 

  2544. 		# %!options
    2545. 

  2545. 		if key == 'options':
    2546. 

  2546. 			ignoreme = self.dft_actions.keys() + ['target']
    2547. 

  2547. 			ignoreme.remove('dump-config')
    2548. 

  2548. 			ignoreme.remove('dump-source')
    2549. 

  2549. 			raw_opts = CommandLine().get_raw_config(
    2550. 

  2550. 				val, ignore=ignoreme)
    2551. 

  2551. 			for target, key, val in raw_opts:
    2552. 

  2552. 				self.add(key, val)
    2553. 

  2553. 			return
    2554. 

  2554. 		# The no- prefix turns OFF this key
    2555. 

  2555. 		if key.startswith('no-'):
    2556. 

  2556. 			key = key[3:]              # remove prefix
    2557. 

  2557. 			val = self.off.get(key)    # turn key OFF
    2558. 

  2558. 		# Is this key valid?
    2559. 

  2559. 		if key not in self.defaults.keys():
    2560. 

  2560. 			Debug('Bogus Config %s:%s'%(key,val),1)
    2561. 

  2561. 			return
    2562. 

  2562. 		# Is this value the default one?
    2563. 

  2563. 		if val == self.defaults.get(key):
    2564. 

  2564. 			# If default value, remove previous key:val
    2565. 

  2565. 			if self.parsed.has_key(key):
    2566. 

  2566. 				del self.parsed[key]
    2567. 

  2567. 			# Nothing more to do
    2568. 

  2568. 			return
    2569. 

  2569. 		# Flags ON comes empty. we'll add the 1 value now
    2570. 

  2570. 		if val == '' and (
    2571. 

  2571. 		   key in self.dft_flags.keys() or
    2572. 

  2572. 		   key in self.dft_actions.keys()):
    2573. 

  2573. 			val = 1
    2574. 

  2574. 		# Multi value or single?
    2575. 

  2575. 		if key in self.multi:
    2576. 

  2576. 			# First one? start new list
    2577. 

  2577. 			if not self.parsed.has_key(key):
    2578. 

  2578. 				self.parsed[key] = []
    2579. 

  2579. 			self.parsed[key].append(val)
    2580. 

  2580. 		# Incremental value? so let's add it
    2581. 

  2581. 		elif key in self.incremental:
    2582. 

  2582. 			self.parsed[key] = (self.parsed.get(key) or 0) + val
    2583. 

  2583. 		else:
    2584. 

  2584. 			self.parsed[key] = val
    2585. 

  2585. 		fancykey = dotted_spaces("%12s"%key)
    2586. 

  2586. 		Message(_("Added config %s : %s")%(fancykey,val),3)
    2587. 

  2587. 	
    2588. 

  2588. 	def get_outfile_name(self, config={}):
    2589. 

  2589. 		"Dirname is the same for {in,out}file"
    2590. 

  2590. 		infile, outfile = config['sourcefile'], config['outfile']
    2591. 

  2591. 		if outfile and outfile not in (STDOUT, MODULEOUT) \
    2592. 

  2592. 		   and not os.path.isabs(outfile):
    2593. 

  2593. 			outfile = os.path.join(os.path.dirname(infile), outfile)
    2594. 

  2594. 		if infile == STDIN    and not outfile: outfile = STDOUT
    2595. 

  2595. 		if infile == MODULEIN and not outfile: outfile = MODULEOUT
    2596. 

  2596. 		if not outfile and (infile and config.get('target')):
    2597. 

  2597. 			basename = re.sub('\.(txt|t2t)$','',infile)
    2598. 

  2598. 			outfile = "%s.%s"%(basename, config['target'])
    2599. 

  2599. 		Debug(" infile: '%s'"%infile , 1)
    2600. 

  2600. 		Debug("outfile: '%s'"%outfile, 1)
    2601. 

  2601. 		return outfile
    2602. 

  2602. 	
    2603. 

  2603. 	def sanity(self, config, gui=0):
    2604. 

  2604. 		"Basic config sanity checking"
    2605. 

  2605. 		if not config: return {}
    2606. 

  2606. 		target = config.get('target')
    2607. 

  2607. 		# Some actions don't require target specification
    2608. 

  2608. 		if not target:
    2609. 

  2609. 			for action in NO_TARGET:
    2610. 

  2610. 				if config.get(action):
    2611. 

  2611. 					target = 'txt'
    2612. 

  2612. 					break
    2613. 

  2613. 		# On GUI, some checking are skipped
    2614. 

  2614. 		if not gui:
    2615. 

  2615. 			# We *need* a target
    2616. 

  2616. 			if not target:
    2617. 

  2617. 				Error(_('No target specified (try --help)') + '\n\n' +
    2618. 

  2618. 				_('Maybe trying to convert an old v1.x file?'))
    2619. 

  2619. 			# And of course, an infile also
    2620. 

  2620. 			if not config.get('infile'):
    2621. 

  2621. 				Error(_('Missing input file (try --help)'))
    2622. 

  2622. 			# Is the target valid?
    2623. 

  2623. 			if not TARGETS.count(target):
    2624. 

  2624. 				Error(_("Invalid target '%s' (try --help)") % target)
    2625. 

  2625. 		# Ensure all keys are present
    2626. 

  2626. 		empty = self.defaults.copy() ; empty.update(config)
    2627. 

  2627. 		config = empty.copy()
    2628. 

  2628. 		# Check integers options
    2629. 

  2629. 		for key in config.keys():
    2630. 

  2630. 			if key in self.numeric:
    2631. 

  2631. 				try: config[key] = int(config[key])
    2632. 

  2632. 				except: Error(_('--%s value must be a number') % key)
    2633. 

  2633. 		# Check split level value
    2634. 

  2634. 		if config['split'] not in (0,1,2):
    2635. 

  2635. 			Error(_('Option --split must be 0, 1 or 2'))
    2636. 

  2636. 		# --toc-only is stronger than others
    2637. 

  2637. 		if config['toc-only']:
    2638. 

  2638. 			config['headers'] = 0
    2639. 

  2639. 			config['toc']     = 0
    2640. 

  2640. 			config['split']   = 0
    2641. 

  2641. 			config['gui']     = 0
    2642. 

  2642. 			config['outfile'] = config['outfile'] or STDOUT
    2643. 

  2643. 		# Splitting is disable for now (future: HTML only, no STDOUT)
    2644. 

  2644. 		config['split'] = 0
    2645. 

  2645. 		# Restore target
    2646. 

  2646. 		config['target'] = target
    2647. 

  2647. 		# Set output file name
    2648. 

  2648. 		config['outfile'] = self.get_outfile_name(config)
    2649. 

  2649. 		# Checking suicide
    2650. 

  2650. 		if config['sourcefile'] == config['outfile'] and \
    2651. 

  2651. 		   config['outfile'] not in [STDOUT,MODULEOUT] and not gui:
    2652. 

  2652. 			Error(_("Input and Output files are the same: %s") % config['outfile'])
    2653. 

  2653. 		return config
    2654. 

  2654. 	
    2655. 

  2655. 	def parse(self):
    2656. 

  2656. 		"Returns the parsed config for the current target"
    2657. 

  2657. 		raw = self.get_target_raw()
    2658. 

  2658. 		for target, key, value in raw:
    2659. 

  2659. 			self.add(key, value)
    2660. 

  2660. 		Message(_("Added the following keys: %s") % ', '.join(self.parsed.keys()), 2)
    2661. 

  2661. 		return self.parsed.copy()
    2662. 

  2662. 	
    2663. 

  2663. 	def find_value(self, key='', target=''):
    2664. 

  2664. 		"Scans ALL raw config to find the desired key"
    2665. 

  2665. 		ret = []
    2666. 

  2666. 		# Scan and save all values found
    2667. 

  2667. 		for targ, k, val in self.raw:
    2668. 

  2668. 			if k == key and (targ == target or targ == 'all'):
    2669. 

  2669. 				ret.append(val)
    2670. 

  2670. 		if not ret: return ''
    2671. 

  2671. 		# If not multi value, return only the last found
    2672. 

  2672. 		if key in self.multi: return ret
    2673. 

  2673. 		else                : return ret[-1]
    2674. 

  2674. 

  2675. ########################################################################
    2676. 

  2676. 

  2677. class ConfigLines:
    2678. 

  2678. 	"""
    2679. 

  2679. 	ConfigLines class - the config file data extractor
    2680. 

  2680. 	
    2681. 

  2681. 	This class reads and parse the config lines on the %!key:val
    2682. 

  2682. 	format, converting it to RAW config. It deals with user
    2683. 

  2683. 	config file (RC file), source document CONF area and
    2684. 

  2684. 	%!includeconf directives.
    2685. 

  2685. 

  2686. 	Call it passing a file name or feed the desired config lines.
    2687. 

  2687. 	Then just call the get_raw_config() method and wait to
    2688. 

  2688. 	receive the full config data on the RAW format. This method
    2689. 

  2689. 	also follows the possible %!includeconf directives found on
    2690. 

  2690. 	the config lines. Example:
    2691. 

  2691. 

  2692. 		raw = ConfigLines(file=".txt2tagsrc").get_raw_config()
    2693. 

  2693. 

  2694. 	The parse_line() method is also useful to be used alone,
    2695. 

  2695. 	to identify and tokenize a single config line. For example,
    2696. 

  2696. 	to get the %!include command components, on the source
    2697. 

  2697. 	document BODY:
    2698. 

  2698. 	
    2699. 

  2699. 		target, key, value = ConfigLines().parse_line(body_line)
    2700. 

  2700. 	"""
    2701. 

  2701. 	def __init__(self, file='', lines=[], first_line=1):
    2702. 

  2702. 		self.file = file or 'NOFILE'
    2703. 

  2703. 		self.lines = lines
    2704. 

  2704. 		self.first_line = first_line
    2705. 

  2705. 	
    2706. 

  2706. 	def load_lines(self):
    2707. 

  2707. 		"Make sure we've loaded the file contents into buffer"
    2708. 

  2708. 		if not self.lines and not self.file:
    2709. 

  2709. 			Error("ConfigLines: No file or lines provided")
    2710. 

  2710. 		if not self.lines:
    2711. 

  2711. 			self.lines = self.read_config_file(self.file)
    2712. 

  2712. 	
    2713. 

  2713. 	def read_config_file(self, filename=''):
    2714. 

  2714. 		"Read a Config File contents, aborting on invalid line"
    2715. 

  2715. 		if not filename: return []
    2716. 

  2716. 		errormsg = _("Invalid CONFIG line on %s")+"\n%03d:%s"
    2717. 

  2717. 		lines = Readfile(filename, remove_linebreaks=1)
    2718. 

  2718. 		# Sanity: try to find invalid config lines
    2719. 

  2719. 		for i in xrange(len(lines)):
    2720. 

  2720. 			line = lines[i].rstrip()
    2721. 

  2721. 			if not line: continue  # empty
    2722. 

  2722. 			if line[0] != '%': Error(errormsg%(filename,i+1,line))
    2723. 

  2723. 		return lines
    2724. 

  2724. 	
    2725. 

  2725. 	def include_config_file(self, file=''):
    2726. 

  2726. 		"Perform the %!includeconf action, returning RAW config"
    2727. 

  2727. 		if not file: return []
    2728. 

  2728. 		# Current dir relative to the current file (self.file)
    2729. 

  2729. 		current_dir = os.path.dirname(self.file)
    2730. 

  2730. 		file = os.path.join(current_dir, file)
    2731. 

  2731. 		# Read and parse included config file contents
    2732. 

  2732. 		lines = self.read_config_file(file)
    2733. 

  2733. 		return ConfigLines(file=file, lines=lines).get_raw_config()
    2734. 

  2734. 	
    2735. 

  2735. 	def get_raw_config(self):
    2736. 

  2736. 		"Scan buffer and extract all config as RAW (including includes)"
    2737. 

  2737. 		ret = []
    2738. 

  2738. 		self.load_lines()
    2739. 

  2739. 		first = self.first_line
    2740. 

  2740. 		for i in xrange(len(self.lines)):
    2741. 

  2741. 			line = self.lines[i]
    2742. 

  2742. 			Message(_("Processing line %03d: %s")%(first+i,line),2)
    2743. 

  2743. 			target, key, val = self.parse_line(line)
    2744. 

  2744. 			if not key: continue    # no config on this line
    2745. 

  2745. 			if key == 'includeconf':
    2746. 

  2746. 				err = _('A file cannot include itself (loop!)')
    2747. 

  2747. 				if val == self.file:
    2748. 

  2748. 					Error("%s: %%!includeconf: %s" % (err, self.file))
    2749. 

  2749. 				more_raw = self.include_config_file(val)
    2750. 

  2750. 				ret.extend(more_raw)
    2751. 

  2751. 				Message(_("Finished Config file inclusion: %s") % val, 2)
    2752. 

  2752. 			else:
    2753. 

  2753. 				ret.append([target, key, val])
    2754. 

  2754. 				Message(_("Added %s")%key,3)
    2755. 

  2755. 		return ret
    2756. 

  2756. 	
    2757. 

  2757. 	def parse_line(self, line='', keyname='', target=''):
    2758. 

  2758. 		"Detects %!key:val config lines and extract data from it"
    2759. 

  2759. 		empty = ['', '', '']
    2760. 

  2760. 		if not line: return empty
    2761. 

  2761. 		no_target = ['target', 'includeconf']
    2762. 

  2762. 		re_name   = keyname or '[a-z]+'
    2763. 

  2763. 		re_target = target  or '[a-z]*'
    2764. 

  2764. 		# XXX TODO <value>\S.+?  requires TWO chars, breaks %!include:a
    2765. 

  2765. 		cfgregex  = re.compile("""
    2766. 

  2766. 			^%%!\s*               # leading id with opt spaces
    2767. 

  2767. 			(?P<name>%s)\s*       # config name
    2768. 

  2768. 			(\((?P<target>%s)\))? # optional target spec inside ()
    2769. 

  2769. 			\s*:\s*               # key:value delimiter with opt spaces
    2770. 

  2770. 			(?P<value>\S.+?)      # config value
    2771. 

  2771. 			\s*$                  # rstrip() spaces and hit EOL
    2772. 

  2772. 			"""%(re_name, re_target), re.I+re.VERBOSE)
    2773. 

  2773. 		prepostregex = re.compile("""
    2774. 

  2774. 		                              # ---[ PATTERN ]---
    2775. 

  2775. 			^( "([^"]*)"          # "double quoted" or
    2776. 

  2776. 			| '([^']*)'           # 'single quoted' or
    2777. 

  2777. 			| ([^\s]+)            # single_word
    2778. 

  2778. 			)
    2779. 

  2779. 			\s+                   # separated by spaces
    2780. 

  2780. 		
    2781. 

  2781. 		                              # ---[ REPLACE ]---
    2782. 

  2782. 			( "([^"]*)"           # "double quoted" or
    2783. 

  2783. 			| '([^']*)'           # 'single quoted' or
    2784. 

  2784. 			| (.*)                # anything
    2785. 

  2785. 			)
    2786. 

  2786. 			\s*$
    2787. 

  2787. 			""", re.VERBOSE)
    2788. 

  2788. 		guicolors = re.compile("^([^\s]+\s+){3}[^\s]+") # 4 tokens
    2789. 

  2789. 		match = cfgregex.match(line)
    2790. 

  2790. 		if not match: return empty
    2791. 

  2791. 		
    2792. 

  2792. 		name   = (match.group('name') or '').lower()
    2793. 

  2793. 		target = (match.group('target') or 'all').lower()
    2794. 

  2794. 		value  = match.group('value')
    2795. 

  2795. 		
    2796. 

  2796. 		# NO target keywords: force all targets
    2797. 

  2797. 		if name in no_target: target = 'all'
    2798. 

  2798. 		
    2799. 

  2799. 		# Special config for GUI colors
    2800. 

  2800. 		if name == 'guicolors':
    2801. 

  2801. 			valmatch = guicolors.search(value)
    2802. 

  2802. 			if not valmatch: return empty
    2803. 

  2803. 			value = re.split('\s+', value)
    2804. 

  2804. 		
    2805. 

  2805. 		# Special config with two quoted values (%!preproc: "foo" 'bar')
    2806. 

  2806. 		if name == 'preproc' or name == 'postproc':
    2807. 

  2807. 			valmatch = prepostregex.search(value)
    2808. 

  2808. 			if not valmatch: return empty
    2809. 

  2809. 			getval = valmatch.group
    2810. 

  2810. 			patt   = getval(2) or getval(3) or getval(4) or ''
    2811. 

  2811. 			repl   = getval(6) or getval(7) or getval(8) or ''
    2812. 

  2812. 			value  = (patt, repl)
    2813. 

  2813. 		return [target, name, value]
    2814. 

  2814. 

  2815. ##############################################################################
    2816. 

  2816. 

  2817. class MaskMaster:
    2818. 

  2818. 	"(Un)Protect important structures from escaping and formatting"
    2819. 

  2819. 	def __init__(self):
    2820. 

  2820. 		self.linkmask  = 'vvvLINKvvv'
    2821. 

  2821. 		self.monomask  = 'vvvMONOvvv'
    2822. 

  2822. 		self.macromask = 'vvvMACROvvv'
    2823. 

  2823. 		self.rawmask   = 'vvvRAWvvv'
    2824. 

  2824. 		self.taggedmask= 'vvvTAGGEDvvv'
    2825. 

  2825. 		self.tocmask   = 'vvvTOCvvv'
    2826. 

  2826. 		self.macroman  = MacroMaster()
    2827. 

  2827. 		self.reset()
    2828. 

  2828. 	
    2829. 

  2829. 	def reset(self):
    2830. 

  2830. 		self.linkbank = []
    2831. 

  2831. 		self.monobank = []
    2832. 

  2832. 		self.macrobank = []
    2833. 

  2833. 		self.rawbank = []
    2834. 

  2834. 		self.taggedbank = []
    2835. 

  2835. 	
    2836. 

  2836. 	def mask(self, line=''):
    2837. 

  2837. 		global AUTOTOC
    2838. 

  2838. 

  2839. 		# The verbatim, raw and tagged inline marks are mutually exclusive.
    2840. 

  2840. 		# This means that one can't appear inside the other.
    2841. 

  2841. 		# If found, the inner marks must be ignored.
    2842. 

  2842. 		# Example: ``foo ""bar"" ''baz''``
    2843. 

  2843. 		# In HTML: <code>foo ""bar"" ''baz''</code> 		
    2844. 

  2844. 		#
    2845. 

  2845. 		# The trick here is to protect the mark who appears first on the line.
    2846. 

  2846. 		# The three regexes are tried and the one with the lowest index wins.
    2847. 

  2847. 		# If none is found (else), we get out of the loop.
    2848. 

  2848. 		#
    2849. 

  2849. 		while True:
    2850. 

  2850. 			
    2851. 

  2851. 			# Try to match the line for the three marks
    2852. 

  2852. 			# Note: 'z' > 999999
    2853. 

  2853. 			#
    2854. 

  2854. 			t = r = v = 'z'
    2855. 

  2855. 			try: t = regex['tagged'].search(line).start()
    2856. 

  2856. 			except: pass
    2857. 

  2857. 			try: r = regex['raw'].search(line).start()
    2858. 

  2858. 			except: pass
    2859. 

  2859. 			try: v = regex['fontMono'].search(line).start()
    2860. 

  2860. 			except: pass
    2861. 

  2861. 

  2862. 			# Protect tagged text
    2863. 

  2863. 			if t >= 0 and t < r and t < v:
    2864. 

  2864. 				txt = regex['tagged'].search(line).group(1)
    2865. 

  2865. 				self.taggedbank.append(txt)
    2866. 

  2866. 				line = regex['tagged'].sub(self.taggedmask,line,1)
    2867. 

  2867. 

  2868. 			# Protect raw text
    2869. 

  2869. 			elif r >= 0 and r < t and r < v:
    2870. 

  2870. 				txt = regex['raw'].search(line).group(1)
    2871. 

  2871. 				txt = doEscape(TARGET,txt)
    2872. 

  2872. 				self.rawbank.append(txt)
    2873. 

  2873. 				line = regex['raw'].sub(self.rawmask,line,1)
    2874. 

  2874. 

  2875. 			# Protect verbatim text
    2876. 

  2876. 			elif v >= 0 and v < t and v < r:
    2877. 

  2877. 				txt = regex['fontMono'].search(line).group(1)
    2878. 

  2878. 				txt = doEscape(TARGET,txt)
    2879. 

  2879. 				self.monobank.append(txt)
    2880. 

  2880. 				line = regex['fontMono'].sub(self.monomask,line,1)
    2881. 

  2881. 			else:
    2882. 

  2882. 				break
    2883. 

  2883. 			
    2884. 

  2884. 		# Protect macros
    2885. 

  2885. 		while regex['macros'].search(line):
    2886. 

  2886. 			txt = regex['macros'].search(line).group()
    2887. 

  2887. 			self.macrobank.append(txt)
    2888. 

  2888. 			line = regex['macros'].sub(self.macromask,line,1)
    2889. 

  2889. 		
    2890. 

  2890. 		# Protect TOC location
    2891. 

  2891. 		while regex['toc'].search(line):
    2892. 

  2892. 			line = regex['toc'].sub(self.tocmask,line)
    2893. 

  2893. 			AUTOTOC = 0
    2894. 

  2894. 		
    2895. 

  2895. 		# Protect URLs and emails
    2896. 

  2896. 		while regex['linkmark'].search(line) or \
    2897. 

  2897. 		      regex['link'    ].search(line):
    2898. 

  2898. 			
    2899. 

  2899. 			# Try to match plain or named links
    2900. 

  2900. 			match_link  = regex['link'].search(line)
    2901. 

  2901. 			match_named = regex['linkmark'].search(line)
    2902. 

  2902. 			
    2903. 

  2903. 			# Define the current match
    2904. 

  2904. 			if match_link and match_named:
    2905. 

  2905. 				# Both types found, which is the first?
    2906. 

  2906. 				m = match_link
    2907. 

  2907. 				if match_named.start() < match_link.start():
    2908. 

  2908. 					m = match_named
    2909. 

  2909. 			else:
    2910. 

  2910. 				# Just one type found, we're fine
    2911. 

  2911. 				m = match_link or match_named
    2912. 

  2912. 			
    2913. 

  2913. 			# Extract link data and apply mask
    2914. 

  2914. 			if m == match_link:              # plain link
    2915. 

  2915. 				link = m.group()
    2916. 

  2916. 				label = ''
    2917. 

  2917. 				link_re = regex['link']
    2918. 

  2918. 			else:                            # named link
    2919. 

  2919. 				link = m.group('link')
    2920. 

  2920. 				label = m.group('label').rstrip()
    2921. 

  2921. 				link_re = regex['linkmark']
    2922. 

  2922. 			line = link_re.sub(self.linkmask,line,1)
    2923. 

  2923. 			
    2924. 

  2924. 			# Save link data to the link bank
    2925. 

  2925. 			self.linkbank.append((label, link))
    2926. 

  2926. 		return line
    2927. 

  2927. 	
    2928. 

  2928. 	def undo(self, line):
    2929. 

  2929. 		
    2930. 

  2930. 		# url & email
    2931. 

  2931. 		for label,url in self.linkbank:
    2932. 

  2932. 			link = get_tagged_link(label, url)
    2933. 

  2933. 			line = line.replace(self.linkmask, link, 1)
    2934. 

  2934. 		
    2935. 

  2935. 		# Expand macros
    2936. 

  2936. 		for macro in self.macrobank:
    2937. 

  2937. 			macro = self.macroman.expand(macro)
    2938. 

  2938. 			line = line.replace(self.macromask, macro, 1)
    2939. 

  2939. 		
    2940. 

  2940. 		# Expand verb
    2941. 

  2941. 		for mono in self.monobank:
    2942. 

  2942. 			open,close = TAGS['fontMonoOpen'],TAGS['fontMonoClose']
    2943. 

  2943. 			line = line.replace(self.monomask, open+mono+close, 1)
    2944. 

  2944. 		
    2945. 

  2945. 		# Expand raw
    2946. 

  2946. 		for raw in self.rawbank:
    2947. 

  2947. 			line = line.replace(self.rawmask, raw, 1)
    2948. 

  2948. 

  2949. 		# Expand tagged
    2950. 

  2950. 		for tagged in self.taggedbank:
    2951. 

  2951. 			line = line.replace(self.taggedmask, tagged, 1)
    2952. 

  2952. 		
    2953. 

  2953. 		return line
    2954. 

  2954. 

  2955. 

  2956. ##############################################################################
    2957. 

  2957. 

  2958. 

  2959. class TitleMaster:
    2960. 

  2960. 	"Title things"
    2961. 

  2961. 	def __init__(self):
    2962. 

  2962. 		self.count = ['',0,0,0,0,0]
    2963. 

  2963. 		self.toc   = []
    2964. 

  2964. 		self.level = 0
    2965. 

  2965. 		self.kind  = ''
    2966. 

  2966. 		self.txt   = ''
    2967. 

  2967. 		self.label = ''
    2968. 

  2968. 		self.tag   = ''
    2969. 

  2969. 		self.tag_hold = []
    2970. 

  2970. 		self.last_level = 0
    2971. 

  2971. 		self.count_id = ''
    2972. 

  2972. 		self.user_labels = {}
    2973. 

  2973. 		self.anchor_count = 0
    2974. 

  2974. 		self.anchor_prefix = 'toc'
    2975. 

  2975. 	
    2976. 

  2976. 	def _open_close_blocks(self):
    2977. 

  2977. 		"Open new title blocks, closing the previous (if any)"
    2978. 

  2978. 		if not rules['titleblocks']: return
    2979. 

  2979. 		tag = ''
    2980. 

  2980. 		last = self.last_level
    2981. 

  2981. 		curr = self.level
    2982. 

  2982. 		
    2983. 

  2983. 		# Same level, just close the previous
    2984. 

  2984. 		if curr == last:
    2985. 

  2985. 			tag = TAGS.get('title%dClose'%last)
    2986. 

  2986. 			if tag: self.tag_hold.append(tag)
    2987. 

  2987. 		
    2988. 

  2988. 		# Section -> subsection, more depth
    2989. 

  2989. 		while curr > last:
    2990. 

  2990. 			last += 1
    2991. 

  2991. 			
    2992. 

  2992. 			# Open the new block of subsections
    2993. 

  2993. 			tag = TAGS.get('blockTitle%dOpen'%last)
    2994. 

  2994. 			if tag: self.tag_hold.append(tag)
    2995. 

  2995. 			
    2996. 

  2996. 			# Jump from title1 to title3 or more
    2997. 

  2997. 			# Fill the gap with an empty section
    2998. 

  2998. 			if curr - last > 0:
    2999. 

  2999. 				tag = TAGS.get('title%dOpen'%last)
    3000. 

  3000. 				tag = regex['x'].sub('', tag)      # del \a
    3001. 

  3001. 				if tag: self.tag_hold.append(tag)
    3002. 

  3002. 		
    3003. 

  3003. 		# Section <- subsection, less depth
    3004. 

  3004. 		while curr < last:
    3005. 

  3005. 			# Close the current opened subsection
    3006. 

  3006. 			tag = TAGS.get('title%dClose'%last)
    3007. 

  3007. 			if tag: self.tag_hold.append(tag)
    3008. 

  3008. 			
    3009. 

  3009. 			# Close the current opened block of subsections
    3010. 

  3010. 			tag = TAGS.get('blockTitle%dClose'%last)
    3011. 

  3011. 			if tag: self.tag_hold.append(tag)
    3012. 

  3012. 			
    3013. 

  3013. 			last -= 1
    3014. 

  3014. 			
    3015. 

  3015. 			# Close the previous section of the same level
    3016. 

  3016. 			# The subsections were under it
    3017. 

  3017. 			if curr == last:
    3018. 

  3018. 				tag = TAGS.get('title%dClose'%last)
    3019. 

  3019. 				if tag: self.tag_hold.append(tag)
    3020. 

  3020. 	
    3021. 

  3021. 	def add(self, line):
    3022. 

  3022. 		"Parses a new title line."
    3023. 

  3023. 		if not line: return
    3024. 

  3024. 		self._set_prop(line)
    3025. 

  3025. 		self._open_close_blocks()
    3026. 

  3026. 		self._set_count_id()
    3027. 

  3027. 		self._set_label()
    3028. 

  3028. 		self._save_toc_info()
    3029. 

  3029. 	
    3030. 

  3030. 	def close_all(self):
    3031. 

  3031. 		"Closes all opened title blocks"
    3032. 

  3032. 		ret = []
    3033. 

  3033. 		ret.extend(self.tag_hold)
    3034. 

  3034. 		while self.level:
    3035. 

  3035. 			tag = TAGS.get('title%dClose'%self.level)
    3036. 

  3036. 			if tag: ret.append(tag)
    3037. 

  3037. 			tag = TAGS.get('blockTitle%dClose'%self.level)
    3038. 

  3038. 			if tag: ret.append(tag)
    3039. 

  3039. 			self.level -= 1
    3040. 

  3040. 		return ret
    3041. 

  3041. 	
    3042. 

  3042. 	def _save_toc_info(self):
    3043. 

  3043. 		"Save TOC info, used by self.dump_marked_toc()"
    3044. 

  3044. 		self.toc.append((self.level, self.count_id, self.txt, self.label))
    3045. 

  3045. 	
    3046. 

  3046. 	def _set_prop(self, line=''):
    3047. 

  3047. 		"Extract info from original line and set data holders."
    3048. 

  3048. 		# Detect title type (numbered or not)
    3049. 

  3049. 		id = line.lstrip()[0]
    3050. 

  3050. 		if   id == '=': kind = 'title'
    3051. 

  3051. 		elif id == '+': kind = 'numtitle'
    3052. 

  3052. 		else: Error("Unknown Title ID '%s'"%id)
    3053. 

  3053. 		# Extract line info
    3054. 

  3054. 		match = regex[kind].search(line)
    3055. 

  3055. 		level = len(match.group('id'))
    3056. 

  3056. 		txt   = match.group('txt').strip()
    3057. 

  3057. 		label = match.group('label')
    3058. 

  3058. 		# Parse info & save
    3059. 

  3059. 		if CONF['enum-title']: kind = 'numtitle'  # force
    3060. 

  3060. 		if rules['titleblocks']:
    3061. 

  3061. 			self.tag = TAGS.get('%s%dOpen'%(kind,level)) or \
    3062. 

  3062. 			           TAGS.get('title%dOpen'%level)
    3063. 

  3063. 		else:
    3064. 

  3064. 			self.tag = TAGS.get(kind+`level`) or \
    3065. 

  3065. 			           TAGS.get('title'+`level`)
    3066. 

  3066. 		self.last_level = self.level
    3067. 

  3067. 		self.kind  = kind
    3068. 

  3068. 		self.level = level
    3069. 

  3069. 		self.txt   = txt
    3070. 

  3070. 		self.label = label
    3071. 

  3071. 	
    3072. 

  3072. 	def _set_count_id(self):
    3073. 

  3073. 		"Compose and save the title count identifier (if needed)."
    3074. 

  3074. 		count_id = ''
    3075. 

  3075. 		if self.kind == 'numtitle' and not rules['autonumbertitle']:
    3076. 

  3076. 			# Manually increase title count
    3077. 

  3077. 			self.count[self.level] += 1
    3078. 

  3078. 			# Reset sublevels count (if any)
    3079. 

  3079. 			max_levels = len(self.count)
    3080. 

  3080. 			if self.level < max_levels-1:
    3081. 

  3081. 				for i in xrange(self.level+1, max_levels):
    3082. 

  3082. 					self.count[i] = 0
    3083. 

  3083. 			# Compose count id from hierarchy
    3084. 

  3084. 			for i in xrange(self.level):
    3085. 

  3085. 				count_id= "%s%d."%(count_id, self.count[i+1])
    3086. 

  3086. 		self.count_id = count_id
    3087. 

  3087. 	
    3088. 

  3088. 	def _set_label(self):
    3089. 

  3089. 		"Compose and save title label, used by anchors."
    3090. 

  3090. 		# Remove invalid chars from label set by user
    3091. 

  3091. 		self.label = re.sub('[^A-Za-z0-9_-]', '', self.label or '')
    3092. 

  3092. 		# Generate name as 15 first :alnum: chars
    3093. 

  3093. 		#TODO how to translate safely accented chars to plain?
    3094. 

  3094. 		#self.label = re.sub('[^A-Za-z0-9]', '', self.txt)[:15]
    3095. 

  3095. 		# 'tocN' label - sequential count, ignoring 'toc-level'
    3096. 

  3096. 		#self.label = self.anchor_prefix + str(len(self.toc)+1)
    3097. 

  3097. 	
    3098. 

  3098. 	def _get_tagged_anchor(self):
    3099. 

  3099. 		"Return anchor if user defined a label, or TOC is on."
    3100. 

  3100. 		ret = ''
    3101. 

  3101. 		label = self.label
    3102. 

  3102. 		if CONF['toc'] and self.level <= CONF['toc-level']:
    3103. 

  3103. 			# This count is needed bcos self.toc stores all
    3104. 

  3104. 			# titles, regardless of the 'toc-level' setting,
    3105. 

  3105. 			# so we can't use self.toc length to number anchors
    3106. 

  3106. 			self.anchor_count += 1
    3107. 

  3107. 			# Autonumber label (if needed)
    3108. 

  3108. 			label = label or '%s%s' % (self.anchor_prefix, self.anchor_count)
    3109. 

  3109. 		if label and TAGS['anchor']:
    3110. 

  3110. 			ret = regex['x'].sub(label,TAGS['anchor'])
    3111. 

  3111. 		return ret
    3112. 

  3112. 	
    3113. 

  3113. 	def _get_full_title_text(self):
    3114. 

  3114. 		"Returns the full title contents, already escaped."
    3115. 

  3115. 		ret = self.txt
    3116. 

  3116. 		# Insert count_id (if any) before text
    3117. 

  3117. 		if self.count_id:
    3118. 

  3118. 			ret = '%s %s'%(self.count_id, ret)
    3119. 

  3119. 		# Escape specials
    3120. 

  3120. 		ret = doEscape(TARGET, ret)
    3121. 

  3121. 		# Same targets needs final escapes on title lines
    3122. 

  3122. 		# It's here because there is a 'continue' after title
    3123. 

  3123. 		if rules['finalescapetitle']:
    3124. 

  3124. 			ret = doFinalEscape(TARGET, ret)
    3125. 

  3125. 		return ret
    3126. 

  3126. 	
    3127. 

  3127. 	def get(self):
    3128. 

  3128. 		"Returns the tagged title as a list."
    3129. 

  3129. 		ret = []
    3130. 

  3130. 		
    3131. 

  3131. 		# Maybe some anchoring before?
    3132. 

  3132. 		anchor = self._get_tagged_anchor()
    3133. 

  3133. 		self.tag = regex['_anchor'].sub(anchor, self.tag)
    3134. 

  3134. 		
    3135. 

  3135. 		### Compose & escape title text (TOC uses unescaped)
    3136. 

  3136. 		full_title = self._get_full_title_text()
    3137. 

  3137. 		
    3138. 

  3138. 		# Close previous section area
    3139. 

  3139. 		ret.extend(self.tag_hold)
    3140. 

  3140. 		self.tag_hold = []
    3141. 

  3141. 		
    3142. 

  3142. 		tagged = regex['x'].sub(full_title, self.tag)
    3143. 

  3143. 

  3144. 		# Adds "underline" on TXT target
    3145. 

  3145. 		if TARGET == 'txt':
    3146. 

  3146. 			if BLOCK.count > 1: ret.append('') # blank line before
    3147. 

  3147. 			ret.append(tagged)
    3148. 

  3148. 			# Get the right letter count for UTF
    3149. 

  3149. 			if CONF['encoding'].lower() == 'utf-8':
    3150. 

  3150. 				i = len(full_title.decode('utf-8'))
    3151. 

  3151. 			else:
    3152. 

  3152. 				i = len(full_title)
    3153. 

  3153. 			ret.append(regex['x'].sub('='*i, self.tag))
    3154. 

  3154. 		elif TARGET == 'art' and self.level == 1:
    3155. 

  3155. 			if BLOCK.count > 1: ret.append('') # blank line before
    3156. 

  3156. 			ret.append(aa_box(tagged))
    3157. 

  3157. 		elif TARGET == 'art':
    3158. 

  3158. 			level = 'level'+str(self.level)
    3159. 

  3159. 			if BLOCK.count > 1: ret.append('') # blank line before
    3160. 

  3160. 			ret.append(tagged)
    3161. 

  3161. 			ret.append(AA_CHARS[level]*len(full_title))
    3162. 

  3162. 		else:
    3163. 

  3163. 			ret.append(tagged)
    3164. 

  3164. 		return ret
    3165. 

  3165. 	
    3166. 

  3166. 	def dump_marked_toc(self, max_level=99):
    3167. 

  3167. 		"Dumps all toc itens as a valid t2t markup list"
    3168. 

  3168. 		ret = []
    3169. 

  3169. 		toc_count = 1
    3170. 

  3170. 		for level, count_id, txt, label in self.toc:
    3171. 

  3171. 			if level > max_level: continue   # ignore
    3172. 

  3172. 			indent = '  '*level
    3173. 

  3173. 			id_txt = ('%s %s'%(count_id, txt)).lstrip()
    3174. 

  3174. 			label = label or self.anchor_prefix+`toc_count`
    3175. 

  3175. 			toc_count += 1
    3176. 

  3176. 			# TOC will have links
    3177. 

  3177. 			if TAGS['anchor']:
    3178. 

  3178. 				# TOC is more readable with master topics
    3179. 

  3179. 				# not linked at number. This is a stoled
    3180. 

  3180. 				# idea from Windows .CHM help files
    3181. 

  3181. 				if CONF['enum-title'] and level == 1:
    3182. 

  3182. 					tocitem = '%s+ [""%s"" #%s]' % (indent, txt, label)
    3183. 

  3183. 				else:
    3184. 

  3184. 					tocitem = '%s- [""%s"" #%s]' % (indent, id_txt, label)
    3185. 

  3185. 			# No links on TOC, just text
    3186. 

  3186. 			else:
    3187. 

  3187. 				# man don't reformat TOC lines, cool!
    3188. 

  3188. 				if TARGET in ['txt', 'man', 'art']:
    3189. 

  3189. 					tocitem = '%s""%s""' % (indent, id_txt)
    3190. 

  3190. 				else:
    3191. 

  3191. 					tocitem = '%s- ""%s""' % (indent, id_txt)
    3192. 

  3192. 			ret.append(tocitem)
    3193. 

  3193. 		return ret
    3194. 

  3194. 

  3195. 

  3196. ##############################################################################
    3197. 

  3197. 

  3198. #TODO check all this table mess
    3199. 

  3199. # Trata linhas TABLE, com as prop do parse_row
    3200. 

  3200. # O metodo table() do BLOCK xunxa e troca as celulas pelas parseadas
    3201. 

  3201. class TableMaster:
    3202. 

  3202. 	def __init__(self, line=''):
    3203. 

  3203. 		self.rows      = []
    3204. 

  3204. 		self.border    = 0
    3205. 

  3205. 		self.align     = 'Left'
    3206. 

  3206. 		self.cellalign = []
    3207. 

  3207. 		self.colalign  = []
    3208. 

  3208. 		self.cellspan  = []
    3209. 

  3209. 		if line:
    3210. 

  3210. 			prop = self.parse_row(line)
    3211. 

  3211. 			self.border    = prop['border']
    3212. 

  3212. 			self.align     = prop['align']
    3213. 

  3213. 			self.cellalign = prop['cellalign']
    3214. 

  3214. 			self.cellspan  = prop['cellspan']
    3215. 

  3215. 			self.colalign  = self._get_col_align()
    3216. 

  3216. 

  3217. 	def _get_col_align(self):
    3218. 

  3218. 		colalign = []
    3219. 

  3219. 		for cell in range(0,len(self.cellalign)):
    3220. 

  3220. 			align = self.cellalign[cell]
    3221. 

  3221. 			span  = self.cellspan[cell]
    3222. 

  3222. 			colalign.extend([align] * span)
    3223. 

  3223. 		return colalign
    3224. 

  3224. 

  3225. 	def _get_open_tag(self):
    3226. 

  3226. 		topen     = TAGS['tableOpen']
    3227. 

  3227. 		tborder   = TAGS['_tableBorder']
    3228. 

  3228. 		talign    = TAGS['_tableAlign'+self.align]
    3229. 

  3229. 		calignsep = TAGS['tableColAlignSep']
    3230. 

  3230. 		calign    = ''
    3231. 

  3231. 		
    3232. 

  3232. 		# The first line defines if table has border or not
    3233. 

  3233. 		if not self.border: tborder = ''
    3234. 

  3234. 		# Set the columns alignment
    3235. 

  3235. 		if rules['tablecellaligntype'] == 'column':
    3236. 

  3236. 			calign = map(lambda x: TAGS['_tableColAlign%s'%x], self.colalign)
    3237. 

  3237. 			calign = calignsep.join(calign)
    3238. 

  3238. 		# Align full table, set border and Column align (if any)
    3239. 

  3239. 		topen = regex['_tableAlign'   ].sub(talign , topen)
    3240. 

  3240. 		topen = regex['_tableBorder'  ].sub(tborder, topen)
    3241. 

  3241. 		topen = regex['_tableColAlign'].sub(calign , topen)
    3242. 

  3242. 		# Tex table spec, border or not: {|l|c|r|} , {lcr}
    3243. 

  3243. 		if calignsep and not self.border:
    3244. 

  3244. 			# Remove cell align separator
    3245. 

  3245. 			topen = topen.replace(calignsep, '')
    3246. 

  3246. 		return topen
    3247. 

  3247. 	
    3248. 

  3248. 	def _get_cell_align(self, cells):
    3249. 

  3249. 		ret = []
    3250. 

  3250. 		for cell in cells:
    3251. 

  3251. 			align = 'Left'
    3252. 

  3252. 			if cell.strip():
    3253. 

  3253. 				if cell[0] == ' ' and cell[-1] == ' ':
    3254. 

  3254. 					align = 'Center'
    3255. 

  3255. 				elif cell[0] == ' ':
    3256. 

  3256. 					align = 'Right'
    3257. 

  3257. 			ret.append(align)
    3258. 

  3258. 		return ret
    3259. 

  3259. 	
    3260. 

  3260. 	def _get_cell_span(self, cells):
    3261. 

  3261. 		ret = []
    3262. 

  3262. 		for cell in cells:
    3263. 

  3263. 			span = 1
    3264. 

  3264. 			m = re.search('\a(\|+)$', cell)
    3265. 

  3265. 			if m: span = len(m.group(1))+1
    3266. 

  3266. 			ret.append(span)
    3267. 

  3267. 		return ret
    3268. 

  3268. 	
    3269. 

  3269. 	def _tag_cells(self, rowdata):
    3270. 

  3270. 		row = []
    3271. 

  3271. 		cells  = rowdata['cells']
    3272. 

  3272. 		open   = TAGS['tableCellOpen']
    3273. 

  3273. 		close  = TAGS['tableCellClose']
    3274. 

  3274. 		sep    = TAGS['tableCellSep']
    3275. 

  3275. 		calign    = map(lambda x: TAGS['_tableCellAlign'+x], rowdata['cellalign'])
    3276. 

  3276. 		calignsep = TAGS['tableColAlignSep']
    3277. 

  3277. 		ncolumns = len(self.colalign)
    3278. 

  3278. 

  3279. 		# Populate the span and multicol open tags
    3280. 

  3280. 		cspan = []
    3281. 

  3281. 		multicol = []
    3282. 

  3282. 		colindex = 0
    3283. 

  3283. 		for cellindex in range(0,len(rowdata['cellspan'])):
    3284. 

  3284. 		
    3285. 

  3285. 			span = rowdata['cellspan'][cellindex]
    3286. 

  3286. 			align = rowdata['cellalign'][cellindex]
    3287. 

  3287. 

  3288. 			if span > 1:
    3289. 

  3289. 				cspan.append(regex['x'].sub(
    3290. 

  3290. 				str(span), TAGS['_tableCellColSpan']))
    3291. 

  3291. 

  3292. 				mcopen = regex['x'].sub(str(span), TAGS['_tableCellMulticolOpen'])
    3293. 

  3293. 				multicol.append(mcopen)
    3294. 

  3294. 			else:
    3295. 

  3295. 				cspan.append('')
    3296. 

  3296. 

  3297. 				if colindex < ncolumns and align != self.colalign[colindex]:
    3298. 

  3298. 					mcopen = regex['x'].sub('1', TAGS['_tableCellMulticolOpen'])
    3299. 

  3299. 					multicol.append(mcopen)
    3300. 

  3300. 				else:
    3301. 

  3301. 					multicol.append('')
    3302. 

  3302. 

  3303. 			if not self.border:
    3304. 

  3304. 				multicol[-1] = multicol[-1].replace(calignsep, '')
    3305. 

  3305. 

  3306. 			colindex += span
    3307. 

  3307. 		
    3308. 

  3308. 		# Maybe is it a title row?
    3309. 

  3309. 		if rowdata['title']:
    3310. 

  3310. 			open  = TAGS['tableTitleCellOpen']  or open
    3311. 

  3311. 			close = TAGS['tableTitleCellClose'] or close
    3312. 

  3312. 			sep   = TAGS['tableTitleCellSep']   or sep
    3313. 

  3313. 		
    3314. 

  3314. 		# Should we break the line on *each* table cell?
    3315. 

  3315. 		if rules['breaktablecell']: close = close+'\n'
    3316. 

  3316. 		
    3317. 

  3317. 		# Cells pre processing
    3318. 

  3318. 		if rules['tablecellstrip']:
    3319. 

  3319. 			cells = map(lambda x: x.strip(), cells)
    3320. 

  3320. 		if rowdata['title'] and rules['tabletitlerowinbold']:
    3321. 

  3321. 			cells = map(lambda x: enclose_me('fontBold',x), cells)
    3322. 

  3322. 	
    3323. 

  3323. 		# Add cell BEGIN/END tags
    3324. 

  3324. 		for cell in cells:
    3325. 

  3325. 			copen = open
    3326. 

  3326. 			cclose = close
    3327. 

  3327. 			# Make sure we will pop from some filled lists
    3328. 

  3328. 			# Fixes empty line bug '| |'
    3329. 

  3329. 			this_align = this_span = this_mcopen = ''
    3330. 

  3330. 			if calign: this_align = calign.pop(0)
    3331. 

  3331. 			if cspan : this_span = cspan.pop(0)
    3332. 

  3332. 			if multicol: this_mcopen = multicol.pop(0)
    3333. 

  3333. 

  3334. 			# Insert cell align into open tag (if cell is alignable)
    3335. 

  3335. 			if rules['tablecellaligntype'] == 'cell':
    3336. 

  3336. 				copen = regex['_tableCellAlign'].sub(
    3337. 

  3337. 					this_align, copen)
    3338. 

  3338. 

  3339. 			# Insert cell span into open tag (if cell is spannable)
    3340. 

  3340. 			if rules['tablecellspannable']:
    3341. 

  3341. 				copen = regex['_tableCellColSpan'].sub(
    3342. 

  3342. 					this_span, copen)
    3343. 

  3343. 

  3344. 			# Use multicol tags instead (if multicol supported, and if
    3345. 

  3345. 			# cell has a span or is aligned differently to column)
    3346. 

  3346. 			if rules['tablecellmulticol']:
    3347. 

  3347. 				if this_mcopen:
    3348. 

  3348. 					copen = regex['_tableColAlign'].sub(this_align, this_mcopen)
    3349. 

  3349. 					cclose = TAGS['_tableCellMulticolClose']
    3350. 

  3350. 

  3351. 			row.append(copen + cell + cclose)
    3352. 

  3352. 		
    3353. 

  3353. 		# Maybe there are cell separators?
    3354. 

  3354. 		return sep.join(row)
    3355. 

  3355. 	
    3356. 

  3356. 	def add_row(self, cells):
    3357. 

  3357. 		self.rows.append(cells)
    3358. 

  3358. 	
    3359. 

  3359. 	def parse_row(self, line):
    3360. 

  3360. 		# Default table properties
    3361. 

  3361. 		ret = {
    3362. 

  3362. 			'border':0, 'title':0, 'align':'Left',
    3363. 

  3363. 			'cells':[], 'cellalign':[], 'cellspan':[]
    3364. 

  3364. 		}
    3365. 

  3365. 		# Detect table align (and remove spaces mark)
    3366. 

  3366. 		if line[0] == ' ': ret['align'] = 'Center'
    3367. 

  3367. 		line = line.lstrip()
    3368. 

  3368. 		# Detect title mark
    3369. 

  3369. 		if line[1] == '|': ret['title'] = 1
    3370. 

  3370. 		# Detect border mark and normalize the EOL
    3371. 

  3371. 		m = re.search(' (\|+) *$', line)
    3372. 

  3372. 		if m: line = line+' ' ; ret['border'] = 1
    3373. 

  3373. 		else: line = line+' | '
    3374. 

  3374. 		# Delete table mark
    3375. 

  3375. 		line = regex['table'].sub('', line)
    3376. 

  3376. 		# Detect colspan  | foo | bar baz |||
    3377. 

  3377. 		line = re.sub(' (\|+)\| ', '\a\\1 | ', line)
    3378. 

  3378. 		# Split cells (the last is fake)
    3379. 

  3379. 		ret['cells'] = line.split(' | ')[:-1]
    3380. 

  3380. 		# Find cells span
    3381. 

  3381. 		ret['cellspan'] = self._get_cell_span(ret['cells'])
    3382. 

  3382. 		# Remove span ID
    3383. 

  3383. 		ret['cells'] = map(lambda x:re.sub('\a\|+$','',x),ret['cells'])
    3384. 

  3384. 		# Find cells align
    3385. 

  3385. 		ret['cellalign'] = self._get_cell_align(ret['cells'])
    3386. 

  3386. 		# Hooray!
    3387. 

  3387. 		Debug('Table Prop: %s' % ret, 7)
    3388. 

  3388. 		return ret
    3389. 

  3389. 	
    3390. 

  3390. 	def dump(self):
    3391. 

  3391. 		open  = self._get_open_tag()
    3392. 

  3392. 		rows  = self.rows
    3393. 

  3393. 		close = TAGS['tableClose']
    3394. 

  3394. 		
    3395. 

  3395. 		rowopen     = TAGS['tableRowOpen']
    3396. 

  3396. 		rowclose    = TAGS['tableRowClose']
    3397. 

  3397. 		rowsep      = TAGS['tableRowSep']
    3398. 

  3398. 		titrowopen  = TAGS['tableTitleRowOpen']  or rowopen
    3399. 

  3399. 		titrowclose = TAGS['tableTitleRowClose'] or rowclose
    3400. 

  3400. 		
    3401. 

  3401. 		if rules['breaktablelineopen']:
    3402. 

  3402. 			rowopen = rowopen + '\n'
    3403. 

  3403. 			titrowopen = titrowopen + '\n'
    3404. 

  3404. 		
    3405. 

  3405. 		# Tex gotchas
    3406. 

  3406. 		if TARGET == 'tex':
    3407. 

  3407. 			if not self.border:
    3408. 

  3408. 				rowopen = titrowopen = ''
    3409. 

  3409. 			else:
    3410. 

  3410. 				close = rowopen + close
    3411. 

  3411. 		
    3412. 

  3412. 		# Now we tag all the table cells on each row
    3413. 

  3413. 		#tagged_cells = map(lambda x: self._tag_cells(x), rows) #!py15
    3414. 

  3414. 		tagged_cells = []
    3415. 

  3415. 		for cell in rows: tagged_cells.append(self._tag_cells(cell))
    3416. 

  3416. 		
    3417. 

  3417. 		# Add row separator tags between lines
    3418. 

  3418. 		tagged_rows = []
    3419. 

  3419. 		if rowsep:
    3420. 

  3420. 			#!py15
    3421. 

  3421. 			#tagged_rows = map(lambda x:x+rowsep, tagged_cells)
    3422. 

  3422. 			for cell in tagged_cells:
    3423. 

  3423. 				tagged_rows.append(cell+rowsep)
    3424. 

  3424. 			# Remove last rowsep, because the table is over
    3425. 

  3425. 			tagged_rows[-1] = tagged_rows[-1].replace(rowsep, '')
    3426. 

  3426. 		# Add row BEGIN/END tags for each line
    3427. 

  3427. 		else:
    3428. 

  3428. 			for rowdata in rows:
    3429. 

  3429. 				if rowdata['title']:
    3430. 

  3430. 					o,c = titrowopen, titrowclose
    3431. 

  3431. 				else:
    3432. 

  3432. 					o,c = rowopen, rowclose
    3433. 

  3433. 				row = tagged_cells.pop(0)
    3434. 

  3434. 				tagged_rows.append(o + row + c)
    3435. 

  3435. 		
    3436. 

  3436. 		# Join the pieces together
    3437. 

  3437. 		fulltable = []
    3438. 

  3438. 		if open: fulltable.append(open)
    3439. 

  3439. 		fulltable.extend(tagged_rows)
    3440. 

  3440. 		if close: fulltable.append(close)
    3441. 

  3441. 

  3442. 		return fulltable
    3443. 

  3443. 

  3444. 

  3445. ##############################################################################
    3446. 

  3446. 

  3447. 

  3448. class BlockMaster:
    3449. 

  3449. 	"TIP: use blockin/out to add/del holders"
    3450. 

  3450. 	def __init__(self):
    3451. 

  3451. 		self.BLK = []
    3452. 

  3452. 		self.HLD = []
    3453. 

  3453. 		self.PRP = []
    3454. 

  3454. 		self.depth = 0
    3455. 

  3455. 		self.count = 0
    3456. 

  3456. 		self.last = ''
    3457. 

  3457. 		self.tableparser = None
    3458. 

  3458. 		self.contains = {
    3459. 

  3459. 			'para'    :['comment','raw','tagged'],
    3460. 

  3460. 			'verb'    :[],
    3461. 

  3461. 			'table'   :['comment'],
    3462. 

  3462. 			'raw'     :[],
    3463. 

  3463. 			'tagged'  :[],
    3464. 

  3464. 			'comment' :[],
    3465. 

  3465. 			'quote'   :['quote','comment','raw','tagged'],
    3466. 

  3466. 			'list'    :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3467. 

  3467. 			'numlist' :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3468. 

  3468. 			'deflist' :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3469. 

  3469. 			'bar'     :[],
    3470. 

  3470. 			'title'   :[],
    3471. 

  3471. 			'numtitle':[],
    3472. 

  3472. 		}
    3473. 

  3473. 		self.allblocks = self.contains.keys()
    3474. 

  3474. 

  3475. 		# If one is found inside another, ignore the marks
    3476. 

  3476. 		self.exclusive = ['comment','verb','raw','tagged']
    3477. 

  3477. 		
    3478. 

  3478. 		# May we include bars inside quotes?
    3479. 

  3479. 		if rules['barinsidequote']:
    3480. 

  3480. 			self.contains['quote'].append('bar')
    3481. 

  3481. 	
    3482. 

  3482. 	def block(self):
    3483. 

  3483. 		if not self.BLK: return ''
    3484. 

  3484. 		return self.BLK[-1]
    3485. 

  3485. 	
    3486. 

  3486. 	def isblock(self, name=''):
    3487. 

  3487. 		return self.block() == name
    3488. 

  3488. 	
    3489. 

  3489. 	def prop(self, key):
    3490. 

  3490. 		if not self.PRP: return ''
    3491. 

  3491. 		return self.PRP[-1].get(key) or ''
    3492. 

  3492. 	
    3493. 

  3493. 	def propset(self, key, val):
    3494. 

  3494. 		self.PRP[-1][key] = val
    3495. 

  3495. 		#Debug('BLOCK prop ++: %s->%s'%(key,repr(val)), 1)
    3496. 

  3496. 		#Debug('BLOCK props: %s'%(repr(self.PRP)), 1)
    3497. 

  3497. 	
    3498. 

  3498. 	def hold(self):
    3499. 

  3499. 		if not self.HLD: return []
    3500. 

  3500. 		return self.HLD[-1]
    3501. 

  3501. 	
    3502. 

  3502. 	def holdadd(self, line):
    3503. 

  3503. 		if self.block().endswith('list'): line = [line]
    3504. 

  3504. 		self.HLD[-1].append(line)
    3505. 

  3505. 		Debug('HOLD add: %s'%repr(line), 4)
    3506. 

  3506. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3507. 

  3507. 	
    3508. 

  3508. 	def holdaddsub(self, line):
    3509. 

  3509. 		self.HLD[-1][-1].append(line)
    3510. 

  3510. 		Debug('HOLD addsub: %s'%repr(line), 4)
    3511. 

  3511. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3512. 

  3512. 	
    3513. 

  3513. 	def holdextend(self, lines):
    3514. 

  3514. 		if self.block().endswith('list'): lines = [lines]
    3515. 

  3515. 		self.HLD[-1].extend(lines)
    3516. 

  3516. 		Debug('HOLD extend: %s'%repr(lines), 4)
    3517. 

  3517. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3518. 

  3518. 	
    3519. 

  3519. 	def blockin(self, block):
    3520. 

  3520. 		ret = []
    3521. 

  3521. 		if block not in self.allblocks:
    3522. 

  3522. 			Error("Invalid block '%s'"%block)
    3523. 

  3523. 

  3524. 		# First, let's close other possible open blocks
    3525. 

  3525. 		while self.block() and block not in self.contains[self.block()]:
    3526. 

  3526. 			ret.extend(self.blockout())
    3527. 

  3527. 

  3528. 		# Now we can gladly add this new one
    3529. 

  3529. 		self.BLK.append(block)
    3530. 

  3530. 		self.HLD.append([])
    3531. 

  3531. 		self.PRP.append({})
    3532. 

  3532. 		self.count += 1
    3533. 

  3533. 		if block == 'table': self.tableparser = TableMaster()
    3534. 

  3534. 		# Deeper and deeper
    3535. 

  3535. 		self.depth = len(self.BLK)
    3536. 

  3536. 		Debug('block ++ (%s): %s' % (block,self.BLK), 3)
    3537. 

  3537. 		return ret
    3538. 

  3538. 	
    3539. 

  3539. 	def blockout(self):
    3540. 

  3540. 		if not self.BLK: Error('No block to pop')
    3541. 

  3541. 		blockname = self.BLK.pop()
    3542. 

  3542. 		result = getattr(self, blockname)()
    3543. 

  3543. 		parsed = self.HLD.pop()
    3544. 

  3544. 		self.PRP.pop()
    3545. 

  3545. 		self.depth = len(self.BLK)
    3546. 

  3546. 		if blockname == 'table': del self.tableparser
    3547. 

  3547. 

  3548. 		# Inserting a nested block into mother
    3549. 

  3549. 		if self.block():
    3550. 

  3550. 			if blockname != 'comment': # ignore comment blocks
    3551. 

  3551. 				if self.block().endswith('list'):
    3552. 

  3552. 					self.HLD[-1][-1].append(result)
    3553. 

  3553. 				else:
    3554. 

  3554. 					self.HLD[-1].append(result)
    3555. 

  3555. 			# Reset now. Mother block will have it all
    3556. 

  3556. 			result = []
    3557. 

  3557. 

  3558. 		Debug('block -- (%s): %s' % (blockname,self.BLK), 3)
    3559. 

  3559. 		Debug('RELEASED (%s): %s' % (blockname,parsed), 3)
    3560. 

  3560. 

  3561. 		# Save this top level block name (produced output)
    3562. 

  3562. 		# The next block will use it
    3563. 

  3563. 		if result:
    3564. 

  3564. 			self.last = blockname
    3565. 

  3565. 			Debug('BLOCK: %s'%result, 6)
    3566. 

  3566. 

  3567. 		return result
    3568. 

  3568. 	
    3569. 

  3569. 	def _last_escapes(self, line):
    3570. 

  3570. 		return doFinalEscape(TARGET, line)
    3571. 

  3571. 	
    3572. 

  3572. 	def _get_escaped_hold(self):
    3573. 

  3573. 		ret = []
    3574. 

  3574. 		for line in self.hold():
    3575. 

  3575. 			linetype = type(line)
    3576. 

  3576. 			if linetype == type('') or linetype == type(u''):
    3577. 

  3577. 				ret.append(self._last_escapes(line))
    3578. 

  3578. 			elif linetype == type([]):
    3579. 

  3579. 				ret.extend(line)
    3580. 

  3580. 			else:
    3581. 

  3581. 				Error("BlockMaster: Unknown HOLD item type: %s" % linetype)
    3582. 

  3582. 		return ret
    3583. 

  3583. 	
    3584. 

  3584. 	def _remove_twoblanks(self, lastitem):
    3585. 

  3585. 		if len(lastitem) > 1 and lastitem[-2:] == ['','']:
    3586. 

  3586. 			return lastitem[:-2]
    3587. 

  3587. 		return lastitem
    3588. 

  3588. 	
    3589. 

  3589. 	def _should_add_blank_line(self, where, blockname):
    3590. 

  3590. 		"Validates the blanksaround* rules"
    3591. 

  3591. 

  3592. 		# Nestable blocks: only mother blocks (level 1) are spaced
    3593. 

  3593. 		if blockname.endswith('list') and self.depth > 1:
    3594. 

  3594. 			return False
    3595. 

  3595. 

  3596. 		# The blank line after the block is always added
    3597. 

  3597. 		if where == 'after' \
    3598. 

  3598. 			and rules['blanksaround'+blockname]:
    3599. 

  3599. 			return True
    3600. 

  3600. 

  3601. 		# The blank line before the block is only added if
    3602. 

  3602. 		# the previous block haven't added a blank line
    3603. 

  3603. 		# (to avoid consecutive blanks)
    3604. 

  3604. 		elif where == 'before' \
    3605. 

  3605. 			and rules['blanksaround'+blockname] \
    3606. 

  3606. 			and not rules.get('blanksaround'+self.last):
    3607. 

  3607. 			return True
    3608. 

  3608. 

  3609. 		# Nested quotes are handled here,
    3610. 

  3610. 		# because the mother quote isn't closed yet
    3611. 

  3611. 		elif where == 'before' \
    3612. 

  3612. 			and blockname == 'quote' \
    3613. 

  3613. 			and rules['blanksaround'+blockname] \
    3614. 

  3614. 			and self.depth > 1:
    3615. 

  3615. 			return True
    3616. 

  3616. 

  3617. 		return False
    3618. 

  3618. 

  3619. 	def comment(self):
    3620. 

  3620. 		return ''
    3621. 

  3621. 	
    3622. 

  3622. 	def raw(self):
    3623. 

  3623. 		lines = self.hold()
    3624. 

  3624. 		return map(lambda x: doEscape(TARGET, x), lines)
    3625. 

  3625. 

  3626. 	def tagged(self):
    3627. 

  3627. 		return self.hold()
    3628. 

  3628. 	
    3629. 

  3629. 	def para(self):
    3630. 

  3630. 		result = []
    3631. 

  3631. 		open  = TAGS['paragraphOpen']
    3632. 

  3632. 		close = TAGS['paragraphClose']
    3633. 

  3633. 		lines = self._get_escaped_hold()
    3634. 

  3634. 

  3635. 		# Blank line before?
    3636. 

  3636. 		if self._should_add_blank_line('before', 'para'): result.append('')
    3637. 

  3637. 

  3638. 		# Open tag
    3639. 

  3639. 		if open: result.append(open)
    3640. 

  3640. 

  3641. 		# Pagemaker likes a paragraph as a single long line
    3642. 

  3642. 		if rules['onelinepara']:
    3643. 

  3643. 			result.append(' '.join(lines))
    3644. 

  3644. 		# Others are normal :)
    3645. 

  3645. 		else:
    3646. 

  3646. 			result.extend(lines)
    3647. 

  3647. 

  3648. 		# Close tag
    3649. 

  3649. 		if close: result.append(close)
    3650. 

  3650. 

  3651. 		# Blank line after?
    3652. 

  3652. 		if self._should_add_blank_line('after', 'para'): result.append('')
    3653. 

  3653. 	
    3654. 

  3654. 		# Very very very very very very very very very UGLY fix
    3655. 

  3655. 		# Needed because <center> can't appear inside <p>
    3656. 

  3656. 		try:
    3657. 

  3657. 			if len(lines) == 1 and \
    3658. 

  3658. 			   TARGET in ('html', 'xhtml') and \
    3659. 

  3659. 			   re.match('^\s*<center>.*</center>\s*$', lines[0]):
    3660. 

  3660. 				result = [lines[0]]
    3661. 

  3661. 		except: pass
    3662. 

  3662. 		
    3663. 

  3663. 		return result
    3664. 

  3664. 	
    3665. 

  3665. 	def verb(self):
    3666. 

  3666. 		"Verbatim lines are not masked, so there's no need to unmask"
    3667. 

  3667. 		result = []
    3668. 

  3668. 		open  = TAGS['blockVerbOpen']
    3669. 

  3669. 		close = TAGS['blockVerbClose']
    3670. 

  3670. 

  3671. 		# Blank line before?
    3672. 

  3672. 		if self._should_add_blank_line('before', 'verb'): result.append('')
    3673. 

  3673. 

  3674. 		# Open tag
    3675. 

  3675. 		if open: result.append(open)
    3676. 

  3676. 

  3677. 		# Get contents
    3678. 

  3678. 		for line in self.hold():
    3679. 

  3679. 			if self.prop('mapped') == 'table':
    3680. 

  3680. 				line = MacroMaster().expand(line)
    3681. 

  3681. 			if not rules['verbblocknotescaped']:
    3682. 

  3682. 				line = doEscape(TARGET,line)
    3683. 

  3683. 			if rules['indentverbblock']:
    3684. 

  3684. 				line = '  '+line
    3685. 

  3685. 			if rules['verbblockfinalescape']:
    3686. 

  3686. 				line = doFinalEscape(TARGET, line)
    3687. 

  3687. 			result.append(line)
    3688. 

  3688. 

  3689. 		# Close tag
    3690. 

  3690. 		if close: result.append(close)
    3691. 

  3691. 

  3692. 		# Blank line after?
    3693. 

  3693. 		if self._should_add_blank_line('after', 'verb'): result.append('')
    3694. 

  3694. 

  3695. 		return result
    3696. 

  3696. 

  3697. 	def numtitle(self): return self.title('numtitle')
    3698. 

  3698. 	def title(self, name='title'):
    3699. 

  3699. 		result = []
    3700. 

  3700. 

  3701. 		# Blank line before?
    3702. 

  3702. 		if self._should_add_blank_line('before', name): result.append('')
    3703. 

  3703. 

  3704. 		# Get contents
    3705. 

  3705. 		result.extend(TITLE.get())
    3706. 

  3706. 

  3707. 		# Blank line after?
    3708. 

  3708. 		if self._should_add_blank_line('after', name): result.append('')
    3709. 

  3709. 

  3710. 		return result
    3711. 

  3711. 

  3712. 	def table(self):
    3713. 

  3713. 		result = []
    3714. 

  3714. 

  3715. 		# Blank line before?
    3716. 

  3716. 		if self._should_add_blank_line('before', 'table'): result.append('')
    3717. 

  3717. 

  3718. 		# Rewrite all table cells by the unmasked and escaped data
    3719. 

  3719. 		lines = self._get_escaped_hold()
    3720. 

  3720. 		for i in xrange(len(lines)):
    3721. 

  3721. 			cells = lines[i].split(SEPARATOR)
    3722. 

  3722. 			self.tableparser.rows[i]['cells'] = cells
    3723. 

  3723. 		result.extend(self.tableparser.dump())
    3724. 

  3724. 

  3725. 		# Blank line after?
    3726. 

  3726. 		if self._should_add_blank_line('after', 'table'): result.append('')
    3727. 

  3727. 

  3728. 		return result
    3729. 

  3729. 

  3730. 	def quote(self):
    3731. 

  3731. 		result = []
    3732. 

  3732. 		open   = TAGS['blockQuoteOpen']            # block based
    3733. 

  3733. 		close  = TAGS['blockQuoteClose']
    3734. 

  3734. 		qline  = TAGS['blockQuoteLine']            # line based
    3735. 

  3735. 		indent = tagindent = '\t'*self.depth
    3736. 

  3736. 		
    3737. 

  3737. 		# Apply rules
    3738. 

  3738. 		if rules['tagnotindentable']: tagindent = ''
    3739. 

  3739. 		if not rules['keepquoteindent']: indent = ''
    3740. 

  3740. 		
    3741. 

  3741. 		# Blank line before?
    3742. 

  3742. 		if self._should_add_blank_line('before', 'quote'): result.append('')
    3743. 

  3743. 

  3744. 		# Open tag
    3745. 

  3745. 		if open: result.append(tagindent+open)
    3746. 

  3746. 		
    3747. 

  3747. 		# Get contents
    3748. 

  3748. 		for item in self.hold():
    3749. 

  3749. 			if type(item) == type([]):
    3750. 

  3750. 				result.extend(item)        # subquotes
    3751. 

  3751. 			else:
    3752. 

  3752. 				item = regex['quote'].sub('', item)  # del TABs
    3753. 

  3753. 				item = self._last_escapes(item)
    3754. 

  3754. 				item = qline*self.depth + item
    3755. 

  3755. 				result.append(indent+item) # quote line
    3756. 

  3756. 

  3757. 		# Close tag
    3758. 

  3758. 		if close: result.append(tagindent+close)
    3759. 

  3759. 

  3760. 		# Blank line after?
    3761. 

  3761. 		if self._should_add_blank_line('after', 'quote'): result.append('')
    3762. 

  3762. 		
    3763. 

  3763. 		return result
    3764. 

  3764. 	
    3765. 

  3765. 	def bar(self):
    3766. 

  3766. 		result = []
    3767. 

  3767. 		bar_tag = ''
    3768. 

  3768. 

  3769. 		# Blank line before?
    3770. 

  3770. 		if self._should_add_blank_line('before', 'bar'): result.append('')
    3771. 

  3771. 

  3772. 		# Get the original bar chars
    3773. 

  3773. 		bar_chars = self.hold()[0].strip()
    3774. 

  3774. 

  3775. 		# Set bar type
    3776. 

  3776. 		if bar_chars.startswith('='): bar_tag = TAGS['bar2']
    3777. 

  3777. 		else                        : bar_tag = TAGS['bar1']
    3778. 

  3778. 

  3779. 		# To avoid comment tag confusion like <!-- ------ --> (sgml)
    3780. 

  3780. 		if TAGS['comment'].count('--'):
    3781. 

  3781. 			bar_chars = bar_chars.replace('--', '__')
    3782. 

  3782. 

  3783. 		# Get the bar tag (may contain \a)
    3784. 

  3784. 		result.append(regex['x'].sub(bar_chars, bar_tag))
    3785. 

  3785. 

  3786. 		# Blank line after?
    3787. 

  3787. 		if self._should_add_blank_line('after', 'bar'): result.append('')
    3788. 

  3788. 

  3789. 		return result
    3790. 

  3790. 

  3791. 	def deflist(self): return self.list('deflist')
    3792. 

  3792. 	def numlist(self): return self.list('numlist')
    3793. 

  3793. 	def list(self, name='list'):
    3794. 

  3794. 		result    = []
    3795. 

  3795. 		items     = self.hold()
    3796. 

  3796. 		indent    = self.prop('indent')
    3797. 

  3797. 		tagindent = indent
    3798. 

  3798. 		listline  = TAGS.get(name+'ItemLine')
    3799. 

  3799. 		itemcount = 0
    3800. 

  3800. 

  3801. 		if name == 'deflist':
    3802. 

  3802. 			itemopen  = TAGS[name+'Item1Open']
    3803. 

  3803. 			itemclose = TAGS[name+'Item2Close']
    3804. 

  3804. 			itemsep   = TAGS[name+'Item1Close']+\
    3805. 

  3805. 			            TAGS[name+'Item2Open']
    3806. 

  3806. 		else:
    3807. 

  3807. 			itemopen  = TAGS[name+'ItemOpen']
    3808. 

  3808. 			itemclose = TAGS[name+'ItemClose']
    3809. 

  3809. 			itemsep   = ''
    3810. 

  3810. 		
    3811. 

  3811. 		# Apply rules
    3812. 

  3812. 		if rules['tagnotindentable']: tagindent = ''
    3813. 

  3813. 		if not rules['keeplistindent']: indent = tagindent = ''
    3814. 

  3814. 

  3815. 		# ItemLine: number of leading chars identifies list depth
    3816. 

  3816. 		if listline:
    3817. 

  3817. 			itemopen  = listline*self.depth + itemopen
    3818. 

  3818. 		
    3819. 

  3819. 		# Adds trailing space on opening tags
    3820. 

  3820. 		if (name == 'list'    and rules['spacedlistitemopen']) or \
    3821. 

  3821. 		   (name == 'numlist' and rules['spacednumlistitemopen']):
    3822. 

  3822. 			itemopen = itemopen + ' '
    3823. 

  3823. 			
    3824. 

  3824. 		# Remove two-blanks from list ending mark, to avoid <p>
    3825. 

  3825. 		items[-1] = self._remove_twoblanks(items[-1])
    3826. 

  3826. 

  3827. 		# Blank line before?
    3828. 

  3828. 		if self._should_add_blank_line('before', name): result.append('')
    3829. 

  3829. 

  3830. 		# Tag each list item (multiline items), store in listbody
    3831. 

  3831. 		itemopenorig = itemopen
    3832. 

  3832. 		listbody = []
    3833. 

  3833. 		widelist = 0
    3834. 

  3834. 		for item in items:
    3835. 

  3835. 			
    3836. 

  3836. 			# Add "manual" item count for noautonum targets
    3837. 

  3837. 			itemcount += 1
    3838. 

  3838. 			if name == 'numlist' and not rules['autonumberlist']:
    3839. 

  3839. 				n = str(itemcount)
    3840. 

  3840. 				itemopen = regex['x'].sub(n, itemopenorig)
    3841. 

  3841. 				del n
    3842. 

  3842. 

  3843. 			# Tag it
    3844. 

  3844. 			item[0] = self._last_escapes(item[0])
    3845. 

  3845. 			if name == 'deflist':
    3846. 

  3846. 				z,term,rest = item[0].split(SEPARATOR, 2)
    3847. 

  3847. 				item[0] = rest
    3848. 

  3848. 				if not item[0]: del item[0]      # to avoid <p>
    3849. 

  3849. 				listbody.append(tagindent+itemopen+term+itemsep)
    3850. 

  3850. 			else:
    3851. 

  3851. 				fullitem = tagindent+itemopen
    3852. 

  3852. 				listbody.append(item[0].replace(SEPARATOR, fullitem))
    3853. 

  3853. 				del item[0]
    3854. 

  3854. 			
    3855. 

  3855. 			# Process next lines for this item (if any)
    3856. 

  3856. 			for line in item:
    3857. 

  3857. 				if type(line) == type([]): # sublist inside
    3858. 

  3858. 					listbody.extend(line)
    3859. 

  3859. 				else:
    3860. 

  3860. 					line = self._last_escapes(line)
    3861. 

  3861. 					
    3862. 

  3862. 					# Blank lines turns to <p>
    3863. 

  3863. 					if not line and rules['parainsidelist']:
    3864. 

  3864. 						line = indent + TAGS['paragraphOpen'] + TAGS['paragraphClose']
    3865. 

  3865. 						line = line.rstrip()
    3866. 

  3866. 						widelist = 1
    3867. 

  3867. 						
    3868. 

  3868. 					# Some targets don't like identation here (wiki)
    3869. 

  3869. 					if not rules['keeplistindent'] or (name == 'deflist' and rules['deflisttextstrip']):
    3870. 

  3870. 						line = line.lstrip()
    3871. 

  3871. 

  3872. 					# Maybe we have a line prefix to add? (wiki)
    3873. 

  3873. 					if name == 'deflist' and TAGS['deflistItem2LinePrefix']:
    3874. 

  3874. 						line = TAGS['deflistItem2LinePrefix'] + line
    3875. 

  3875. 						
    3876. 

  3876. 					listbody.append(line)
    3877. 

  3877. 			
    3878. 

  3878. 			# Close item (if needed)
    3879. 

  3879. 			if itemclose: listbody.append(tagindent+itemclose)
    3880. 

  3880. 		
    3881. 

  3881. 		if not widelist and rules['compactlist']:
    3882. 

  3882. 			listopen = TAGS.get(name+'OpenCompact')
    3883. 

  3883. 			listclose = TAGS.get(name+'CloseCompact')
    3884. 

  3884. 		else:
    3885. 

  3885. 			listopen  = TAGS.get(name+'Open')
    3886. 

  3886. 			listclose = TAGS.get(name+'Close')
    3887. 

  3887. 

  3888. 		# Open list (not nestable lists are only opened at mother)
    3889. 

  3889. 		if listopen and not \
    3890. 

  3890. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    3891. 

  3891. 			result.append(tagindent+listopen)
    3892. 

  3892. 

  3893. 		result.extend(listbody)
    3894. 

  3894. 		
    3895. 

  3895. 		# Close list (not nestable lists are only closed at mother)
    3896. 

  3896. 		if listclose and not \
    3897. 

  3897. 		   (rules['listnotnested'] and self.depth != 1):
    3898. 

  3898. 			result.append(tagindent+listclose)
    3899. 

  3899. 

  3900. 		# Blank line after?
    3901. 

  3901. 		if self._should_add_blank_line('after', name): result.append('')
    3902. 

  3902. 

  3903. 		return result
    3904. 

  3904. 

  3905. 

  3906. ##############################################################################
    3907. 

  3907. 

  3908. 

  3909. class MacroMaster:
    3910. 

  3910. 	def __init__(self, config={}):
    3911. 

  3911. 		self.name     = ''
    3912. 

  3912. 		self.config   = config or CONF
    3913. 

  3913. 		self.infile   = self.config['sourcefile']
    3914. 

  3914. 		self.outfile  = self.config['outfile']
    3915. 

  3915. 		self.currdate = time.localtime(time.time())
    3916. 

  3916. 		self.rgx      = regex.get('macros') or getRegexes()['macros']
    3917. 

  3917. 		self.fileinfo = { 'infile': None, 'outfile': None }
    3918. 

  3918. 		self.dft_fmt  = MACROS
    3919. 

  3919. 	
    3920. 

  3920. 	def walk_file_format(self, fmt):
    3921. 

  3921. 		"Walks the %%{in/out}file format string, expanding the % flags"
    3922. 

  3922. 		i = 0; ret = ''                                 # counter/hold
    3923. 

  3923. 		while i < len(fmt):                             # char by char
    3924. 

  3924. 			c = fmt[i]; i += 1
    3925. 

  3925. 			if c == '%':                            # hot char!
    3926. 

  3926. 				if i == len(fmt):               # % at the end
    3927. 

  3927. 					ret = ret + c
    3928. 

  3928. 					break
    3929. 

  3929. 				c = fmt[i]; i += 1              # read next
    3930. 

  3930. 				ret = ret + self.expand_file_flag(c)
    3931. 

  3931. 			else:
    3932. 

  3932. 				ret = ret +c                    # common char
    3933. 

  3933. 		return ret
    3934. 

  3934. 	
    3935. 

  3935. 	def expand_file_flag(self, flag):
    3936. 

  3936. 		"%f: filename          %F: filename (w/o extension)"
    3937. 

  3937. 		"%d: dirname           %D: dirname (only parent dir)"
    3938. 

  3938. 		"%p: file path         %e: extension"
    3939. 

  3939. 		info = self.fileinfo[self.name]           # get dict
    3940. 

  3940. 		if   flag == '%': x = '%'                 # %% -> %
    3941. 

  3941. 		elif flag == 'f': x = info['name']
    3942. 

  3942. 		elif flag == 'F': x = re.sub('\.[^.]*$','',info['name'])
    3943. 

  3943. 		elif flag == 'd': x = info['dir']
    3944. 

  3944. 		elif flag == 'D': x = os.path.split(info['dir'])[-1]
    3945. 

  3945. 		elif flag == 'p': x = info['path']
    3946. 

  3946. 		elif flag == 'e': x = re.search('.(\.([^.]+))?$', info['name']).group(2) or ''
    3947. 

  3947. 		#TODO simpler way for %e ?
    3948. 

  3948. 		else            : x = '%'+flag            # false alarm
    3949. 

  3949. 		return x
    3950. 

  3950. 	
    3951. 

  3951. 	def set_file_info(self, macroname):
    3952. 

  3952. 		if self.fileinfo.get(macroname): return   # already done
    3953. 

  3953. 		file = getattr(self, self.name)           # self.infile
    3954. 

  3954. 		if file == STDOUT or file == MODULEOUT:
    3955. 

  3955. 			dir = ''; path = name = file
    3956. 

  3956. 		else:
    3957. 

  3957. 			path = os.path.abspath(file)
    3958. 

  3958. 			dir  = os.path.dirname(path)
    3959. 

  3959. 			name = os.path.basename(path)
    3960. 

  3960. 		self.fileinfo[macroname] = {'path':path,'dir':dir,'name':name}
    3961. 

  3961. 	
    3962. 

  3962. 	def expand(self, line=''):
    3963. 

  3963. 		"Expand all macros found on the line"
    3964. 

  3964. 		while self.rgx.search(line):
    3965. 

  3965. 			m = self.rgx.search(line)
    3966. 

  3966. 			name = self.name = m.group('name').lower()
    3967. 

  3967. 			fmt = m.group('fmt') or self.dft_fmt.get(name)
    3968. 

  3968. 			if name == 'date':
    3969. 

  3969. 				txt = time.strftime(fmt,self.currdate)
    3970. 

  3970. 			elif name == 'mtime':
    3971. 

  3971. 				if self.infile in (STDIN, MODULEIN):
    3972. 

  3972. 					fdate = self.currdate
    3973. 

  3973. 				else:
    3974. 

  3974. 					mtime = os.path.getmtime(self.infile)
    3975. 

  3975. 					fdate = time.localtime(mtime)
    3976. 

  3976. 				txt = time.strftime(fmt,fdate)
    3977. 

  3977. 			elif name == 'infile' or name == 'outfile':
    3978. 

  3978. 				self.set_file_info(name)
    3979. 

  3979. 				txt = self.walk_file_format(fmt)
    3980. 

  3980. 			else:
    3981. 

  3981. 				Error("Unknown macro name '%s'"%name)
    3982. 

  3982. 			line = self.rgx.sub(txt,line,1)
    3983. 

  3983. 		return line
    3984. 

  3984. 

  3985. 

  3986. ##############################################################################
    3987. 

  3987. 

  3988. 

  3989. def dumpConfig(source_raw, parsed_config):
    3990. 

  3990. 	onoff = {1:_('ON'), 0:_('OFF')}
    3991. 

  3991. 	data = [
    3992. 

  3992. 		(_('RC file')        , RC_RAW     ),
    3993. 

  3993. 		(_('source document'), source_raw ),
    3994. 

  3994. 		(_('command line')   , CMDLINE_RAW)
    3995. 

  3995. 	]
    3996. 

  3996. 	# First show all RAW data found
    3997. 

  3997. 	for label, cfg in data:
    3998. 

  3998. 		print _('RAW config for %s')%label
    3999. 

  3999. 		for target,key,val in cfg:
    4000. 

  4000. 			target = '(%s)'%target
    4001. 

  4001. 			key    = dotted_spaces("%-14s"%key)
    4002. 

  4002. 			val    = val or _('ON')
    4003. 

  4003. 			print '  %-8s %s: %s'%(target,key,val)
    4004. 

  4004. 		print
    4005. 

  4005. 	# Then the parsed results of all of them
    4006. 

  4006. 	print _('Full PARSED config')
    4007. 

  4007. 	keys = parsed_config.keys() ; keys.sort()  # sorted
    4008. 

  4008. 	for key in keys:
    4009. 

  4009. 		val = parsed_config[key]
    4010. 

  4010. 		# Filters are the last
    4011. 

  4011. 		if key == 'preproc' or key == 'postproc':
    4012. 

  4012. 			continue
    4013. 

  4013. 		# Flag beautifier
    4014. 

  4014. 		if key in FLAGS.keys() or key in ACTIONS.keys():
    4015. 

  4015. 			val = onoff.get(val) or val
    4016. 

  4016. 		# List beautifier
    4017. 

  4017. 		if type(val) == type([]):
    4018. 

  4018. 			if key == 'options': sep = ' '
    4019. 

  4019. 			else               : sep = ', '
    4020. 

  4020. 			val = sep.join(val)
    4021. 

  4021. 		print "%25s: %s"%(dotted_spaces("%-14s"%key),val)
    4022. 

  4022. 	print
    4023. 

  4023. 	print _('Active filters')
    4024. 

  4024. 	for filter in ['preproc', 'postproc']:
    4025. 

  4025. 		for rule in parsed_config.get(filter) or []:
    4026. 

  4026. 			print "%25s: %s  ->  %s" % (
    4027. 

  4027. 				dotted_spaces("%-14s"%filter), rule[0], rule[1])
    4028. 

  4028. 

  4029. 

  4030. def get_file_body(file):
    4031. 

  4031. 	"Returns all the document BODY lines"
    4032. 

  4032. 	return process_source_file(file, noconf=1)[1][2]
    4033. 

  4033. 

  4034. 

  4035. def finish_him(outlist, config):
    4036. 

  4036. 	"Writing output to screen or file"
    4037. 

  4037. 	outfile = config['outfile']
    4038. 

  4038. 	outlist = unmaskEscapeChar(outlist)
    4039. 

  4039. 	outlist = expandLineBreaks(outlist)
    4040. 

  4040. 	
    4041. 

  4041. 	# Apply PostProc filters
    4042. 

  4042. 	if config['postproc']:
    4043. 

  4043. 		filters = compile_filters(config['postproc'],
    4044. 

  4044. 			_('Invalid PostProc filter regex'))
    4045. 

  4045. 		postoutlist = []
    4046. 

  4046. 		errmsg = _('Invalid PostProc filter replacement')
    4047. 

  4047. 		for line in outlist:
    4048. 

  4048. 			for rgx,repl in filters:
    4049. 

  4049. 				try: line = rgx.sub(repl, line)
    4050. 

  4050. 				except: Error("%s: '%s'"%(errmsg, repl))
    4051. 

  4051. 			postoutlist.append(line)
    4052. 

  4052. 		outlist = postoutlist[:]
    4053. 

  4053. 	
    4054. 

  4054. 	if outfile == MODULEOUT:
    4055. 

  4055. 		return outlist
    4056. 

  4056. 	elif outfile == STDOUT:
    4057. 

  4057. 		if GUI:
    4058. 

  4058. 			return outlist, config
    4059. 

  4059. 		else:
    4060. 

  4060. 			for line in outlist: print line
    4061. 

  4061. 	else:
    4062. 

  4062. 		Savefile(outfile, addLineBreaks(outlist))
    4063. 

  4063. 		if not GUI and not QUIET:
    4064. 

  4064. 			print _('%s wrote %s')%(my_name,outfile)
    4065. 

  4065. 	
    4066. 

  4066. 	if config['split']:
    4067. 

  4067. 		if not QUIET: print "--- html..."
    4068. 

  4068. 		sgml2html = 'sgml2html -s %s -l %s %s' % (
    4069. 

  4069. 			config['split'], config['lang'] or lang, outfile)
    4070. 

  4070. 		if not QUIET: print "Running system command:", sgml2html
    4071. 

  4071. 		os.system(sgml2html)
    4072. 

  4072. 

  4073. 

  4074. def toc_inside_body(body, toc, config):
    4075. 

  4075. 	ret = []
    4076. 

  4076. 	if AUTOTOC: return body                     # nothing to expand
    4077. 

  4077. 	toc_mark = MaskMaster().tocmask
    4078. 

  4078. 	# Expand toc mark with TOC contents
    4079. 

  4079. 	for line in body:
    4080. 

  4080. 		if line.count(toc_mark):            # toc mark found
    4081. 

  4081. 			if config['toc']:
    4082. 

  4082. 				ret.extend(toc)     # include if --toc
    4083. 

  4083. 			else:
    4084. 

  4084. 				pass                # or remove %%toc line
    4085. 

  4085. 		else:
    4086. 

  4086. 			ret.append(line)            # common line
    4087. 

  4087. 	return ret
    4088. 

  4088. 

  4089. def toc_tagger(toc, config):
    4090. 

  4090. 	"Convert t2t-marked TOC (it is a list) to target-tagged TOC"
    4091. 

  4091. 	ret = []
    4092. 

  4092. 	# Tag if TOC-only TOC "by hand" (target don't have a TOC tag)
    4093. 

  4093. 	if config['toc-only'] or (config['toc'] and not TAGS['TOC']):
    4094. 

  4094. 		fakeconf = config.copy()
    4095. 

  4095. 		fakeconf['headers']    = 0
    4096. 

  4096. 		fakeconf['toc-only']   = 0
    4097. 

  4097. 		fakeconf['mask-email'] = 0
    4098. 

  4098. 		fakeconf['preproc']    = []
    4099. 

  4099. 		fakeconf['postproc']   = []
    4100. 

  4100. 		fakeconf['css-sugar']  = 0
    4101. 

  4101. 		ret,foo = convert(toc, fakeconf)
    4102. 

  4102. 		set_global_config(config)   # restore config
    4103. 

  4103. 	# Target TOC is a tag
    4104. 

  4104. 	elif config['toc'] and TAGS['TOC']:
    4105. 

  4105. 		ret = [TAGS['TOC']]
    4106. 

  4106. 	return ret
    4107. 

  4107. 

  4108. def toc_formatter(toc, config):
    4109. 

  4109. 	"Formats TOC for automatic placement between headers and body"
    4110. 

  4110. 	if config['toc-only']: return toc              # no formatting needed
    4111. 

  4111. 	if not config['toc'] : return []               # TOC disabled
    4112. 

  4112. 	ret = toc
    4113. 

  4113. 	# TOC open/close tags (if any)
    4114. 

  4114. 	if TAGS['tocOpen' ]: ret.insert(0, TAGS['tocOpen'])
    4115. 

  4115. 	if TAGS['tocClose']: ret.append(TAGS['tocClose'])
    4116. 

  4116. 	# Autotoc specific formatting
    4117. 

  4117. 	if AUTOTOC:
    4118. 

  4118. 		if rules['autotocwithbars']:           # TOC between bars
    4119. 

  4119. 			para = TAGS['paragraphOpen']+TAGS['paragraphClose']
    4120. 

  4120. 			bar  = regex['x'].sub('-'*72,TAGS['bar1'])
    4121. 

  4121. 			tocbar = [para, bar, para]
    4122. 

  4122. 			ret = tocbar + ret + tocbar
    4123. 

  4123. 		if rules['blankendautotoc']:           # blank line after TOC
    4124. 

  4124. 			ret.append('')
    4125. 

  4125. 		if rules['autotocnewpagebefore']:      # page break before TOC
    4126. 

  4126. 			ret.insert(0,TAGS['pageBreak'])
    4127. 

  4127. 		if rules['autotocnewpageafter']:       # page break after TOC
    4128. 

  4128. 			ret.append(TAGS['pageBreak'])
    4129. 

  4129. 	return ret
    4130. 

  4130. 

  4131. 

  4132. def doHeader(headers, config):
    4133. 

  4133. 	if not config['headers']: return []
    4134. 

  4134. 	if not headers: headers = ['','','']
    4135. 

  4135. 	target = config['target']
    4136. 

  4136. 	if not HEADER_TEMPLATE.has_key(target):
    4137. 

  4137. 		Error("doHeader: Unknown target '%s'"%target)
    4138. 

  4138. 	
    4139. 

  4139. 	if target in ('html','xhtml') and config.get('css-sugar'):
    4140. 

  4140. 		template = HEADER_TEMPLATE[target+'css'].split('\n')
    4141. 

  4141. 	else:
    4142. 

  4142. 		template = HEADER_TEMPLATE[target].split('\n')
    4143. 

  4143. 	
    4144. 

  4144. 	head_data = {'STYLE':[], 'ENCODING':''}
    4145. 

  4145. 	for key in head_data.keys():
    4146. 

  4146. 		val = config.get(key.lower())
    4147. 

  4147. 		# Remove .sty extension from each style filename (freaking tex)
    4148. 

  4148. 		# XXX Can't handle --style foo.sty,bar.sty
    4149. 

  4149. 		if target == 'tex' and key == 'STYLE':
    4150. 

  4150. 			val = map(lambda x:re.sub('(?i)\.sty$','',x), val)
    4151. 

  4151. 		if key == 'ENCODING':
    4152. 

  4152. 			val = get_encoding_string(val, target)
    4153. 

  4153. 		head_data[key] = val
    4154. 

  4154. 	# Parse header contents
    4155. 

  4155. 	for i in 0,1,2:
    4156. 

  4156. 		# Expand macros
    4157. 

  4157. 		contents = MacroMaster(config=config).expand(headers[i])
    4158. 

  4158. 		# Escapes - on tex, just do it if any \tag{} present
    4159. 

  4159. 		if target != 'tex' or \
    4160. 

  4160. 		  (target == 'tex' and re.search(r'\\\w+{', contents)):
    4161. 

  4161. 			contents = doEscape(target, contents)
    4162. 

  4162. 		if target == 'lout':
    4163. 

  4163. 			contents = doFinalEscape(target, contents)
    4164. 

  4164. 		
    4165. 

  4165. 		head_data['HEADER%d'%(i+1)] = contents
    4166. 

  4166. 	
    4167. 

  4167. 	if target == 'art':
    4168. 

  4168. 		if not [v for v in head_data.values() if v]:
    4169. 

  4169. 			return []
    4170. 

  4170. 		template = aa_header(head_data)
    4171. 

  4171. 		return template.split('\n')
    4172. 

  4172. 	
    4173. 

  4173. 	# css-inside removes STYLE line
    4174. 

  4174. 	#XXX In tex, this also removes the modules call (%!style:amsfonts)
    4175. 

  4175. 	if target in ('html','xhtml') and config.get('css-inside') and \
    4176. 

  4176. 	   config.get('style'):
    4177. 

  4177. 		head_data['STYLE'] = []
    4178. 

  4178. 	Debug("Header Data: %s"%head_data, 1)
    4179. 

  4179. 	# Scan for empty dictionary keys
    4180. 

  4180. 	# If found, scan template lines for that key reference
    4181. 

  4181. 	# If found, remove the reference
    4182. 

  4182. 	# If there isn't any other key reference on the same line, remove it
    4183. 

  4183. 	#TODO loop by template line > key
    4184. 

  4184. 	for key in head_data.keys():
    4185. 

  4185. 		if head_data.get(key): continue
    4186. 

  4186. 		for line in template:
    4187. 

  4187. 			if line.count('%%(%s)s'%key):
    4188. 

  4188. 				sline = line.replace('%%(%s)s'%key, '')
    4189. 

  4189. 				if not re.search(r'%\([A-Z0-9]+\)s', sline):
    4190. 

  4190. 					template.remove(line)
    4191. 

  4191. 	# Style is a multiple tag.
    4192. 

  4192. 	# - If none or just one, use default template
    4193. 

  4193. 	# - If two or more, insert extra lines in a loop (and remove original)
    4194. 

  4194. 	styles = head_data['STYLE']
    4195. 

  4195. 	if len(styles) == 1:
    4196. 

  4196. 		head_data['STYLE'] = styles[0]
    4197. 

  4197. 	elif len(styles) > 1:
    4198. 

  4198. 		style_mark = '%(STYLE)s'
    4199. 

  4199. 		for i in xrange(len(template)):
    4200. 

  4200. 			if template[i].count(style_mark):
    4201. 

  4201. 				while styles:
    4202. 

  4202. 					template.insert(i+1, template[i].replace(style_mark, styles.pop()))
    4203. 

  4203. 				del template[i]
    4204. 

  4204. 				break
    4205. 

  4205. 	# Populate template with data (dict expansion)
    4206. 

  4206. 	template = '\n'.join(template) % head_data
    4207. 

  4207. 	
    4208. 

  4208. 	# Adding CSS contents into template (for --css-inside)
    4209. 

  4209. 	# This code sux. Dirty++
    4210. 

  4210. 	if target in ('html','xhtml') and config.get('css-inside') and \
    4211. 

  4211. 	   config.get('style'):
    4212. 

  4212. 		set_global_config(config) # usually on convert(), needed here
    4213. 

  4213. 		for i in xrange(len(config['style'])):
    4214. 

  4214. 			cssfile = config['style'][i]
    4215. 

  4215. 			if not os.path.isabs(cssfile):
    4216. 

  4216. 				infile = config.get('sourcefile')
    4217. 

  4217. 				cssfile = os.path.join(
    4218. 

  4218. 					os.path.dirname(infile), cssfile)
    4219. 

  4219. 			try:
    4220. 

  4220. 				contents = Readfile(cssfile, 1)
    4221. 

  4221. 				css = "\n%s\n%s\n%s\n%s\n" % (
    4222. 

  4222. 					doCommentLine("Included %s" % cssfile),
    4223. 

  4223. 					TAGS['cssOpen'],
    4224. 

  4224. 					'\n'.join(contents),
    4225. 

  4225. 					TAGS['cssClose'])
    4226. 

  4226. 				# Style now is content, needs escaping (tex)
    4227. 

  4227. 				#css = maskEscapeChar(css)
    4228. 

  4228. 			except:
    4229. 

  4229. 				errmsg = "CSS include failed for %s" % cssfile
    4230. 

  4230. 				css = "\n%s\n" % (doCommentLine(errmsg))
    4231. 

  4231. 			# Insert this CSS file contents on the template
    4232. 

  4232. 			template = re.sub('(?i)(</HEAD>)', css+r'\1', template)
    4233. 

  4233. 			# template = re.sub(r'(?i)(\\begin{document})',
    4234. 

  4234. 			#		css+'\n'+r'\1', template) # tex
    4235. 

  4235. 		
    4236. 

  4236. 		# The last blank line to keep everything separated
    4237. 

  4237. 		template = re.sub('(?i)(</HEAD>)', '\n'+r'\1', template)
    4238. 

  4238. 	
    4239. 

  4239. 	return template.split('\n')
    4240. 

  4240. 

  4241. def doCommentLine(txt):
    4242. 

  4242. 	# The -- string ends a (h|sg|xht)ml comment :(
    4243. 

  4243. 	txt = maskEscapeChar(txt)
    4244. 

  4244. 	if TAGS['comment'].count('--') and txt.count('--'):
    4245. 

  4245. 		txt = re.sub('-(?=-)', r'-\\', txt)
    4246. 

  4246. 	
    4247. 

  4247. 	if TAGS['comment']:
    4248. 

  4248. 		return regex['x'].sub(txt, TAGS['comment'])
    4249. 

  4249. 	return ''
    4250. 

  4250. 

  4251. def doFooter(config):
    4252. 

  4252. 	if not config['headers']: return []
    4253. 

  4253. 	ret = []
    4254. 

  4254. 	target = config['target']
    4255. 

  4255. 	cmdline = config['realcmdline']
    4256. 

  4256. 	typename = target
    4257. 

  4257. 	if target == 'tex': typename = 'LaTeX2e'
    4258. 

  4258. 	ppgd = '%s code generated by %s %s (%s)' % (typename, my_name, my_version, my_url)
    4259. 

  4259. 	cmdline = 'cmdline: %s %s' % (my_name, ' '.join(cmdline))
    4260. 

  4260. 	ret.append('')
    4261. 

  4261. 	ret.append(doCommentLine(ppgd))
    4262. 

  4262. 	ret.append(doCommentLine(cmdline))
    4263. 

  4263. 	ret.append(TAGS['EOD'])
    4264. 

  4264. 	return ret
    4265. 

  4265. 

  4266. def doEscape(target,txt):
    4267. 

  4267. 	"Target-specific special escapes. Apply *before* insert any tag."
    4268. 

  4268. 	tmpmask = 'vvvvThisEscapingSuxvvvv'
    4269. 

  4269. 	if target in ('html','sgml','xhtml'):
    4270. 

  4270. 		txt = re.sub('&','&amp;',txt)
    4271. 

  4271. 		txt = re.sub('<','&lt;',txt)
    4272. 

  4272. 		txt = re.sub('>','&gt;',txt)
    4273. 

  4273. 		if target == 'sgml':
    4274. 

  4274. 			txt = re.sub('\xff','&yuml;',txt)  # "+y
    4275. 

  4275. 	elif target == 'pm6':
    4276. 

  4276. 		txt = re.sub('<','<\#60>',txt)
    4277. 

  4277. 	elif target == 'mgp':
    4278. 

  4278. 		txt = re.sub('^%',' %',txt)  # add leading blank to avoid parse
    4279. 

  4279. 	elif target == 'man':
    4280. 

  4280. 		txt = re.sub("^([.'])", '\\&\\1',txt)           # command ID
    4281. 

  4281. 		txt = txt.replace(ESCCHAR, ESCCHAR+'e')         # \e
    4282. 

  4282. 	elif target == 'lout':
    4283. 

  4283. 		# TIP: / moved to FinalEscape to avoid //italic//
    4284. 

  4284. 		# TIP: these are also converted by lout:  ...  ---  --
    4285. 

  4285. 		txt = txt.replace(ESCCHAR, tmpmask)             # \
    4286. 

  4286. 		txt = txt.replace('"', '"%s""'%ESCCHAR)         # "\""
    4287. 

  4287. 		txt = re.sub('([|&{}@#^~])', '"\\1"', txt)      # "@"
    4288. 

  4288. 		txt = txt.replace(tmpmask, '"%s"'%(ESCCHAR*2))  # "\\"
    4289. 

  4289. 	elif target == 'tex':
    4290. 

  4290. 		# Mark literal \ to be changed to $\backslash$ later
    4291. 

  4291. 		txt = txt.replace(ESCCHAR, tmpmask)
    4292. 

  4292. 		txt = re.sub('([#$&%{}])', ESCCHAR+r'\1'  , txt)  # \%
    4293. 

  4293. 		txt = re.sub('([~^])'    , ESCCHAR+r'\1{}', txt)  # \~{}
    4294. 

  4294. 		txt = re.sub('([<|>])'   ,         r'$\1$', txt)  # $>$
    4295. 

  4295. 		txt = txt.replace(tmpmask, maskEscapeChar(r'$\backslash$'))
    4296. 

  4296. 		# TIP the _ is escaped at the end
    4297. 

  4297. 	return txt
    4298. 

  4298. 

  4299. # TODO man: where - really needs to be escaped?
    4300. 

  4300. def doFinalEscape(target, txt):
    4301. 

  4301. 	"Last escapes of each line"
    4302. 

  4302. 	if   target == 'pm6' : txt = txt.replace(ESCCHAR+'<', r'<\#92><')
    4303. 

  4303. 	elif target == 'man' : txt = txt.replace('-', r'\-')
    4304. 

  4304. 	elif target == 'sgml': txt = txt.replace('[', '&lsqb;')
    4305. 

  4305. 	elif target == 'lout': txt = txt.replace('/', '"/"')
    4306. 

  4306. 	elif target == 'tex' :
    4307. 

  4307. 		txt = txt.replace('_', r'\_')
    4308. 

  4308. 		txt = txt.replace('vvvvTexUndervvvv', '_')  # shame!
    4309. 

  4309. 	return txt
    4310. 

  4310. 

  4311. def EscapeCharHandler(action, data):
    4312. 

  4312. 	"Mask/Unmask the Escape Char on the given string"
    4313. 

  4313. 	if not data.strip(): return data
    4314. 

  4314. 	if action not in ('mask','unmask'):
    4315. 

  4315. 		Error("EscapeCharHandler: Invalid action '%s'"%action)
    4316. 

  4316. 	if action == 'mask': return data.replace('\\', ESCCHAR)
    4317. 

  4317. 	else:                return data.replace(ESCCHAR, '\\')
    4318. 

  4318. 

  4319. def maskEscapeChar(data):
    4320. 

  4320. 	"Replace any Escape Char \ with a text mask (Input: str or list)"
    4321. 

  4321. 	if type(data) == type([]):
    4322. 

  4322. 		return map(lambda x: EscapeCharHandler('mask', x), data)
    4323. 

  4323. 	return EscapeCharHandler('mask',data)
    4324. 

  4324. 

  4325. def unmaskEscapeChar(data):
    4326. 

  4326. 	"Undo the Escape char \ masking (Input: str or list)"
    4327. 

  4327. 	if type(data) == type([]):
    4328. 

  4328. 		return map(lambda x: EscapeCharHandler('unmask', x), data)
    4329. 

  4329. 	return EscapeCharHandler('unmask',data)
    4330. 

  4330. 

  4331. def addLineBreaks(mylist):
    4332. 

  4332. 	"use LB to respect sys.platform"
    4333. 

  4333. 	ret = []
    4334. 

  4334. 	for line in mylist:
    4335. 

  4335. 		line = line.replace('\n', LB)        # embedded \n's
    4336. 

  4336. 		ret.append(line+LB)                  # add final line break
    4337. 

  4337. 	return ret
    4338. 

  4338. 

  4339. # Convert ['foo\nbar'] to ['foo', 'bar']
    4340. 

  4340. def expandLineBreaks(mylist):
    4341. 

  4341. 	ret = []
    4342. 

  4342. 	for line in mylist:
    4343. 

  4343. 		ret.extend(line.split('\n'))
    4344. 

  4344. 	return ret
    4345. 

  4345. 

  4346. def compile_filters(filters, errmsg='Filter'):
    4347. 

  4347. 	if filters:
    4348. 

  4348. 		for i in xrange(len(filters)):
    4349. 

  4349. 			patt,repl = filters[i]
    4350. 

  4350. 			try: rgx = re.compile(patt)
    4351. 

  4351. 			except: Error("%s: '%s'"%(errmsg, patt))
    4352. 

  4352. 			filters[i] = (rgx,repl)
    4353. 

  4353. 	return filters
    4354. 

  4354. 

  4355. def enclose_me(tagname, txt):
    4356. 

  4356. 	return TAGS.get(tagname+'Open') + txt + TAGS.get(tagname+'Close')
    4357. 

  4357. 

  4358. def beautify_me(name, line):
    4359. 

  4359. 	"where name is: bold, italic, underline or strike"
    4360. 

  4360. 

  4361. 	# Exception: Doesn't parse an horizontal bar as strike
    4362. 

  4362. 	if name == 'strike' and regex['bar'].search(line): return line
    4363. 

  4363. 	
    4364. 

  4364. 	name  = 'font%s' % name.capitalize()
    4365. 

  4365. 	open  = TAGS['%sOpen'%name]
    4366. 

  4366. 	close = TAGS['%sClose'%name]
    4367. 

  4367. 	txt = r'%s\1%s'%(open, close)
    4368. 

  4368. 	line = regex[name].sub(txt,line)
    4369. 

  4369. 	return line
    4370. 

  4370. 

  4371. def get_tagged_link(label, url):
    4372. 

  4372. 	ret = ''
    4373. 

  4373. 	target = CONF['target']
    4374. 

  4374. 	image_re = regex['img']
    4375. 

  4375. 	
    4376. 

  4376. 	# Set link type
    4377. 

  4377. 	if regex['email'].match(url):
    4378. 

  4378. 		linktype = 'email'
    4379. 

  4379. 	else:
    4380. 

  4380. 		linktype = 'url';
    4381. 

  4381. 	
    4382. 

  4382. 	# Escape specials from TEXT parts
    4383. 

  4383. 	label = doEscape(target,label)
    4384. 

  4384. 	
    4385. 

  4385. 	# Escape specials from link URL
    4386. 

  4386. 	if not rules['linkable'] or rules['escapeurl']:
    4387. 

  4387. 		url = doEscape(target, url)
    4388. 

  4388. 	
    4389. 

  4389. 	# Adding protocol to guessed link
    4390. 

  4390. 	guessurl = ''
    4391. 

  4391. 	if linktype == 'url' and \
    4392. 

  4392. 	   re.match('(?i)'+regex['_urlskel']['guess'], url):
    4393. 

  4393. 		if url[0] in 'Ww': guessurl = 'http://' +url
    4394. 

  4394. 		else             : guessurl =  'ftp://' +url
    4395. 

  4395. 		
    4396. 

  4396. 		# Not link aware targets -> protocol is useless
    4397. 

  4397. 		if not rules['linkable']: guessurl = ''
    4398. 

  4398. 	
    4399. 

  4399. 	# Simple link (not guessed)
    4400. 

  4400. 	if not label and not guessurl:
    4401. 

  4401. 		if CONF['mask-email'] and linktype == 'email':
    4402. 

  4402. 			# Do the email mask feature (no TAGs, just text)
    4403. 

  4403. 			url = url.replace('@', ' (a) ')
    4404. 

  4404. 			url = url.replace('.', ' ')
    4405. 

  4405. 			url = "<%s>" % url
    4406. 

  4406. 			if rules['linkable']: url = doEscape(target, url)
    4407. 

  4407. 			ret = url
    4408. 

  4408. 		else:
    4409. 

  4409. 			# Just add link data to tag
    4410. 

  4410. 			tag = TAGS[linktype]
    4411. 

  4411. 			ret = regex['x'].sub(url,tag)
    4412. 

  4412. 	
    4413. 

  4413. 	# Named link or guessed simple link
    4414. 

  4414. 	else:
    4415. 

  4415. 		# Adjusts for guessed link
    4416. 

  4416. 		if not label: label = url         # no   protocol
    4417. 

  4417. 		if guessurl : url   = guessurl    # with protocol
    4418. 

  4418. 		
    4419. 

  4419. 		# Image inside link!
    4420. 

  4420. 		if image_re.match(label):
    4421. 

  4421. 			if rules['imglinkable']:  # get image tag
    4422. 

  4422. 				label = parse_images(label)
    4423. 

  4423. 			else:                     #  img@link !supported
    4424. 

  4424. 				label = "(%s)"%image_re.match(label).group(1)
    4425. 

  4425. 		
    4426. 

  4426. 		# Putting data on the right appearance order
    4427. 

  4427. 		if rules['labelbeforelink'] or not rules['linkable']:
    4428. 

  4428. 			urlorder = [label, url]   # label before link
    4429. 

  4429. 		else:
    4430. 

  4430. 			urlorder = [url, label]   # link before label
    4431. 

  4431. 		
    4432. 

  4432. 		# Add link data to tag (replace \a's)
    4433. 

  4433. 		ret = TAGS["%sMark"%linktype]
    4434. 

  4434. 		for data in urlorder:
    4435. 

  4435. 			ret = regex['x'].sub(data,ret,1)
    4436. 

  4436. 	
    4437. 

  4437. 	return ret
    4438. 

  4438. 

  4439. 

  4440. def parse_deflist_term(line):
    4441. 

  4441. 	"Extract and parse definition list term contents"
    4442. 

  4442. 	img_re = regex['img']
    4443. 

  4443. 	term   = regex['deflist'].search(line).group(3)
    4444. 

  4444. 	
    4445. 

  4445. 	# Mask image inside term as (image.jpg), where not supported
    4446. 

  4446. 	if not rules['imgasdefterm'] and img_re.search(term):
    4447. 

  4447. 		while img_re.search(term):
    4448. 

  4448. 			imgfile = img_re.search(term).group(1)
    4449. 

  4449. 			term = img_re.sub('(%s)'%imgfile, term, 1)
    4450. 

  4450. 	
    4451. 

  4451. 	#TODO tex: escape ] on term. \], \rbrack{} and \verb!]! don't work :(
    4452. 

  4452. 	return term
    4453. 

  4453. 

  4454. 

  4455. def get_image_align(line):
    4456. 

  4456. 	"Return the image (first found) align for the given line"
    4457. 

  4457. 	
    4458. 

  4458. 	# First clear marks that can mess align detection
    4459. 

  4459. 	line = re.sub(SEPARATOR+'$', '', line)  # remove deflist sep
    4460. 

  4460. 	line = re.sub('^'+SEPARATOR, '', line)  # remove list sep
    4461. 

  4461. 	line = re.sub('^[\t]+'     , '', line)  # remove quote mark
    4462. 

  4462. 	
    4463. 

  4463. 	# Get image position on the line
    4464. 

  4464. 	m = regex['img'].search(line)
    4465. 

  4465. 	ini = m.start() ; head = 0
    4466. 

  4466. 	end = m.end()   ; tail = len(line)
    4467. 

  4467. 	
    4468. 

  4468. 	# The align detection algorithm
    4469. 

  4469. 	if   ini == head and end != tail: align = 'left'   # ^img + text$
    4470. 

  4470. 	elif ini != head and end == tail: align = 'right'  # ^text + img$
    4471. 

  4471. 	else                            : align = 'center' # default align
    4472. 

  4472. 	
    4473. 

  4473. 	# Some special cases
    4474. 

  4474. 	if BLOCK.isblock('table'): align = 'center'    # ignore when table
    4475. 

  4475. #	if TARGET == 'mgp' and align == 'center': align = 'center'
    4476. 

  4476. 	
    4477. 

  4477. 	return align
    4478. 

  4478. 

  4479. 

  4480. # Reference: http://www.iana.org/assignments/character-sets
    4481. 

  4481. # http://www.drclue.net/F1.cgi/HTML/META/META.html
    4482. 

  4482. def get_encoding_string(enc, target):
    4483. 

  4483. 	if not enc: return ''
    4484. 

  4484. 	# Target specific translation table
    4485. 

  4485. 	translate = {
    4486. 

  4486. 		'tex': {
    4487. 

  4487. 			# missing: ansinew , applemac , cp437 , cp437de , cp865
    4488. 

  4488. 			'utf-8'       : 'utf8',
    4489. 

  4489. 			'us-ascii'    : 'ascii',
    4490. 

  4490. 			'windows-1250': 'cp1250',
    4491. 

  4491. 			'windows-1252': 'cp1252',
    4492. 

  4492. 			'ibm850'      : 'cp850',
    4493. 

  4493. 			'ibm852'      : 'cp852',
    4494. 

  4494. 			'iso-8859-1'  : 'latin1',
    4495. 

  4495. 			'iso-8859-2'  : 'latin2',
    4496. 

  4496. 			'iso-8859-3'  : 'latin3',
    4497. 

  4497. 			'iso-8859-4'  : 'latin4',
    4498. 

  4498. 			'iso-8859-5'  : 'latin5',
    4499. 

  4499. 			'iso-8859-9'  : 'latin9',
    4500. 

  4500. 			'koi8-r'      : 'koi8-r'
    4501. 

  4501. 		}
    4502. 

  4502. 	}
    4503. 

  4503. 	# Normalization
    4504. 

  4504. 	enc = re.sub('(?i)(us[-_]?)?ascii|us|ibm367','us-ascii'  , enc)
    4505. 

  4505. 	enc = re.sub('(?i)(ibm|cp)?85([02])'        ,'ibm85\\2'  , enc)
    4506. 

  4506. 	enc = re.sub('(?i)(iso[_-]?)?8859[_-]?'     ,'iso-8859-' , enc)
    4507. 

  4507. 	enc = re.sub('iso-8859-($|[^1-9]).*'        ,'iso-8859-1', enc)
    4508. 

  4508. 	# Apply translation table
    4509. 

  4509. 	try: enc = translate[target][enc.lower()]
    4510. 

  4510. 	except: pass
    4511. 

  4511. 	return enc
    4512. 

  4512. 

  4513. 

  4514. ##############################################################################
    4515. 

  4515. ##MerryChristmas,IdontwanttofighttonightwithyouImissyourbodyandIneedyourlove##
    4516. 

  4516. ##############################################################################
    4517. 

  4517. 

  4518. 

  4519. def process_source_file(file='', noconf=0, contents=[]):
    4520. 

  4520. 	"""
    4521. 

  4521. 	Find and Join all the configuration available for a source file.
    4522. 

  4522. 	No sanity checking is done on this step.
    4523. 

  4523. 	It also extracts the source document parts into separate holders.
    4524. 

  4524. 	
    4525. 

  4525. 	The config scan order is:
    4526. 

  4526. 		1. The user configuration file (i.e. $HOME/.txt2tagsrc)
    4527. 

  4527. 		2. The source document's CONF area
    4528. 

  4528. 		3. The command line options
    4529. 

  4529. 

  4530. 	The return data is a tuple of two items:
    4531. 

  4531. 		1. The parsed config dictionary
    4532. 

  4532. 		2. The document's parts, as a (head, conf, body) tuple
    4533. 

  4533. 	
    4534. 

  4534. 	All the conversion process will be based on the data and
    4535. 

  4535. 	configuration returned by this function.
    4536. 

  4536. 	The source files is read on this step only.
    4537. 

  4537. 	"""
    4538. 

  4538. 	if contents:
    4539. 

  4539. 		source = SourceDocument(contents=contents)
    4540. 

  4540. 	else:
    4541. 

  4541. 		source = SourceDocument(file)
    4542. 

  4542. 	head, conf, body = source.split()
    4543. 

  4543. 	Message(_("Source document contents stored"),2)
    4544. 

  4544. 	if not noconf:
    4545. 

  4545. 		# Read document config
    4546. 

  4546. 		source_raw = source.get_raw_config()
    4547. 

  4547. 		# Join all the config directives found, then parse it
    4548. 

  4548. 		full_raw = RC_RAW + source_raw + CMDLINE_RAW
    4549. 

  4549. 		Message(_("Parsing and saving all config found (%03d items)") % (len(full_raw)), 1)
    4550. 

  4550. 		full_parsed = ConfigMaster(full_raw).parse()
    4551. 

  4551. 		# Add manually the filename to the conf dic
    4552. 

  4552. 		if contents:
    4553. 

  4553. 			full_parsed['sourcefile'] = MODULEIN
    4554. 

  4554. 			full_parsed['infile'] = MODULEIN
    4555. 

  4555. 			full_parsed['outfile'] = MODULEOUT
    4556. 

  4556. 		else:
    4557. 

  4557. 			full_parsed['sourcefile'] = file
    4558. 

  4558. 		# Maybe should we dump the config found?
    4559. 

  4559. 		if full_parsed.get('dump-config'):
    4560. 

  4560. 			dumpConfig(source_raw, full_parsed)
    4561. 

  4561. 			Quit()
    4562. 

  4562. 		# The user just want to know a single config value (hidden feature)
    4563. 

  4563. 		#TODO pick a better name than --show-config-value
    4564. 

  4564. 		elif full_parsed.get('show-config-value'):
    4565. 

  4565. 			config_value = full_parsed.get(full_parsed['show-config-value'])
    4566. 

  4566. 			if config_value:
    4567. 

  4567. 				if type(config_value) == type([]):
    4568. 

  4568. 					print '\n'.join(config_value)
    4569. 

  4569. 				else:
    4570. 

  4570. 					print config_value
    4571. 

  4571. 			Quit()
    4572. 

  4572. 		# Okay, all done
    4573. 

  4573. 		Debug("FULL config for this file: %s"%full_parsed, 1)
    4574. 

  4574. 	else:
    4575. 

  4575. 		full_parsed = {}
    4576. 

  4576. 	return full_parsed, (head,conf,body)
    4577. 

  4577. 

  4578. def get_infiles_config(infiles):
    4579. 

  4579. 	"""
    4580. 

  4580. 	Find and Join into a single list, all configuration available
    4581. 

  4581. 	for each input file. This function is supposed to be the very
    4582. 

  4582. 	first one to be called, before any processing.
    4583. 

  4583. 	"""
    4584. 

  4584. 	return map(process_source_file, infiles)
    4585. 

  4585. 

  4586. def convert_this_files(configs):
    4587. 

  4587. 	global CONF
    4588. 

  4588. 	for myconf,doc in configs:                 # multifile support
    4589. 

  4589. 		target_head = []
    4590. 

  4590. 		target_toc  = []
    4591. 

  4591. 		target_body = []
    4592. 

  4592. 		target_foot = []
    4593. 

  4593. 		source_head, source_conf, source_body = doc
    4594. 

  4594. 		myconf = ConfigMaster().sanity(myconf)
    4595. 

  4595. 		# Compose the target file Headers
    4596. 

  4596. 		#TODO escape line before?
    4597. 

  4597. 		#TODO see exceptions by tex and mgp
    4598. 

  4598. 		Message(_("Composing target Headers"),1)
    4599. 

  4599. 		target_head = doHeader(source_head, myconf)
    4600. 

  4600. 		# Parse the full marked body into tagged target
    4601. 

  4601. 		first_body_line = (len(source_head) or 1)+ len(source_conf) + 1
    4602. 

  4602. 		Message(_("Composing target Body"),1)
    4603. 

  4603. 		target_body, marked_toc = convert(source_body, myconf, firstlinenr=first_body_line)
    4604. 

  4604. 		# If dump-source, we're done
    4605. 

  4605. 		if myconf['dump-source']:
    4606. 

  4606. 			for line in source_head+source_conf+target_body:
    4607. 

  4607. 				print line
    4608. 

  4608. 			return
    4609. 

  4609. 		# Make TOC (if needed)
    4610. 

  4610. 		Message(_("Composing target TOC"),1)
    4611. 

  4611. 		tagged_toc  = toc_tagger(marked_toc, myconf)
    4612. 

  4612. 		target_toc  = toc_formatter(tagged_toc, myconf)
    4613. 

  4613. 		target_body = toc_inside_body(target_body, target_toc, myconf)
    4614. 

  4614. 		if not AUTOTOC and not myconf['toc-only']: target_toc = []
    4615. 

  4615. 		# Compose the target file Footer
    4616. 

  4616. 		Message(_("Composing target Footer"),1)
    4617. 

  4617. 		if TARGET not in ['txt', 'art']: 
    4618. 

  4618. 			target_foot = doFooter(myconf)
    4619. 

  4619. 		# Finally, we have our document
    4620. 

  4620. 		outlist = target_head + target_toc + target_body + target_foot
    4621. 

  4621. 		# If on GUI, abort before finish_him
    4622. 

  4622. 		# If module, return finish_him as list
    4623. 

  4623. 		# Else, write results to file or STDOUT
    4624. 

  4624. 		if GUI:
    4625. 

  4625. 			return outlist, myconf
    4626. 

  4626. 		elif myconf.get('outfile') == MODULEOUT:
    4627. 

  4627. 			return finish_him(outlist, myconf), myconf
    4628. 

  4628. 		else:
    4629. 

  4629. 			Message(_("Saving results to the output file"),1)
    4630. 

  4630. 			finish_him(outlist, myconf)
    4631. 

  4631. 

  4632. 

  4633. def parse_images(line):
    4634. 

  4634. 	"Tag all images found"
    4635. 

  4635. 	while regex['img'].search(line) and TAGS['img'] != '[\a]':
    4636. 

  4636. 		txt = regex['img'].search(line).group(1)
    4637. 

  4637. 		tag = TAGS['img']
    4638. 

  4638. 		
    4639. 

  4639. 		# If target supports image alignment, here we go
    4640. 

  4640. 		if rules['imgalignable']:
    4641. 

  4641. 			
    4642. 

  4642. 			align = get_image_align(line)         # right
    4643. 

  4643. 			align_name = align.capitalize()       # Right
    4644. 

  4644. 			
    4645. 

  4645. 			# The align is a full tag, or part of the image tag (~A~)
    4646. 

  4646. 			if TAGS['imgAlign'+align_name]:
    4647. 

  4647. 				tag = TAGS['imgAlign'+align_name]
    4648. 

  4648. 			else:
    4649. 

  4649. 				align_tag = TAGS['_imgAlign'+align_name]
    4650. 

  4650. 				tag = regex['_imgAlign'].sub(align_tag, tag, 1)
    4651. 

  4651. 				
    4652. 

  4652. 			# Dirty fix to allow centered solo images
    4653. 

  4653. 			if align == 'center' and TARGET in ('html','xhtml'):
    4654. 

  4654. 				rest = regex['img'].sub('',line,1)
    4655. 

  4655. 				if re.match('^\s+$', rest):
    4656. 

  4656. 					tag = "<center>%s</center>" %tag
    4657. 

  4657. 		
    4658. 

  4658. 		if TARGET == 'tex':
    4659. 

  4659. 			tag = re.sub(r'\\b',r'\\\\b',tag)
    4660. 

  4660. 			txt = txt.replace('_', 'vvvvTexUndervvvv')
    4661. 

  4661. 		
    4662. 

  4662. 		line = regex['img'].sub(tag,line,1)
    4663. 

  4663. 		line = regex['x'].sub(txt,line,1)
    4664. 

  4664. 	return line
    4665. 

  4665. 

  4666. 

  4667. def add_inline_tags(line):
    4668. 

  4668. 	# Beautifiers
    4669. 

  4669. 	for beauti in ('bold', 'italic', 'underline', 'strike'):
    4670. 

  4670. 		if regex['font%s'%beauti.capitalize()].search(line):
    4671. 

  4671. 			line = beautify_me(beauti, line)
    4672. 

  4672. 	
    4673. 

  4673. 	line = parse_images(line)
    4674. 

  4674. 	return line
    4675. 

  4675. 

  4676. 

  4677. def get_include_contents(file, path=''):
    4678. 

  4678. 	"Parses %!include: value and extract file contents"
    4679. 

  4679. 	ids = {'`':'verb', '"':'raw', "'":'tagged' }
    4680. 

  4680. 	id = 't2t'
    4681. 

  4681. 	# Set include type and remove identifier marks
    4682. 

  4682. 	mark = file[0]
    4683. 

  4683. 	if mark in ids.keys():
    4684. 

  4684. 		if file[:2] == file[-2:] == mark*2:
    4685. 

  4685. 			id = ids[mark]     # set type
    4686. 

  4686. 			file = file[2:-2]  # remove marks
    4687. 

  4687. 	# Handle remote dir execution
    4688. 

  4688. 	filepath = os.path.join(path, file)
    4689. 

  4689. 	# Read included file contents
    4690. 

  4690. 	lines = Readfile(filepath, remove_linebreaks=1)
    4691. 

  4691. 	# Default txt2tags marked text, just BODY matters
    4692. 

  4692. 	if id == 't2t':
    4693. 

  4693. 		lines = get_file_body(filepath)
    4694. 

  4694. 		#TODO fix images relative path if file has a path, ie.: chapter1/index.t2t (wait until tree parsing)
    4695. 

  4695. 		#TODO for the images path fix, also respect outfile path, if different from infile (wait until tree parsing)
    4696. 

  4696. 		lines.insert(0, '%%INCLUDED(%s) starts here: %s'%(id,file))
    4697. 

  4697. 		# This appears when included hit EOF with verbatim area open
    4698. 

  4698. 		#lines.append('%%INCLUDED(%s) ends here: %s'%(id,file))
    4699. 

  4699. 	return id, lines
    4700. 

  4700. 

  4701. 

  4702. def set_global_config(config):
    4703. 

  4703. 	global CONF, TAGS, regex, rules, TARGET
    4704. 

  4704. 	CONF   = config
    4705. 

  4705. 	rules  = getRules(CONF)
    4706. 

  4706. 	TAGS   = getTags(CONF)
    4707. 

  4707. 	regex  = getRegexes()
    4708. 

  4708. 	TARGET = config['target']  # save for buggy functions that need global
    4709. 

  4709. 

  4710. 

  4711. def convert(bodylines, config, firstlinenr=1):
    4712. 

  4712. 	global BLOCK, TITLE
    4713. 

  4713. 	
    4714. 

  4714. 	set_global_config(config)
    4715. 

  4715. 	
    4716. 

  4716. 	target = config['target']
    4717. 

  4717. 	BLOCK = BlockMaster()
    4718. 

  4718. 	MASK  =  MaskMaster()
    4719. 

  4719. 	TITLE = TitleMaster()
    4720. 

  4720. 	
    4721. 

  4721. 	ret = []
    4722. 

  4722. 	dump_source = []
    4723. 

  4723. 	f_lastwasblank = 0
    4724. 

  4724. 	
    4725. 

  4725. 	# Compiling all PreProc regexes
    4726. 

  4726. 	pre_filter = compile_filters(
    4727. 

  4727. 		CONF['preproc'], _('Invalid PreProc filter regex'))
    4728. 

  4728. 	
    4729. 

  4729. 	# Let's mark it up!
    4730. 

  4730. 	linenr = firstlinenr-1
    4731. 

  4731. 	lineref = 0
    4732. 

  4732. 	while lineref < len(bodylines):
    4733. 

  4733. 		# Defaults
    4734. 

  4734. 		MASK.reset()
    4735. 

  4735. 		results_box = ''
    4736. 

  4736. 		
    4737. 

  4737. 		untouchedline = bodylines[lineref]
    4738. 

  4738. 		dump_source.append(untouchedline)
    4739. 

  4739. 		
    4740. 

  4740. 		line = re.sub('[\n\r]+$','',untouchedline)   # del line break
    4741. 

  4741. 		
    4742. 

  4742. 		# Apply PreProc filters
    4743. 

  4743. 		if pre_filter:
    4744. 

  4744. 			errmsg = _('Invalid PreProc filter replacement')
    4745. 

  4745. 			for rgx,repl in pre_filter:
    4746. 

  4746. 				try: line = rgx.sub(repl, line)
    4747. 

  4747. 				except: Error("%s: '%s'"%(errmsg, repl))
    4748. 

  4748. 		
    4749. 

  4749. 		line = maskEscapeChar(line)                  # protect \ char
    4750. 

  4750. 		linenr  += 1
    4751. 

  4751. 		lineref += 1
    4752. 

  4752. 		
    4753. 

  4753. 		Debug(repr(line), 2, linenr)  # heavy debug: show each line
    4754. 

  4754. 		
    4755. 

  4755. 		#------------------[ Comment Block ]------------------------
    4756. 

  4756. 		
    4757. 

  4757. 		# We're already on a comment block
    4758. 

  4758. 		if BLOCK.block() == 'comment':
    4759. 

  4759. 		
    4760. 

  4760. 			# Closing comment
    4761. 

  4761. 			if regex['blockCommentClose'].search(line):
    4762. 

  4762. 				ret.extend(BLOCK.blockout() or [])
    4763. 

  4763. 				continue
    4764. 

  4764. 			
    4765. 

  4765. 			# Normal comment-inside line. Ignore it.
    4766. 

  4766. 			continue
    4767. 

  4767. 		
    4768. 

  4768. 		# Detecting comment block init
    4769. 

  4769. 		if regex['blockCommentOpen'].search(line) \
    4770. 

  4770. 		   and BLOCK.block() not in BLOCK.exclusive:
    4771. 

  4771. 			ret.extend(BLOCK.blockin('comment'))
    4772. 

  4772. 			continue
    4773. 

  4773. 

  4774. 		#-------------------------[ Tagged Text ]----------------------
    4775. 

  4775. 

  4776. 		# We're already on a tagged block
    4777. 

  4777. 		if BLOCK.block() == 'tagged':
    4778. 

  4778. 		
    4779. 

  4779. 			# Closing tagged
    4780. 

  4780. 			if regex['blockTaggedClose'].search(line):
    4781. 

  4781. 				ret.extend(BLOCK.blockout())
    4782. 

  4782. 				continue
    4783. 

  4783. 			
    4784. 

  4784. 			# Normal tagged-inside line
    4785. 

  4785. 			BLOCK.holdadd(line)
    4786. 

  4786. 			continue
    4787. 

  4787. 		
    4788. 

  4788. 		# Detecting tagged block init
    4789. 

  4789. 		if regex['blockTaggedOpen'].search(line) \
    4790. 

  4790. 		   and BLOCK.block() not in BLOCK.exclusive:
    4791. 

  4791. 			ret.extend(BLOCK.blockin('tagged'))
    4792. 

  4792. 			continue
    4793. 

  4793. 		
    4794. 

  4794. 		# One line tagged text
    4795. 

  4795. 		if regex['1lineTagged'].search(line) \
    4796. 

  4796. 		   and BLOCK.block() not in BLOCK.exclusive:
    4797. 

  4797. 			ret.extend(BLOCK.blockin('tagged'))
    4798. 

  4798. 			line = regex['1lineTagged'].sub('',line)
    4799. 

  4799. 			BLOCK.holdadd(line)
    4800. 

  4800. 			ret.extend(BLOCK.blockout())
    4801. 

  4801. 			continue
    4802. 

  4802. 		
    4803. 

  4803. 		#-------------------------[ Raw Text ]----------------------
    4804. 

  4804. 		
    4805. 

  4805. 		# We're already on a raw block
    4806. 

  4806. 		if BLOCK.block() == 'raw':
    4807. 

  4807. 		
    4808. 

  4808. 			# Closing raw
    4809. 

  4809. 			if regex['blockRawClose'].search(line):
    4810. 

  4810. 				ret.extend(BLOCK.blockout())
    4811. 

  4811. 				continue
    4812. 

  4812. 			
    4813. 

  4813. 			# Normal raw-inside line
    4814. 

  4814. 			BLOCK.holdadd(line)
    4815. 

  4815. 			continue
    4816. 

  4816. 		
    4817. 

  4817. 		# Detecting raw block init
    4818. 

  4818. 		if regex['blockRawOpen'].search(line) \
    4819. 

  4819. 		   and BLOCK.block() not in BLOCK.exclusive:
    4820. 

  4820. 			ret.extend(BLOCK.blockin('raw'))
    4821. 

  4821. 			continue
    4822. 

  4822. 		
    4823. 

  4823. 		# One line raw text
    4824. 

  4824. 		if regex['1lineRaw'].search(line) \
    4825. 

  4825. 		   and BLOCK.block() not in BLOCK.exclusive:
    4826. 

  4826. 			ret.extend(BLOCK.blockin('raw'))
    4827. 

  4827. 			line = regex['1lineRaw'].sub('',line)
    4828. 

  4828. 			BLOCK.holdadd(line)
    4829. 

  4829. 			ret.extend(BLOCK.blockout())
    4830. 

  4830. 			continue
    4831. 

  4831. 		
    4832. 

  4832. 		#------------------------[ Verbatim  ]----------------------
    4833. 

  4833. 		
    4834. 

  4834. 		#TIP We'll never support beautifiers inside verbatim
    4835. 

  4835. 		
    4836. 

  4836. 		# Closing table mapped to verb
    4837. 

  4837. 		if BLOCK.block() == 'verb' \
    4838. 

  4838. 		   and BLOCK.prop('mapped') == 'table' \
    4839. 

  4839. 		   and not regex['table'].search(line):
    4840. 

  4840. 			ret.extend(BLOCK.blockout())
    4841. 

  4841. 		
    4842. 

  4842. 		# We're already on a verb block
    4843. 

  4843. 		if BLOCK.block() == 'verb':
    4844. 

  4844. 			
    4845. 

  4845. 			# Closing verb
    4846. 

  4846. 			if regex['blockVerbClose'].search(line):
    4847. 

  4847. 				ret.extend(BLOCK.blockout())
    4848. 

  4848. 				continue
    4849. 

  4849. 			
    4850. 

  4850. 			# Normal verb-inside line
    4851. 

  4851. 			BLOCK.holdadd(line)
    4852. 

  4852. 			continue
    4853. 

  4853. 		
    4854. 

  4854. 		# Detecting verb block init
    4855. 

  4855. 		if regex['blockVerbOpen'].search(line) \
    4856. 

  4856. 		   and BLOCK.block() not in BLOCK.exclusive:
    4857. 

  4857. 			ret.extend(BLOCK.blockin('verb'))
    4858. 

  4858. 			f_lastwasblank = 0
    4859. 

  4859. 			continue
    4860. 

  4860. 		
    4861. 

  4861. 		# One line verb-formatted text
    4862. 

  4862. 		if regex['1lineVerb'].search(line) \
    4863. 

  4863. 		   and BLOCK.block() not in BLOCK.exclusive:
    4864. 

  4864. 			ret.extend(BLOCK.blockin('verb'))
    4865. 

  4865. 			line = regex['1lineVerb'].sub('',line)
    4866. 

  4866. 			BLOCK.holdadd(line)
    4867. 

  4867. 			ret.extend(BLOCK.blockout())
    4868. 

  4868. 			f_lastwasblank = 0
    4869. 

  4869. 			continue
    4870. 

  4870. 		
    4871. 

  4871. 		# Tables are mapped to verb when target is not table-aware
    4872. 

  4872. 		if not rules['tableable'] and regex['table'].search(line):
    4873. 

  4873. 			if not BLOCK.isblock('verb'):
    4874. 

  4874. 				ret.extend(BLOCK.blockin('verb'))
    4875. 

  4875. 				BLOCK.propset('mapped', 'table')
    4876. 

  4876. 				BLOCK.holdadd(line)
    4877. 

  4877. 				continue
    4878. 

  4878. 		
    4879. 

  4879. 		#---------------------[ blank lines ]-----------------------
    4880. 

  4880. 		
    4881. 

  4881. 		if regex['blankline'].search(line):
    4882. 

  4882. 			
    4883. 

  4883. 			# Close open paragraph
    4884. 

  4884. 			if BLOCK.isblock('para'):
    4885. 

  4885. 				ret.extend(BLOCK.blockout())
    4886. 

  4886. 				f_lastwasblank = 1
    4887. 

  4887. 				continue
    4888. 

  4888. 			
    4889. 

  4889. 			# Close all open tables
    4890. 

  4890. 			if BLOCK.isblock('table'):
    4891. 

  4891. 				ret.extend(BLOCK.blockout())
    4892. 

  4892. 				f_lastwasblank = 1
    4893. 

  4893. 				continue
    4894. 

  4894. 			
    4895. 

  4895. 			# Close all open quotes
    4896. 

  4896. 			while BLOCK.isblock('quote'):
    4897. 

  4897. 				ret.extend(BLOCK.blockout())
    4898. 

  4898. 			
    4899. 

  4899. 			# Closing all open lists
    4900. 

  4900. 			if f_lastwasblank:          # 2nd consecutive blank
    4901. 

  4901. 				if BLOCK.block().endswith('list'):
    4902. 

  4902. 					BLOCK.holdaddsub('')   # helps parser
    4903. 

  4903. 				while BLOCK.depth:  # closes list (if any)
    4904. 

  4904. 					ret.extend(BLOCK.blockout())
    4905. 

  4905. 				continue            # ignore consecutive blanks
    4906. 

  4906. 			
    4907. 

  4907. 			# Paragraph (if any) is wanted inside lists also
    4908. 

  4908. 			if BLOCK.block().endswith('list'):
    4909. 

  4909. 				BLOCK.holdaddsub('')
    4910. 

  4910. 			
    4911. 

  4911. 			f_lastwasblank = 1
    4912. 

  4912. 			continue
    4913. 

  4913. 		
    4914. 

  4914. 		
    4915. 

  4915. 		#---------------------[ special ]---------------------------
    4916. 

  4916. 		
    4917. 

  4917. 		if regex['special'].search(line):
    4918. 

  4918. 			# Include command
    4919. 

  4919. 			targ, key, val = ConfigLines().parse_line(line, 'include', target)
    4920. 

  4920. 			if key:
    4921. 

  4921. 				Debug("Found config '%s', value '%s'" % (key, val), 1, linenr)
    4922. 

  4922. 				
    4923. 

  4923. 				incpath = os.path.dirname(CONF['sourcefile'])
    4924. 

  4924. 				incfile = val
    4925. 

  4925. 				err = _('A file cannot include itself (loop!)')
    4926. 

  4926. 				if CONF['sourcefile'] == incfile:
    4927. 

  4927. 					Error("%s: %s"%(err,incfile))
    4928. 

  4928. 				inctype, inclines = get_include_contents(incfile, incpath)
    4929. 

  4929. 				# Verb, raw and tagged are easy
    4930. 

  4930. 				if inctype != 't2t':
    4931. 

  4931. 					ret.extend(BLOCK.blockin(inctype))
    4932. 

  4932. 					BLOCK.holdextend(inclines)
    4933. 

  4933. 					ret.extend(BLOCK.blockout())
    4934. 

  4934. 				else:
    4935. 

  4935. 					# Insert include lines into body
    4936. 

  4936. 					#TODO include maxdepth limit
    4937. 

  4937. 					bodylines = bodylines[:lineref] + inclines + bodylines[lineref:]
    4938. 

  4938. 					#TODO fix path if include@include
    4939. 

  4939. 					# Remove %!include call
    4940. 

  4940. 					if CONF['dump-source']:
    4941. 

  4941. 						dump_source.pop()
    4942. 

  4942. 				continue
    4943. 

  4943. 			else:
    4944. 

  4944. 				Debug('Bogus Special Line',1,linenr)
    4945. 

  4945. 		
    4946. 

  4946. 		#---------------------[ dump-source ]-----------------------
    4947. 

  4947. 		
    4948. 

  4948. 		# We don't need to go any further
    4949. 

  4949. 		if CONF['dump-source']:
    4950. 

  4950. 			continue
    4951. 

  4951. 		
    4952. 

  4952. 		#---------------------[ Comments ]--------------------------
    4953. 

  4953. 		
    4954. 

  4954. 		# Just skip them (if not macro)
    4955. 

  4955. 		if regex['comment'].search(line) and not \
    4956. 

  4956. 		   regex['macros'].match(line) and not \
    4957. 

  4957. 		   regex['toc'].match(line):
    4958. 

  4958. 			continue
    4959. 

  4959. 		
    4960. 

  4960. 		#---------------------[ Triggers ]--------------------------
    4961. 

  4961. 		
    4962. 

  4962. 		# Valid line, reset blank status
    4963. 

  4963. 		f_lastwasblank = 0
    4964. 

  4964. 		
    4965. 

  4965. 		# Any NOT quote line closes all open quotes
    4966. 

  4966. 		if BLOCK.isblock('quote') and not regex['quote'].search(line):
    4967. 

  4967. 			while BLOCK.isblock('quote'):
    4968. 

  4968. 				ret.extend(BLOCK.blockout())
    4969. 

  4969. 		
    4970. 

  4970. 		# Any NOT table line closes an open table
    4971. 

  4971. 		if BLOCK.isblock('table') and not regex['table'].search(line):
    4972. 

  4972. 			ret.extend(BLOCK.blockout())
    4973. 

  4973. 		
    4974. 

  4974. 		
    4975. 

  4975. 		#---------------------[ Horizontal Bar ]--------------------
    4976. 

  4976. 

  4977. 		if regex['bar'].search(line):
    4978. 

  4978. 

  4979. 			# Bars inside quotes are handled on the Quote processing
    4980. 

  4980. 			# Otherwise we parse the bars right here
    4981. 

  4981. 			#
    4982. 

  4982. 			if not (BLOCK.isblock('quote') or regex['quote'].search(line)) \
    4983. 

  4983. 				or (BLOCK.isblock('quote') and not rules['barinsidequote']):
    4984. 

  4984. 

  4985. 				# Close all the opened blocks
    4986. 

  4986. 				ret.extend(BLOCK.blockin('bar'))
    4987. 

  4987. 

  4988. 				# Extract the bar chars (- or =)
    4989. 

  4989. 				m = regex['bar'].search(line)
    4990. 

  4990. 				bar_chars = m.group(2)
    4991. 

  4991. 

  4992. 				# Process and dump the tagged bar
    4993. 

  4993. 				BLOCK.holdadd(bar_chars)
    4994. 

  4994. 				ret.extend(BLOCK.blockout())
    4995. 

  4995. 				Debug("BAR: %s"%line, 6)
    4996. 

  4996. 

  4997. 				# We're done, nothing more to process
    4998. 

  4998. 				continue
    4999. 

  4999. 

  5000. 

  5001. 		#---------------------[ Title ]-----------------------------
    5002. 

  5002. 		
    5003. 

  5003. 		if (regex['title'].search(line) or regex['numtitle'].search(line)) \
    5004. 

  5004. 			and not BLOCK.block().endswith('list'):
    5005. 

  5005. 

  5006. 			if regex['title'].search(line):
    5007. 

  5007. 				name = 'title'
    5008. 

  5008. 			else:
    5009. 

  5009. 				name = 'numtitle'
    5010. 

  5010. 			
    5011. 

  5011. 			# Close all the opened blocks
    5012. 

  5012. 			ret.extend(BLOCK.blockin(name))
    5013. 

  5013. 			
    5014. 

  5014. 			# Process title
    5015. 

  5015. 			TITLE.add(line)
    5016. 

  5016. 			ret.extend(BLOCK.blockout())
    5017. 

  5017. 			
    5018. 

  5018. 			# We're done, nothing more to process
    5019. 

  5019. 			continue
    5020. 

  5020. 		
    5021. 

  5021. 		#---------------------[ %%toc ]-----------------------
    5022. 

  5022. 		
    5023. 

  5023. 		# %%toc line closes paragraph
    5024. 

  5024. 		if BLOCK.block() == 'para' and regex['toc'].search(line):
    5025. 

  5025. 			ret.extend(BLOCK.blockout())
    5026. 

  5026. 		
    5027. 

  5027. 		#---------------------[ apply masks ]-----------------------
    5028. 

  5028. 		
    5029. 

  5029. 		line = MASK.mask(line)
    5030. 

  5030. 		
    5031. 

  5031. 		#XXX from here, only block-inside lines will pass
    5032. 

  5032. 		
    5033. 

  5033. 		#---------------------[ Quote ]-----------------------------
    5034. 

  5034. 		
    5035. 

  5035. 		if regex['quote'].search(line):
    5036. 

  5036. 			
    5037. 

  5037. 			# Store number of leading TABS
    5038. 

  5038. 			quotedepth = len(regex['quote'].search(line).group(0))
    5039. 

  5039. 			
    5040. 

  5040. 			# SGML doesn't support nested quotes
    5041. 

  5041. 			if rules['quotenotnested']: quotedepth = 1
    5042. 

  5042. 			
    5043. 

  5043. 			# Don't cross depth limit
    5044. 

  5044. 			maxdepth = rules['quotemaxdepth']
    5045. 

  5045. 			if maxdepth and quotedepth > maxdepth:
    5046. 

  5046. 				quotedepth = maxdepth
    5047. 

  5047. 			
    5048. 

  5048. 			# New quote
    5049. 

  5049. 			if not BLOCK.isblock('quote'):
    5050. 

  5050. 				ret.extend(BLOCK.blockin('quote'))
    5051. 

  5051. 			
    5052. 

  5052. 			# New subquotes
    5053. 

  5053. 			while BLOCK.depth < quotedepth:
    5054. 

  5054. 				BLOCK.blockin('quote')
    5055. 

  5055. 			
    5056. 

  5056. 			# Closing quotes
    5057. 

  5057. 			while quotedepth < BLOCK.depth:
    5058. 

  5058. 				ret.extend(BLOCK.blockout())
    5059. 

  5059. 			
    5060. 

  5060. 			# Bar inside quote
    5061. 

  5061. 			if regex['bar'].search(line) and rules['barinsidequote']:
    5062. 

  5062. 				tempBlock = BlockMaster()
    5063. 

  5063. 				tagged_bar = []
    5064. 

  5064. 				tagged_bar.extend(tempBlock.blockin('bar'))
    5065. 

  5065. 				tempBlock.holdadd(line)
    5066. 

  5066. 				tagged_bar.extend(tempBlock.blockout())
    5067. 

  5067. 				BLOCK.holdextend(tagged_bar)
    5068. 

  5068. 				continue
    5069. 

  5069. 

  5070. 		#---------------------[ Lists ]-----------------------------
    5071. 

  5071. 		
    5072. 

  5072. 		# An empty item also closes the current list
    5073. 

  5073. 		if BLOCK.block().endswith('list'):
    5074. 

  5074. 			m = regex['listclose'].match(line)
    5075. 

  5075. 			if m:
    5076. 

  5076. 				listindent = m.group(1)
    5077. 

  5077. 				listtype = m.group(2)
    5078. 

  5078. 				currlisttype = BLOCK.prop('type')
    5079. 

  5079. 				currlistindent = BLOCK.prop('indent')
    5080. 

  5080. 				if listindent == currlistindent and \
    5081. 

  5081. 				   listtype == currlisttype:
    5082. 

  5082. 					ret.extend(BLOCK.blockout())
    5083. 

  5083. 					continue
    5084. 

  5084. 		
    5085. 

  5085. 		if   regex['list'].search(line) or \
    5086. 

  5086. 		  regex['numlist'].search(line) or \
    5087. 

  5087. 		  regex['deflist'].search(line):
    5088. 

  5088. 			
    5089. 

  5089. 			listindent = BLOCK.prop('indent')
    5090. 

  5090. 			listids = ''.join(LISTNAMES.keys())
    5091. 

  5091. 			m = re.match('^( *)([%s]) '%listids, line)
    5092. 

  5092. 			listitemindent = m.group(1)
    5093. 

  5093. 			listtype = m.group(2)
    5094. 

  5094. 			listname = LISTNAMES[listtype]
    5095. 

  5095. 			results_box = BLOCK.holdadd
    5096. 

  5096. 			
    5097. 

  5097. 			# Del list ID (and separate term from definition)
    5098. 

  5098. 			if listname == 'deflist':
    5099. 

  5099. 				term = parse_deflist_term(line)
    5100. 

  5100. 				line = regex['deflist'].sub(
    5101. 

  5101. 					SEPARATOR+term+SEPARATOR,line)
    5102. 

  5102. 			else:
    5103. 

  5103. 				line = regex[listname].sub(SEPARATOR,line)
    5104. 

  5104. 			
    5105. 

  5105. 			# Don't cross depth limit
    5106. 

  5106. 			maxdepth = rules['listmaxdepth']
    5107. 

  5107. 			if maxdepth and BLOCK.depth == maxdepth:
    5108. 

  5108. 				if len(listitemindent) > len(listindent):
    5109. 

  5109. 					listitemindent = listindent
    5110. 

  5110. 			
    5111. 

  5111. 			# List bumping (same indent, diff mark)
    5112. 

  5112. 			# Close the currently open list to clear the mess
    5113. 

  5113. 			if BLOCK.block().endswith('list') \
    5114. 

  5114. 			   and listname != BLOCK.block() \
    5115. 

  5115. 			   and len(listitemindent) == len(listindent):
    5116. 

  5116. 				ret.extend(BLOCK.blockout())
    5117. 

  5117. 				listindent = BLOCK.prop('indent')
    5118. 

  5118. 			
    5119. 

  5119. 			# Open mother list or sublist
    5120. 

  5120. 			if not BLOCK.block().endswith('list') or \
    5121. 

  5121. 			   len(listitemindent) > len(listindent):
    5122. 

  5122. 				ret.extend(BLOCK.blockin(listname))
    5123. 

  5123. 				BLOCK.propset('indent',listitemindent)
    5124. 

  5124. 				BLOCK.propset('type',listtype)
    5125. 

  5125. 			
    5126. 

  5126. 			# Closing sublists
    5127. 

  5127. 			while len(listitemindent) < len(BLOCK.prop('indent')):
    5128. 

  5128. 				ret.extend(BLOCK.blockout())
    5129. 

  5129. 			
    5130. 

  5130. 			# O-oh, sublist before list ("\n\n  - foo\n- foo")
    5131. 

  5131. 			# Fix: close sublist (as mother), open another list
    5132. 

  5132. 			if not BLOCK.block().endswith('list'):
    5133. 

  5133. 				ret.extend(BLOCK.blockin(listname))
    5134. 

  5134. 				BLOCK.propset('indent',listitemindent)
    5135. 

  5135. 				BLOCK.propset('type',listtype)
    5136. 

  5136. 		
    5137. 

  5137. 		#---------------------[ Table ]-----------------------------
    5138. 

  5138. 		
    5139. 

  5139. 		#TODO escape undesired format inside table
    5140. 

  5140. 		#TODO add pm6 target
    5141. 

  5141. 		if regex['table'].search(line):
    5142. 

  5142. 			
    5143. 

  5143. 			if not BLOCK.isblock('table'):   # first table line!
    5144. 

  5144. 				ret.extend(BLOCK.blockin('table'))
    5145. 

  5145. 				BLOCK.tableparser.__init__(line)
    5146. 

  5146. 			
    5147. 

  5147. 			tablerow = TableMaster().parse_row(line)
    5148. 

  5148. 			BLOCK.tableparser.add_row(tablerow)     # save config
    5149. 

  5149. 			
    5150. 

  5150. 			# Maintain line to unmask and inlines
    5151. 

  5151. 			# XXX Bug: | **bo | ld** | turns **bo\x01ld** and gets converted :(
    5152. 

  5152. 			# TODO isolate unmask+inlines parsing to use here
    5153. 

  5153. 			line = SEPARATOR.join(tablerow['cells'])
    5154. 

  5154. 		
    5155. 

  5155. 		#---------------------[ Paragraph ]-------------------------
    5156. 

  5156. 		
    5157. 

  5157. 		if not BLOCK.block() and \
    5158. 

  5158. 		   not line.count(MASK.tocmask): # new para!
    5159. 

  5159. 			ret.extend(BLOCK.blockin('para'))
    5160. 

  5160. 		
    5161. 

  5161. 		
    5162. 

  5162. 		############################################################
    5163. 

  5163. 		############################################################
    5164. 

  5164. 		############################################################
    5165. 

  5165. 		
    5166. 

  5166. 		
    5167. 

  5167. 		#---------------------[ Final Parses ]----------------------
    5168. 

  5168. 		
    5169. 

  5169. 		# The target-specific special char escapes for body lines
    5170. 

  5170. 		line = doEscape(target,line)
    5171. 

  5171. 		
    5172. 

  5172. 		line = add_inline_tags(line)
    5173. 

  5173. 		line = MASK.undo(line)
    5174. 

  5174. 		
    5175. 

  5175. 		
    5176. 

  5176. 		#---------------------[ Hold or Return? ]-------------------
    5177. 

  5177. 		
    5178. 

  5178. 		### Now we must choose where to put the parsed line
    5179. 

  5179. 		#
    5180. 

  5180. 		if not results_box:
    5181. 

  5181. 			# List item extra lines
    5182. 

  5182. 			if BLOCK.block().endswith('list'):
    5183. 

  5183. 				results_box = BLOCK.holdaddsub
    5184. 

  5184. 			# Other blocks
    5185. 

  5185. 			elif BLOCK.block():
    5186. 

  5186. 				results_box = BLOCK.holdadd
    5187. 

  5187. 			# No blocks
    5188. 

  5188. 			else:
    5189. 

  5189. 				line = doFinalEscape(target, line)
    5190. 

  5190. 				results_box = ret.append
    5191. 

  5191. 		
    5192. 

  5192. 		results_box(line)
    5193. 

  5193. 	
    5194. 

  5194. 	# EOF: close any open para/verb/lists/table/quotes
    5195. 

  5195. 	Debug('EOF',7)
    5196. 

  5196. 	while BLOCK.block():
    5197. 

  5197. 		ret.extend(BLOCK.blockout())
    5198. 

  5198. 	
    5199. 

  5199. 	# Maybe close some opened title area?
    5200. 

  5200. 	if rules['titleblocks']:
    5201. 

  5201. 		ret.extend(TITLE.close_all())
    5202. 

  5202. 	
    5203. 

  5203. 	# Maybe a major tag to enclose body? (like DIV for CSS)
    5204. 

  5204. 	if TAGS['bodyOpen' ]: ret.insert(0, TAGS['bodyOpen'])
    5205. 

  5205. 	if TAGS['bodyClose']: ret.append(TAGS['bodyClose'])
    5206. 

  5206. 	
    5207. 

  5207. 	if CONF['toc-only']: ret = []
    5208. 

  5208. 	marked_toc = TITLE.dump_marked_toc(CONF['toc-level'])
    5209. 

  5209. 	
    5210. 

  5210. 	# If dump-source, all parsing is ignored
    5211. 

  5211. 	if CONF['dump-source']: ret = dump_source[:]
    5212. 

  5212. 	
    5213. 

  5213. 	return ret, marked_toc
    5214. 

  5214. 

  5215. 

  5216. 

  5217. ##############################################################################
    5218. 

  5218. ################################### GUI ######################################
    5219. 

  5219. ##############################################################################
    5220. 

  5220. #
    5221. 

  5221. # Tk help: http://python.org/topics/tkinter/
    5222. 

  5222. #    Tuto: http://ibiblio.org/obp/py4fun/gui/tkPhone.html
    5223. 

  5223. #          /usr/lib/python*/lib-tk/Tkinter.py
    5224. 

  5224. #
    5225. 

  5225. # grid table : row=0, column=0, columnspan=2, rowspan=2
    5226. 

  5226. # grid align : sticky='n,s,e,w' (North, South, East, West)
    5227. 

  5227. # pack place : side='top,bottom,right,left'
    5228. 

  5228. # pack fill  : fill='x,y,both,none', expand=1
    5229. 

  5229. # pack align : anchor='n,s,e,w' (North, South, East, West)
    5230. 

  5230. # padding    : padx=10, pady=10, ipadx=10, ipady=10 (internal)
    5231. 

  5231. # checkbox   : offvalue is return if the _user_ deselected the box
    5232. 

  5232. # label align: justify=left,right,center
    5233. 

  5233. 

  5234. def load_GUI_resources():
    5235. 

  5235. 	"Load all extra modules and methods used by GUI"
    5236. 

  5236. 	global askopenfilename, showinfo, showwarning, showerror, Tkinter
    5237. 

  5237. 	from tkFileDialog import askopenfilename
    5238. 

  5238. 	from tkMessageBox import showinfo,showwarning,showerror
    5239. 

  5239. 	import Tkinter
    5240. 

  5240. 

  5241. class Gui:
    5242. 

  5242. 	"Graphical Tk Interface"
    5243. 

  5243. 	def __init__(self, conf={}):
    5244. 

  5244. 		self.root = Tkinter.Tk()    # mother window, come to butthead
    5245. 

  5245. 		self.root.title(my_name)    # window title bar text
    5246. 

  5246. 		self.window = self.root     # variable "focus" for inclusion
    5247. 

  5247. 		self.row = 0                # row count for grid()
    5248. 

  5248. 		
    5249. 

  5249. 		self.action_length = 150    # left column length (pixel)
    5250. 

  5250. 		self.frame_margin  = 10     # frame margin size  (pixel)
    5251. 

  5251. 		self.frame_border  = 6      # frame border size  (pixel)
    5252. 

  5252. 		
    5253. 

  5253. 		# The default Gui colors, can be changed by %!guicolors
    5254. 

  5254. 		self.dft_gui_colors = ['#6c6','white','#cf9','#030']
    5255. 

  5255. 		self.gui_colors = []
    5256. 

  5256. 		self.bg1 = self.fg1 = self.bg2 = self.fg2 = ''
    5257. 

  5257. 		
    5258. 

  5258. 		# On Tk, vars need to be set/get using setvar()/get()
    5259. 

  5259. 		self.infile  = self.setvar('')
    5260. 

  5260. 		self.target  = self.setvar('')
    5261. 

  5261. 		self.target_name = self.setvar('')
    5262. 

  5262. 		
    5263. 

  5263. 		# The checks appearance order
    5264. 

  5264. 		self.checks = [
    5265. 

  5265. 			'headers', 'enum-title', 'toc', 'mask-email', 'toc-only', 'stdout'
    5266. 

  5266. 		]
    5267. 

  5267. 		
    5268. 

  5268. 		# Creating variables for all checks
    5269. 

  5269. 		for check in self.checks:
    5270. 

  5270. 			setattr(self, 'f_'+check, self.setvar(''))
    5271. 

  5271. 		
    5272. 

  5272. 		# Load RC config
    5273. 

  5273. 		self.conf = {}
    5274. 

  5274. 		if conf: self.load_config(conf)
    5275. 

  5275. 	
    5276. 

  5276. 	def load_config(self, conf):
    5277. 

  5277. 		self.conf = conf
    5278. 

  5278. 		self.gui_colors = conf.get('guicolors') or self.dft_gui_colors
    5279. 

  5279. 		self.bg1, self.fg1, self.bg2, self.fg2 = self.gui_colors
    5280. 

  5280. 		self.root.config(bd=15,bg=self.bg1)
    5281. 

  5281. 	
    5282. 

  5282. 	### Config as dic for python 1.5 compat (**opts don't work :( )
    5283. 

  5283. 	def entry(self, **opts): return Tkinter.Entry(self.window, opts)
    5284. 

  5284. 	def label(self, txt='', bg=None, **opts):
    5285. 

  5285. 		opts.update({'text':txt,'bg':bg or self.bg1})
    5286. 

  5286. 		return Tkinter.Label(self.window, opts)
    5287. 

  5287. 	def button(self,name,cmd,**opts):
    5288. 

  5288. 		opts.update({'text':name,'command':cmd})
    5289. 

  5289. 		return Tkinter.Button(self.window, opts)
    5290. 

  5290. 	def check(self,name,checked=0,**opts):
    5291. 

  5291. 		bg, fg = self.bg2, self.fg2
    5292. 

  5292. 		opts.update({
    5293. 

  5293. 			'text':name,
    5294. 

  5294. 			'onvalue':1,
    5295. 

  5295. 			'offvalue':0,
    5296. 

  5296. 			'activeforeground':fg,
    5297. 

  5297. 			'activebackground':bg,
    5298. 

  5298. 			'highlightbackground':bg,
    5299. 

  5299. 			'fg':fg,
    5300. 

  5300. 			'bg':bg,
    5301. 

  5301. 			'anchor':'w'
    5302. 

  5302. 		})
    5303. 

  5303. 		chk = Tkinter.Checkbutton(self.window, opts)
    5304. 

  5304. 		if checked: chk.select()
    5305. 

  5305. 		chk.grid(columnspan=2, sticky='w', padx=0)
    5306. 

  5306. 	def menu(self,sel,items):
    5307. 

  5307. 		return apply(Tkinter.OptionMenu,(self.window,sel)+tuple(items))
    5308. 

  5308. 	
    5309. 

  5309. 	# Handy auxiliary functions
    5310. 

  5310. 	def action(self, txt):
    5311. 

  5311. 		self.label(
    5312. 

  5312. 			txt,
    5313. 

  5313. 			fg=self.fg1,
    5314. 

  5314. 			bg=self.bg1,
    5315. 

  5315. 			wraplength=self.action_length).grid(column=0,row=self.row)
    5316. 

  5316. 	def frame_open(self):
    5317. 

  5317. 		self.window = Tkinter.Frame(
    5318. 

  5318. 			self.root,
    5319. 

  5319. 			bg=self.bg2,
    5320. 

  5320. 			borderwidth=self.frame_border)
    5321. 

  5321. 	def frame_close(self):
    5322. 

  5322. 		self.window.grid(
    5323. 

  5323. 			column=1,
    5324. 

  5324. 			row=self.row,
    5325. 

  5325. 			sticky='w',
    5326. 

  5326. 			padx=self.frame_margin)
    5327. 

  5327. 		self.window = self.root
    5328. 

  5328. 		self.label('').grid()
    5329. 

  5329. 		self.row += 2   # update row count
    5330. 

  5330. 	def target_name2key(self):
    5331. 

  5331. 		name = self.target_name.get()
    5332. 

  5332. 		target = filter(lambda x: TARGET_NAMES[x] == name, TARGETS)
    5333. 

  5333. 		try   : key = target[0]
    5334. 

  5334. 		except: key = ''
    5335. 

  5335. 		self.target = self.setvar(key)
    5336. 

  5336. 	def target_key2name(self):
    5337. 

  5337. 		key = self.target.get()
    5338. 

  5338. 		name = TARGET_NAMES.get(key) or key
    5339. 

  5339. 		self.target_name = self.setvar(name)
    5340. 

  5340. 	
    5341. 

  5341. 	def exit(self): self.root.destroy()
    5342. 

  5342. 	def setvar(self, val): z = Tkinter.StringVar() ; z.set(val) ; return z
    5343. 

  5343. 	
    5344. 

  5344. 	def askfile(self):
    5345. 

  5345. 		ftypes= [(_('txt2tags files'), ('*.t2t','*.txt')), (_('All files'),'*')]
    5346. 

  5346. 		newfile = askopenfilename(filetypes=ftypes)
    5347. 

  5347. 		if newfile:
    5348. 

  5348. 			self.infile.set(newfile)
    5349. 

  5349. 			newconf = process_source_file(newfile)[0]
    5350. 

  5350. 			newconf = ConfigMaster().sanity(newconf, gui=1)
    5351. 

  5351. 			# Restate all checkboxes after file selection
    5352. 

  5352. 			#TODO how to make a refresh without killing it?
    5353. 

  5353. 			self.root.destroy()
    5354. 

  5354. 			self.__init__(newconf)
    5355. 

  5355. 			self.mainwindow()
    5356. 

  5356. 	
    5357. 

  5357. 	def scrollwindow(self, txt='no text!', title=''):
    5358. 

  5358. 		# Create components
    5359. 

  5359. 		win    = Tkinter.Toplevel() ; win.title(title)
    5360. 

  5360. 		frame  = Tkinter.Frame(win)
    5361. 

  5361. 		scroll = Tkinter.Scrollbar(frame)
    5362. 

  5362. 		text   = Tkinter.Text(frame,yscrollcommand=scroll.set)
    5363. 

  5363. 		button = Tkinter.Button(win)
    5364. 

  5364. 		# Config
    5365. 

  5365. 		text.insert(Tkinter.END, '\n'.join(txt))
    5366. 

  5366. 		scroll.config(command=text.yview)
    5367. 

  5367. 		button.config(text=_('Close'), command=win.destroy)
    5368. 

  5368. 		button.focus_set()
    5369. 

  5369. 		# Packing
    5370. 

  5370. 		text.pack(side='left', fill='both', expand=1)
    5371. 

  5371. 		scroll.pack(side='right', fill='y')
    5372. 

  5372. 		frame.pack(fill='both', expand=1)
    5373. 

  5373. 		button.pack(ipadx=30)
    5374. 

  5374. 	
    5375. 

  5375. 	def runprogram(self):
    5376. 

  5376. 		global CMDLINE_RAW
    5377. 

  5377. 		# Prepare
    5378. 

  5378. 		self.target_name2key()
    5379. 

  5379. 		infile, target = self.infile.get(), self.target.get()
    5380. 

  5380. 		# Sanity
    5381. 

  5381. 		if not target:
    5382. 

  5382. 			showwarning(my_name,_("You must select a target type!"))
    5383. 

  5383. 			return
    5384. 

  5384. 		if not infile:
    5385. 

  5385. 			showwarning(my_name,_("You must provide the source file location!"))
    5386. 

  5386. 			return
    5387. 

  5387. 		# Compose cmdline
    5388. 

  5388. 		guiflags = []
    5389. 

  5389. 		real_cmdline_conf = ConfigMaster(CMDLINE_RAW).parse()
    5390. 

  5390. 		if real_cmdline_conf.has_key('infile'):
    5391. 

  5391. 			del real_cmdline_conf['infile']
    5392. 

  5392. 		if real_cmdline_conf.has_key('target'):
    5393. 

  5393. 			del real_cmdline_conf['target']
    5394. 

  5394. 		real_cmdline = CommandLine().compose_cmdline(real_cmdline_conf)
    5395. 

  5395. 		default_outfile = ConfigMaster().get_outfile_name(
    5396. 

  5396. 			{'sourcefile':infile, 'outfile':'', 'target':target})
    5397. 

  5397. 		for opt in self.checks:
    5398. 

  5398. 			val = int(getattr(self, 'f_%s'%opt).get() or "0")
    5399. 

  5399. 			if opt == 'stdout': opt = 'outfile'
    5400. 

  5400. 			on_config  = self.conf.get(opt) or 0
    5401. 

  5401. 			on_cmdline = real_cmdline_conf.get(opt) or 0
    5402. 

  5402. 			if opt == 'outfile':
    5403. 

  5403. 				if on_config  == STDOUT: on_config = 1
    5404. 

  5404. 				else: on_config = 0
    5405. 

  5405. 				if on_cmdline == STDOUT: on_cmdline = 1
    5406. 

  5406. 				else: on_cmdline = 0
    5407. 

  5407. 			if val != on_config or (
    5408. 

  5408. 			  val == on_config == on_cmdline and
    5409. 

  5409. 			  real_cmdline_conf.has_key(opt)):
    5410. 

  5410. 				if val:
    5411. 

  5411. 					# Was not set, but user selected on GUI
    5412. 

  5412. 					Debug("user turned  ON: %s"%opt)
    5413. 

  5413. 					if opt == 'outfile': opt = '-o-'
    5414. 

  5414. 					else: opt = '--%s'%opt
    5415. 

  5415. 				else:
    5416. 

  5416. 					# Was set, but user deselected on GUI
    5417. 

  5417. 					Debug("user turned OFF: %s"%opt)
    5418. 

  5418. 					if opt == 'outfile':
    5419. 

  5419. 						opt = "-o%s"%default_outfile
    5420. 

  5420. 					else: opt = '--no-%s'%opt
    5421. 

  5421. 				guiflags.append(opt)
    5422. 

  5422. 		cmdline = [my_name, '-t', target] + real_cmdline + guiflags + [infile]
    5423. 

  5423. 		Debug('Gui/Tk cmdline: %s' % cmdline, 5)
    5424. 

  5424. 		# Run!
    5425. 

  5425. 		cmdline_raw_orig = CMDLINE_RAW
    5426. 

  5426. 		try:
    5427. 

  5427. 			# Fake the GUI cmdline as the real one, and parse file
    5428. 

  5428. 			CMDLINE_RAW = CommandLine().get_raw_config(cmdline[1:])
    5429. 

  5429. 			data = process_source_file(infile)
    5430. 

  5430. 			# On GUI, convert_* returns the data, not finish_him()
    5431. 

  5431. 			outlist, config = convert_this_files([data])
    5432. 

  5432. 			# On GUI and STDOUT, finish_him() returns the data
    5433. 

  5433. 			result = finish_him(outlist, config)
    5434. 

  5434. 			# Show outlist in s a nice new window
    5435. 

  5435. 			if result:
    5436. 

  5436. 				outlist, config = result
    5437. 

  5437. 				title = _('%s: %s converted to %s') % (
    5438. 

  5438. 					my_name,
    5439. 

  5439. 					os.path.basename(infile),
    5440. 

  5440. 					config['target'].upper())
    5441. 

  5441. 				self.scrollwindow(outlist, title)
    5442. 

  5442. 			# Show the "file saved" message
    5443. 

  5443. 			else:
    5444. 

  5444. 				msg = "%s\n\n  %s\n%s\n\n  %s\n%s"%(
    5445. 

  5445. 					_('Conversion done!'),
    5446. 

  5446. 					_('FROM:'), infile,
    5447. 

  5447. 					_('TO:'), config['outfile'])
    5448. 

  5448. 				showinfo(my_name, msg)
    5449. 

  5449. 		except error:         # common error (windowed), not quit
    5450. 

  5450. 			pass
    5451. 

  5451. 		except:               # fatal error (windowed and printed)
    5452. 

  5452. 			errormsg = getUnknownErrorMessage()
    5453. 

  5453. 			print errormsg
    5454. 

  5454. 			showerror(_('%s FATAL ERROR!')%my_name,errormsg)
    5455. 

  5455. 			self.exit()
    5456. 

  5456. 		CMDLINE_RAW = cmdline_raw_orig
    5457. 

  5457. 	
    5458. 

  5458. 	def mainwindow(self):
    5459. 

  5459. 		self.infile.set(self.conf.get('sourcefile') or '')
    5460. 

  5460. 		self.target.set(self.conf.get('target') or _('-- select one --'))
    5461. 

  5461. 		outfile = self.conf.get('outfile')
    5462. 

  5462. 		if outfile == STDOUT:                  # map -o-
    5463. 

  5463. 			self.conf['stdout'] = 1
    5464. 

  5464. 		if self.conf.get('headers') == None:
    5465. 

  5465. 			self.conf['headers'] = 1       # map default
    5466. 

  5466. 		
    5467. 

  5467. 		action1 = _("Enter the source file location:")
    5468. 

  5468. 		action2 = _("Choose the target document type:")
    5469. 

  5469. 		action3 = _("Some options you may check:")
    5470. 

  5470. 		action4 = _("Some extra options:")
    5471. 

  5471. 		checks_txt = {
    5472. 

  5472. 			'headers'   : _("Include headers on output"),
    5473. 

  5473. 			'enum-title': _("Number titles (1, 1.1, 1.1.1, etc)"),
    5474. 

  5474. 			'toc'       : _("Do TOC also (Table of Contents)"),
    5475. 

  5475. 			'mask-email': _("Hide e-mails from SPAM robots"),
    5476. 

  5476. 		
    5477. 

  5477. 			'toc-only'  : _("Just do TOC, nothing more"),
    5478. 

  5478. 			'stdout'    : _("Dump to screen (Don't save target file)")
    5479. 

  5479. 		}
    5480. 

  5480. 		targets_menu = map(lambda x: TARGET_NAMES[x], TARGETS)
    5481. 

  5481. 		
    5482. 

  5482. 		# Header
    5483. 

  5483. 		self.label("%s %s"%(my_name.upper(), my_version),
    5484. 

  5484. 			bg=self.bg2, fg=self.fg2).grid(columnspan=2, ipadx=10)
    5485. 

  5485. 		self.label(_("ONE source, MULTI targets")+'\n%s\n'%my_url,
    5486. 

  5486. 			bg=self.bg1, fg=self.fg1).grid(columnspan=2)
    5487. 

  5487. 		self.row = 2
    5488. 

  5488. 		# Choose input file
    5489. 

  5489. 		self.action(action1) ; self.frame_open()
    5490. 

  5490. 		e_infile = self.entry(textvariable=self.infile,width=25)
    5491. 

  5491. 		e_infile.grid(row=self.row, column=0, sticky='e')
    5492. 

  5492. 		if not self.infile.get(): e_infile.focus_set()
    5493. 

  5493. 		self.button(_("Browse"), self.askfile).grid(
    5494. 

  5494. 			row=self.row, column=1, sticky='w', padx=10)
    5495. 

  5495. 		# Show outfile name, style and encoding (if any)
    5496. 

  5496. 		txt = ''
    5497. 

  5497. 		if outfile:
    5498. 

  5498. 			txt = outfile
    5499. 

  5499. 			if outfile == STDOUT: txt = _('<screen>')
    5500. 

  5500. 			l_output = self.label(_('Output: ')+txt, fg=self.fg2, bg=self.bg2)
    5501. 

  5501. 			l_output.grid(columnspan=2, sticky='w')
    5502. 

  5502. 		for setting in ['style','encoding']:
    5503. 

  5503. 			if self.conf.get(setting):
    5504. 

  5504. 				name = setting.capitalize()
    5505. 

  5505. 				val  = self.conf[setting]
    5506. 

  5506. 				self.label('%s: %s'%(name, val),
    5507. 

  5507. 					fg=self.fg2, bg=self.bg2).grid(
    5508. 

  5508. 					columnspan=2, sticky='w')
    5509. 

  5509. 		# Choose target
    5510. 

  5510. 		self.frame_close() ; self.action(action2)
    5511. 

  5511. 		self.frame_open()
    5512. 

  5512. 		self.target_key2name()
    5513. 

  5513. 		self.menu(self.target_name, targets_menu).grid(
    5514. 

  5514. 			columnspan=2, sticky='w')
    5515. 

  5515. 		# Options checkboxes label
    5516. 

  5516. 		self.frame_close() ; self.action(action3)
    5517. 

  5517. 		self.frame_open()
    5518. 

  5518. 		# Compose options check boxes, example:
    5519. 

  5519. 		# self.check(checks_txt['toc'],1,variable=self.f_toc)
    5520. 

  5520. 		for check in self.checks:
    5521. 

  5521. 			# Extra options label
    5522. 

  5522. 			if check == 'toc-only':
    5523. 

  5523. 				self.frame_close() ; self.action(action4)
    5524. 

  5524. 				self.frame_open()
    5525. 

  5525. 			txt = checks_txt[check]
    5526. 

  5526. 			var = getattr(self, 'f_'+check)
    5527. 

  5527. 			checked = self.conf.get(check)
    5528. 

  5528. 			self.check(txt,checked,variable=var)
    5529. 

  5529. 		self.frame_close()
    5530. 

  5530. 		# Spacer and buttons
    5531. 

  5531. 		self.label('').grid() ; self.row += 1
    5532. 

  5532. 		b_quit = self.button(_("Quit"), self.exit)
    5533. 

  5533. 		b_quit.grid(row=self.row, column=0, sticky='w', padx=30)
    5534. 

  5534. 		b_conv = self.button(_("Convert!"), self.runprogram)
    5535. 

  5535. 		b_conv.grid(row=self.row, column=1, sticky='e', padx=30)
    5536. 

  5536. 		if self.target.get() and self.infile.get():
    5537. 

  5537. 			b_conv.focus_set()
    5538. 

  5538. 		
    5539. 

  5539. 		# As documentation told me
    5540. 

  5540. 		if sys.platform.startswith('win'):
    5541. 

  5541. 			self.root.iconify()
    5542. 

  5542. 			self.root.update()
    5543. 

  5543. 			self.root.deiconify()
    5544. 

  5544. 		
    5545. 

  5545. 		self.root.mainloop()
    5546. 

  5546. 

  5547. 

  5548. ##############################################################################
    5549. 

  5549. ##############################################################################
    5550. 

  5550. 

  5551. def exec_command_line(user_cmdline=[]):
    5552. 

  5552. 	global CMDLINE_RAW, RC_RAW, DEBUG, VERBOSE, QUIET, GUI, AA_CHARS, AA_LCHARS, Error
    5553. 

  5553. 	
    5554. 

  5554. 	# Extract command line data
    5555. 

  5555. 	cmdline_data = user_cmdline or sys.argv[1:]
    5556. 

  5556. 	CMDLINE_RAW = CommandLine().get_raw_config(cmdline_data, relative=1)
    5557. 

  5557. 	cmdline_parsed = ConfigMaster(CMDLINE_RAW).parse()
    5558. 

  5558. 	DEBUG   = cmdline_parsed.get('debug'  ) or 0
    5559. 

  5559. 	VERBOSE = cmdline_parsed.get('verbose') or 0
    5560. 

  5560. 	QUIET   = cmdline_parsed.get('quiet'  ) or 0
    5561. 

  5561. 	GUI     = cmdline_parsed.get('gui'    ) or 0
    5562. 

  5562. 	infiles = cmdline_parsed.get('infile' ) or []
    5563. 

  5563. 	
    5564. 

  5564. 	if 'ascii-art' in cmdline_parsed:
    5565. 

  5565. 		lascii = cmdline_parsed['ascii-art']
    5566. 

  5566. 		diff = len(AA_LCHARS)-len(lascii)
    5567. 

  5567. 		if not diff:
    5568. 

  5568. 			AA_CHARS = dict(zip(AA_LCHARS, lascii))
    5569. 

  5569. 		else:
    5570. 

  5570. 			Error(_("%i char(s) to the right number")%diff)
    5571. 

  5571. 	
    5572. 

  5572. 	Message(_("Txt2tags %s processing begins")%my_version,1)
    5573. 

  5573. 	
    5574. 

  5574. 	# The easy ones
    5575. 

  5575. 	if cmdline_parsed.get('help'   ): Quit(USAGE)
    5576. 

  5576. 	if cmdline_parsed.get('version'): Quit(VERSIONSTR)
    5577. 

  5577. 	
    5578. 

  5578. 	# Multifile haters
    5579. 

  5579. 	if len(infiles) > 1:
    5580. 

  5580. 		errmsg=_("Option --%s can't be used with multiple input files")
    5581. 

  5581. 		for option in NO_MULTI_INPUT:
    5582. 

  5582. 			if cmdline_parsed.get(option):
    5583. 

  5583. 				Error(errmsg%option)
    5584. 

  5584. 	
    5585. 

  5585. 	Debug("system platform: %s"%sys.platform)
    5586. 

  5586. 	Debug("python version: %s"%(sys.version.split('(')[0]))
    5587. 

  5587. 	Debug("line break char: %s"%repr(LB))
    5588. 

  5588. 	Debug("command line: %s"%sys.argv)
    5589. 

  5589. 	Debug("command line raw config: %s"%CMDLINE_RAW,1)
    5590. 

  5590. 	
    5591. 

  5591. 	# Extract RC file config
    5592. 

  5592. 	if cmdline_parsed.get('rc') == 0:
    5593. 

  5593. 		Message(_("Ignoring user configuration file"),1)
    5594. 

  5594. 	else:
    5595. 

  5595. 		rc_file = get_rc_path()
    5596. 

  5596. 		if os.path.isfile(rc_file):
    5597. 

  5597. 			Message(_("Loading user configuration file"),1)
    5598. 

  5598. 			RC_RAW = ConfigLines(file=rc_file).get_raw_config()
    5599. 

  5599. 		
    5600. 

  5600. 		Debug("rc file: %s"%rc_file)
    5601. 

  5601. 		Debug("rc file raw config: %s"%RC_RAW,1)
    5602. 

  5602. 	
    5603. 

  5603. 	# Get all infiles config (if any)
    5604. 

  5604. 	infiles_config = get_infiles_config(infiles)
    5605. 

  5605. 	
    5606. 

  5606. 	# Is GUI available?
    5607. 

  5607. 	# Try to load and start GUI interface for --gui
    5608. 

  5608. 	# If program was called with no arguments, try GUI also
    5609. 

  5609. 	if GUI or not infiles:
    5610. 

  5610. 		try:
    5611. 

  5611. 			load_GUI_resources()
    5612. 

  5612. 			Debug("GUI resources OK (Tk module is installed)")
    5613. 

  5613. 			winbox = Gui()
    5614. 

  5614. 			Debug("GUI display OK")
    5615. 

  5615. 			GUI = 1
    5616. 

  5616. 		except:
    5617. 

  5617. 			Debug("GUI Error: no Tk module or no DISPLAY")
    5618. 

  5618. 			GUI = 0
    5619. 

  5619. 	
    5620. 

  5620. 	# User forced --gui, but it's not available
    5621. 

  5621. 	if cmdline_parsed.get('gui') and not GUI:
    5622. 

  5622. 		print getTraceback(); print
    5623. 

  5623. 		Error(
    5624. 

  5624. 			"Sorry, I can't run my Graphical Interface - GUI\n"
    5625. 

  5625. 			"- Check if Python Tcl/Tk module is installed (Tkinter)\n"
    5626. 

  5626. 			"- Make sure you are in a graphical environment (like X)")
    5627. 

  5627. 	
    5628. 

  5628. 	# Okay, we will use GUI
    5629. 

  5629. 	if GUI:
    5630. 

  5630. 		Message(_("We are on GUI interface"),1)
    5631. 

  5631. 		
    5632. 

  5632. 		# Redefine Error function to raise exception instead sys.exit()
    5633. 

  5633. 		def Error(msg):
    5634. 

  5634. 			showerror(_('txt2tags ERROR!'), msg)
    5635. 

  5635. 			raise error
    5636. 

  5636. 		
    5637. 

  5637. 		# If no input file, get RC+cmdline config, else full config
    5638. 

  5638. 		if not infiles:
    5639. 

  5639. 			gui_conf = ConfigMaster(RC_RAW+CMDLINE_RAW).parse()
    5640. 

  5640. 		else:
    5641. 

  5641. 			try   : gui_conf = infiles_config[0][0]
    5642. 

  5642. 			except: gui_conf = {}
    5643. 

  5643. 		
    5644. 

  5644. 		# Sanity is needed to set outfile and other things
    5645. 

  5645. 		gui_conf = ConfigMaster().sanity(gui_conf, gui=1)
    5646. 

  5646. 		Debug("GUI config: %s"%gui_conf,5)
    5647. 

  5647. 		
    5648. 

  5648. 		# Insert config and populate the nice window!
    5649. 

  5649. 		winbox.load_config(gui_conf)
    5650. 

  5650. 		winbox.mainwindow()
    5651. 

  5651. 	
    5652. 

  5652. 	# Console mode rocks forever!
    5653. 

  5653. 	else:
    5654. 

  5654. 		Message(_("We are on Command Line interface"),1)
    5655. 

  5655. 		
    5656. 

  5656. 		# Called with no arguments, show error
    5657. 

  5657. 		if not infiles: Error(_('Missing input file (try --help)'))
    5658. 

  5658. 		
    5659. 

  5659. 		convert_this_files(infiles_config)
    5660. 

  5660. 	
    5661. 

  5661. 	Message(_("Txt2tags finished sucessfuly"),1)
    5662. 

  5662. 

  5663. if __name__ == '__main__':
    5664. 

  5664. 	try:
    5665. 

  5665. 		exec_command_line()
    5666. 

  5666. 	except error, msg:
    5667. 

  5667. 		sys.stderr.write("%s\n"%msg)
    5668. 

  5668. 		sys.stderr.flush()
    5669. 

  5669. 		sys.exit(1)
    5670. 

  5670. 	except SystemExit:
    5671. 

  5671. 		pass
    5672. 

  5672. 	except:
    5673. 

  5673. 		sys.stderr.write(getUnknownErrorMessage())
    5674. 

  5674. 		sys.stderr.flush()
    5675. 

  5675. 		sys.exit(1)
    5676. 

  5676. 	Quit()
    5677. 

  5677. 

  5678. # The End.
    5679. 

  5679.