PageRenderTime 92ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 1ms

/old/txt2tags-2.6.py

http://txt2tags.googlecode.com/
Python | 5987 lines | 5359 code | 249 blank | 379 comment | 250 complexity | 79cde3d3abf5bbc7e2598b375572527c MD5 | raw file
Possible License(s): GPL-2.0, GPL-3.0, WTFPL 
    

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

  2. # txt2tags - generic text conversion tool
    3. 

  3. # http://txt2tags.org
    4. 

  4. #
    5. 

  5. # Copyright 2001-2010 Aurelio Jargas
    6. 

  6. #
    7. 

  7. # License: http://www.gnu.org/licenses/gpl-2.0.txt
    8. 

  8. # Subversion: http://svn.txt2tags.org
    9. 

  9. # Bug tracker: http://bugs.txt2tags.org
    10. 

  10. #
    11. 

  11. ########################################################################
    12. 

  12. #
    13. 

  13. #   BORING CODE EXPLANATION AHEAD
    14. 

  14. #
    15. 

  15. # Just read it if you wish to understand how the txt2tags code works.
    16. 

  16. #
    17. 

  17. ########################################################################
    18. 

  18. #
    19. 

  19. # The code that [1] parses the marked text is separated from the
    20. 

  20. # code that [2] insert the target tags.
    21. 

  21. #
    22. 

  22. #   [1] made by: def convert()
    23. 

  23. #   [2] made by: class BlockMaster
    24. 

  24. #
    25. 

  25. # The structures of the marked text are identified and its contents are
    26. 

  26. # extracted into a data holder (Python lists and dictionaries).
    27. 

  27. #
    28. 

  28. # When parsing the source file, the blocks (para, lists, quote, table)
    29. 

  29. # are opened with BlockMaster, right when found. Then its contents,
    30. 

  30. # which spans on several lines, are feeded into a special holder on the
    31. 

  31. # BlockMaster instance. Just when the block is closed, the target tags
    32. 

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

  33. # have a better control on blocks. Much better than the previous line by
    34. 

  34. # line approach.
    35. 

  35. #
    36. 

  36. # In other words, whenever inside a block, the parser *holds* the tag
    37. 

  37. # insertion process, waiting until the full block is read. That was
    38. 

  38. # needed primary to close paragraphs for the XHTML target, but
    39. 

  39. # proved to be a very good adding, improving many other processing.
    40. 

  40. #
    41. 

  41. # -------------------------------------------------------------------
    42. 

  42. #
    43. 

  43. # These important classes are all documented:
    44. 

  44. # CommandLine, SourceDocument, ConfigMaster, ConfigLines.
    45. 

  45. #
    46. 

  46. # There is a RAW Config format and all kind of configuration is first
    47. 

  47. # converted to this format. Then a generic method parses it.
    48. 

  48. #
    49. 

  49. # These functions get information about the input file(s) and take
    50. 

  50. # care of the init processing:
    51. 

  51. # get_infiles_config(), process_source_file() and convert_this_files()
    52. 

  52. #
    53. 

  53. ########################################################################
    54. 

  54. 

  55. #XXX Python coding warning
    56. 

  56. # Avoid common mistakes:
    57. 

  57. # - do NOT use newlist=list instead newlist=list[:]
    58. 

  58. # - do NOT use newdic=dic   instead newdic=dic.copy()
    59. 

  59. # - do NOT use dic[key]     instead dic.get(key)
    60. 

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

  61. 

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

  63. # Can't fix that because the image is expanded together with the
    64. 

  64. # link, at the linkbank filling moment. Only the image is passed
    65. 

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

  66. 

  67. #XXX Paragraph separation not valid inside Quote
    68. 

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

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

  70. # different background color. Still don't know how to fix it.
    71. 

    72. 

  72. #XXX TODO (maybe)
    73. 

  73. # New mark or macro which expands to an anchor full title.
    74. 

  74. # It is necessary to parse the full document in this order:
    75. 

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

  76. #  DONE  2nd scan: BODY: expand includes & apply %!preproc
    77. 

  77. #        3rd scan: BODY: read titles and compose TOC info
    78. 

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

  79. # Steps 2 and 3 can be made together, with no tag adding.
    80. 

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

  81. # One solution may be add the titles as postproc rules
    82. 

  82. 

  83. 

  84. ##############################################################################
    85. 

  85. 

  86. # User config (1=ON, 0=OFF)
    87. 

  87. 

  88. USE_I18N    = 1   # use gettext for i18ned messages?        (default is 1)
    89. 

  89. COLOR_DEBUG = 1   # show debug messages in colors?          (default is 1)
    90. 

  90. BG_LIGHT    = 0   # your terminal background color is light (default is 0)
    91. 

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

  92. 

  93. ##############################################################################
    94. 

  94. 

  95. 

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

  97. import re, os, sys, time, getopt
    98. 

  98. 

  99. # The CSV module is new in Python version 2.3
    100. 

  100. try:
    101. 

  101. 	import csv
    102. 

  102. except ImportError:
    103. 

  103. 	csv = None
    104. 

  104. 

  105. # Program information
    106. 

  106. my_url = 'http://txt2tags.org'
    107. 

  107. my_name = 'txt2tags'
    108. 

  108. my_email = 'verde@aurelio.net'
    109. 

  109. my_version = '2.6'
    110. 

  110. 

  111. # i18n - just use if available
    112. 

  112. if USE_I18N:
    113. 

  113. 	try:
    114. 

  114. 		import gettext
    115. 

  115. 		# If your locale dir is different, change it here
    116. 

  116. 		cat = gettext.Catalog('txt2tags',localedir='/usr/share/locale/')
    117. 

  117. 		_ = cat.gettext
    118. 

  118. 	except:
    119. 

  119. 		_ = lambda x:x
    120. 

  120. else:
    121. 

  121. 	_ = lambda x:x
    122. 

  122. 

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

  124. # OPTIONS : the conversion related options, may be used in %!options
    125. 

  125. # ACTIONS : the other behavior modifiers, valid on command line only
    126. 

  126. # MACROS  : the valid macros with their default values for formatting
    127. 

  127. # SETTINGS: global miscellaneous settings, valid on RC file only
    128. 

  128. # NO_TARGET: actions that don't require a target specification
    129. 

  129. # NO_MULTI_INPUT: actions that don't accept more than one input file
    130. 

  130. # CONFIG_KEYWORDS: the valid %!key:val keywords
    131. 

  131. #
    132. 

  132. # FLAGS and OPTIONS are configs that affect the converted document.
    133. 

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

  134. #
    135. 

  135. # ACTIONS are needed because when doing multiple input files, strange
    136. 

  136. # behavior would be found, as use command line interface for the
    137. 

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

  138. # --version and --help inside %!options are also odd
    139. 

  139. #
    140. 

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

  141. TARGETS.sort()
    142. 

  142. 

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

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

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

  146.             'quiet'      :0 , 'slides'     :0 }
    147. 

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

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

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

  150.             'width'      :0 , 'height'     :0 , 'art-chars'  :'',
    151. 

  151.             'show-config-value':''}
    152. 

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

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

  154.             'dump-source':0 , 'targets'    :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', 'targets']
    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 text'),
    181. 

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

  182.   'creole' : _('Creole 1.0 document')
    183. 

  183. }
    184. 

  184. 

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

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

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

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

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

  190. 

  191. DFT_TEXT_WIDTH   = 72 # do not edit here, please use --width
    192. 

  192. DFT_SLIDE_WIDTH  = 80 # do not edit here, please use --width
    193. 

  193. DFT_SLIDE_HEIGHT = 25 # do not edit here, please use --height
    194. 

  194. 

  195. # ASCII Art config
    196. 

  196. AA_KEYS = 'corner border side bar1 bar2 level2 level3 level4 level5'.split()
    197. 

  197. AA_VALUES = '+-|-==-^"' # do not edit here, please use --art-chars
    198. 

  198. AA = dict(zip(AA_KEYS, AA_VALUES))
    199. 

  199. AA_COUNT = 0
    200. 

  200. AA_TITLE = ''
    201. 

  201. 

  202. RC_RAW = []
    203. 

  203. CMDLINE_RAW = []
    204. 

  204. CONF = {}
    205. 

  205. BLOCK = None
    206. 

  206. TITLE = None
    207. 

  207. regex = {}
    208. 

  208. TAGS = {}
    209. 

  209. rules = {}
    210. 

  210. 

  211. # Gui globals
    212. 

  212. askopenfilename = None
    213. 

  213. showinfo = None
    214. 

  214. showwarning = None
    215. 

  215. showerror = None
    216. 

  216. 

  217. lang = 'english'
    218. 

  218. TARGET = ''
    219. 

  219. 

  220. STDIN = STDOUT = '-'
    221. 

  221. MODULEIN = MODULEOUT = '-module-'
    222. 

  222. ESCCHAR   = '\x00'
    223. 

  223. SEPARATOR = '\x01'
    224. 

  224. LISTNAMES = {'-':'list', '+':'numlist', ':':'deflist'}
    225. 

  225. LINEBREAK = {'default':'\n', 'win':'\r\n', 'mac':'\r'}
    226. 

  226. 

  227. # Platform specific settings
    228. 

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

  229. 

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

  231. 

  232. USAGE =  '\n'.join([
    233. 

  233. '',
    234. 

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

  235. '',
    236. 

  236. _("      --targets       print a list of all the available targets and exit"),
    237. 

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

  238.   '                      %s,' % ', '.join(TARGETS[:9]),
    239. 

  239.   '                      %s'  % ', '.join(TARGETS[9:]),
    240. 

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

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

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

  243. _("      --toc           add an automatic Table of Contents to the output"),
    244. 

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

  245. _("      --toc-only      print the Table of Contents and exit"),
    246. 

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

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

  248. _("      --css-sugar     insert CSS-friendly tags for HTML/XHTML"),
    249. 

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

  250. _("  -H, --no-headers    suppress header and footer from the output"),
    251. 

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

  252. _("      --slides        format output as presentation slides (used by -t art)"),
    253. 

  253. _("      --width=N       set the output's width to N columns (used by -t art)"),
    254. 

  254. _("      --height=N      set the output's height to N rows (used by -t art)"),
    255. 

  255. _("  -C, --config-file=F read configuration from file F"),
    256. 

  256. _("      --gui           invoke Graphical Tk Interface"),
    257. 

  257. _("  -q, --quiet         quiet mode, suppress all output (except errors)"),
    258. 

  258. _("  -v, --verbose       print informative messages during conversion"),
    259. 

  259. _("  -h, --help          print this help information and exit"),
    260. 

  260. _("  -V, --version       print program version and exit"),
    261. 

  261. _("      --dump-config   print all the configuration found and exit"),
    262. 

  262. _("      --dump-source   print the document source, with includes expanded"),
    263. 

  263. '',
    264. 

  264. _("Turn OFF options:"),
    265. 

  265. "     --no-css-inside, --no-css-sugar, --no-dump-config, --no-dump-source,",
    266. 

  266. "     --no-encoding, --no-enum-title, --no-headers, --no-infile,",
    267. 

  267. "     --no-mask-email, --no-outfile, --no-quiet, --no-rc, --no-slides,",
    268. 

  268. "     --no-style, --no-targets, --no-toc, --no-toc-only",
    269. 

  269. '',
    270. 

  270. _("Example:"),
    271. 

  271. "     %s -t html --toc %s" % (my_name, _("file.t2t")),
    272. 

  272. '',
    273. 

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

  274. _("Use --outfile to force an output file name."),
    275. 

  275. _("If  input file is '-', reads from STDIN."),
    276. 

  276. _("If output file is '-', dumps output to STDOUT."),
    277. 

  277. '',
    278. 

  278. my_url,
    279. 

  279. ''
    280. 

  280. ])
    281. 

  281. 

  282. 

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

  284. 

  285. 

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

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

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

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

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

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

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

  293. #
    294. 

  294. HEADER_TEMPLATE = {
    295. 

  295. 	'art':"""
    296. 

  296. Fake template to respect the general process.
    297. 

  297. """,
    298. 

  298. 	'txt': """\
    299. 

  299. %(HEADER1)s
    300. 

  300. %(HEADER2)s
    301. 

  301. %(HEADER3)s
    302. 

  302. """,
    303. 

    304. 

  304. 	'sgml': """\
    305. 

  305. <!doctype linuxdoc system>
    306. 

  306. <article>
    307. 

  307. <title>%(HEADER1)s
    308. 

  308. <author>%(HEADER2)s
    309. 

  309. <date>%(HEADER3)s
    310. 

  310. """,
    311. 

    312. 

  312. 	'html': """\
    313. 

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

  314. <HTML>
    315. 

  315. <HEAD>
    316. 

  316. <META NAME="generator" CONTENT="http://txt2tags.org">
    317. 

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

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

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

  320. </HEAD><BODY BGCOLOR="white" TEXT="black">
    321. 

  321. <CENTER>
    322. 

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

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

  324. <FONT SIZE="4">%(HEADER3)s</FONT>
    325. 

  325. </CENTER>
    326. 

  326. """,
    327. 

    328. 

  328. 	'htmlcss': """\
    329. 

  329. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    330. 

  330. <HTML>
    331. 

  331. <HEAD>
    332. 

  332. <META NAME="generator" CONTENT="http://txt2tags.org">
    333. 

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

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

  335. <TITLE>%(HEADER1)s</TITLE>
    336. 

  336. </HEAD>
    337. 

  337. <BODY>
    338. 

  338. 

  339. <DIV CLASS="header" ID="header">
    340. 

  340. <H1>%(HEADER1)s</H1>
    341. 

  341. <H2>%(HEADER2)s</H2>
    342. 

  342. <H3>%(HEADER3)s</H3>
    343. 

  343. </DIV>
    344. 

  344. """,
    345. 

    346. 

  346. 	'xhtml': """\
    347. 

  347. <?xml version="1.0"
    348. 

  348.       encoding="%(ENCODING)s"
    349. 

  349. ?>
    350. 

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

  351.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    352. 

  352. <html xmlns="http://www.w3.org/1999/xhtml">
    353. 

  353. <head>
    354. 

  354. <title>%(HEADER1)s</title>
    355. 

  355. <meta name="generator" content="http://txt2tags.org" />
    356. 

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

  357. </head>
    358. 

  358. <body bgcolor="white" text="black">
    359. 

  359. <div align="center">
    360. 

  360. <h1>%(HEADER1)s</h1>
    361. 

  361. <h2>%(HEADER2)s</h2>
    362. 

  362. <h3>%(HEADER3)s</h3>
    363. 

  363. </div>
    364. 

  364. """,
    365. 

    366. 

  366. 	'xhtmlcss': """\
    367. 

  367. <?xml version="1.0"
    368. 

  368.       encoding="%(ENCODING)s"
    369. 

  369. ?>
    370. 

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

  371.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    372. 

  372. <html xmlns="http://www.w3.org/1999/xhtml">
    373. 

  373. <head>
    374. 

  374. <title>%(HEADER1)s</title>
    375. 

  375. <meta name="generator" content="http://txt2tags.org" />
    376. 

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

  377. </head>
    378. 

  378. <body>
    379. 

  379. 

  380. <div class="header" id="header">
    381. 

  381. <h1>%(HEADER1)s</h1>
    382. 

  382. <h2>%(HEADER2)s</h2>
    383. 

  383. <h3>%(HEADER3)s</h3>
    384. 

  384. </div>
    385. 

  385. """,
    386. 

    387. 

  387. 	'dbk': """\
    388. 

  388. <?xml version="1.0"
    389. 

  389.       encoding="%(ENCODING)s"
    390. 

  390. ?>
    391. 

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

  392.  "docbook/dtd/xml/4.5/docbookx.dtd">
    393. 

  393. <article lang="en">
    394. 

  394.   <articleinfo>
    395. 

  395.     <title>%(HEADER1)s</title>
    396. 

  396.     <authorgroup>
    397. 

  397.       <author><othername>%(HEADER2)s</othername></author>
    398. 

  398.     </authorgroup>
    399. 

  399.     <date>%(HEADER3)s</date>
    400. 

  400.   </articleinfo>
    401. 

  401. """,
    402. 

    403. 

  403. 	'man': """\
    404. 

  404. .TH "%(HEADER1)s" 1 "%(HEADER3)s" "%(HEADER2)s"
    405. 

  405. """,
    406. 

    407. 

  407. # TODO style to <HR>
    408. 

  408. 	'pm6': """\
    409. 

  409. <PMTags1.0 win><C-COLORTABLE ("Preto" 1 0 0 0)
    410. 

  410. ><@Normal=
    411. 

  411.   <FONT "Times New Roman"><CCOLOR "Preto"><SIZE 11>
    412. 

  412.   <HORIZONTAL 100><LETTERSPACE 0><CTRACK 127><CSSIZE 70><C+SIZE 58.3>
    413. 

  413.   <C-POSITION 33.3><C+POSITION 33.3><P><CBASELINE 0><CNOBREAK 0><CLEADING -0.05>
    414. 

  414.   <GGRID 0><GLEFT 7.2><GRIGHT 0><GFIRST 0><G+BEFORE 7.2><G+AFTER 0>
    415. 

  415.   <GALIGNMENT "justify"><GMETHOD "proportional"><G& "ENGLISH">
    416. 

  416.   <GPAIRS 12><G%% 120><GKNEXT 0><GKWIDOW 0><GKORPHAN 0><GTABS $>
    417. 

  417.   <GHYPHENATION 2 34 0><GWORDSPACE 75 100 150><GSPACE -5 0 25>
    418. 

  418. ><@Bullet=<@-PARENT "Normal"><FONT "Abadi MT Condensed Light">
    419. 

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

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

  421.   <GLEFT 0><G+BEFORE 0><GALIGNMENT "left"><GWORDSPACE 100 100 100><GSPACE 0 0 0>
    422. 

  422. ><@Title1=<@-PARENT "Normal"><FONT "Arial"><SIZE 14><B>
    423. 

  423.   <GCONTENTS><GLEFT 0><G+BEFORE 0><GALIGNMENT "left">
    424. 

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

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

  426. ><@Title4=<@-PARENT "Title3">
    427. 

  427. ><@Title5=<@-PARENT "Title3">
    428. 

  428. ><@Quote=<@-PARENT "Normal"><SIZE 10><I>>
    429. 

  429. 

  430. %(HEADER1)s
    431. 

  431. %(HEADER2)s
    432. 

  432. %(HEADER3)s
    433. 

  433. """,
    434. 

    435. 

  435. 	'mgp': """\
    436. 

  436. #!/usr/X11R6/bin/mgp -t 90
    437. 

  437. %%deffont "normal"    xfont  "utopia-medium-r", charset "iso8859-1"
    438. 

  438. %%deffont "normal-i"  xfont  "utopia-medium-i", charset "iso8859-1"
    439. 

  439. %%deffont "normal-b"  xfont  "utopia-bold-r"  , charset "iso8859-1"
    440. 

  440. %%deffont "normal-bi" xfont  "utopia-bold-i"  , charset "iso8859-1"
    441. 

  441. %%deffont "mono"      xfont "courier-medium-r", charset "iso8859-1"
    442. 

  442. %%default 1 size 5
    443. 

  443. %%default 2 size 8, fore "yellow", font "normal-b", center
    444. 

  444. %%default 3 size 5, fore "white",  font "normal", left, prefix "  "
    445. 

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

  446. %%tab 2 prefix "            ", icon arc "orange" 40, leftfill
    447. 

  447. %%tab 3 prefix "                   ", icon arc "brown" 40, leftfill
    448. 

  448. %%tab 4 prefix "                          ", icon arc "darkmagenta" 40, leftfill
    449. 

  449. %%tab 5 prefix "                                ", icon arc "magenta" 40, leftfill
    450. 

  450. %%%%------------------------- end of headers -----------------------------
    451. 

  451. %%page
    452. 

  452. 

  453. 

  454. 

  455. 

  456. 

  457. %%size 10, center, fore "yellow"
    458. 

  458. %(HEADER1)s
    459. 

  459. 

  460. %%font "normal-i", size 6, fore "white", center
    461. 

  461. %(HEADER2)s
    462. 

  462. 

  463. %%font "mono", size 7, center
    464. 

  464. %(HEADER3)s
    465. 

  465. """,
    466. 

    467. 

  467. 	'moin': """\
    468. 

  468. '''%(HEADER1)s'''
    469. 

  469. 

  470. ''%(HEADER2)s''
    471. 

  471. 

  472. %(HEADER3)s
    473. 

  473. """,
    474. 

    475. 

  475. 	'gwiki': """\
    476. 

  476. *%(HEADER1)s*
    477. 

  477. 

  478. %(HEADER2)s
    479. 

  479. 

  480. _%(HEADER3)s_
    481. 

  481. """,
    482. 

    483. 

  483. 	'adoc': """\
    484. 

  484. = %(HEADER1)s
    485. 

  485. %(HEADER2)s
    486. 

  486. %(HEADER3)s
    487. 

  487. """,
    488. 

    489. 

  489. 	'doku': """\
    490. 

  490. ===== %(HEADER1)s =====
    491. 

  491. 

  492. **//%(HEADER2)s//**
    493. 

  493. 

  494. //%(HEADER3)s//
    495. 

  495. """,
    496. 

    497. 

  497. 	'pmw': """\
    498. 

  498. (:Title %(HEADER1)s:)
    499. 

  499. 

  500. (:Description %(HEADER2)s:)
    501. 

  501. 

  502. (:Summary %(HEADER3)s:)
    503. 

  503. """,
    504. 

    505. 

  505. 	'wiki': """\
    506. 

  506. '''%(HEADER1)s'''
    507. 

  507. 

  508. %(HEADER2)s
    509. 

  509. 

  510. ''%(HEADER3)s''
    511. 

  511. """,
    512. 

    513. 

  513. 	'tex': \
    514. 

  514. r"""\documentclass{article}
    515. 

  515. \usepackage{graphicx}
    516. 

  516. \usepackage{paralist} %% needed for compact lists
    517. 

  517. \usepackage[normalem]{ulem} %% needed by strike
    518. 

  518. \usepackage[urlcolor=blue,colorlinks=true]{hyperref}
    519. 

  519. \usepackage[%(ENCODING)s]{inputenc}  %% char encoding
    520. 

  520. \usepackage{%(STYLE)s}  %% user defined
    521. 

  521. 

  522. \title{%(HEADER1)s}
    523. 

  523. \author{%(HEADER2)s}
    524. 

  524. \begin{document}
    525. 

  525. \date{%(HEADER3)s}
    526. 

  526. \maketitle
    527. 

  527. \clearpage
    528. 

  528. """,
    529. 

    530. 

  530. 	'lout': """\
    531. 

  531. @SysInclude { doc }
    532. 

  532. @Document
    533. 

  533.   @InitialFont { Times Base 12p }  # Times, Courier, Helvetica, ...
    534. 

  534.   @PageOrientation { Portrait }    # Portrait, Landscape
    535. 

  535.   @ColumnNumber { 1 }              # Number of columns (2, 3, ...)
    536. 

  536.   @PageHeaders { Simple }          # None, Simple, Titles, NoTitles
    537. 

  537.   @InitialLanguage { English }     # German, French, Portuguese, ...
    538. 

  538.   @OptimizePages { Yes }           # Yes/No smart page break feature
    539. 

  539. //
    540. 

  540. @Text @Begin
    541. 

  541. @Display @Heading { %(HEADER1)s }
    542. 

  542. @Display @I { %(HEADER2)s }
    543. 

  543. @Display { %(HEADER3)s }
    544. 

  544. #@NP                               # Break page after Headers
    545. 

  545. """,
    546. 

  546. 	'creole': """\
    547. 

  547. %(HEADER1)s
    548. 

  548. %(HEADER2)s
    549. 

  549. %(HEADER3)s
    550. 

  550. """
    551. 

  551. # @SysInclude { tbl }                   # Tables support
    552. 

  552. # setup: @MakeContents { Yes }          # show TOC
    553. 

  553. # setup: @SectionGap                    # break page at each section
    554. 

  554. }
    555. 

  555. 

  556. 

  557. ##############################################################################
    558. 

  558. 

  559. 

  560. def getTags(config):
    561. 

  561. 	"Returns all the known tags for the specified target"
    562. 

  562. 	
    563. 

  563. 	keys = """
    564. 

  564. 	title1              numtitle1
    565. 

  565. 	title2              numtitle2
    566. 

  566. 	title3              numtitle3
    567. 

  567. 	title4              numtitle4
    568. 

  568. 	title5              numtitle5
    569. 

  569. 	title1Open          title1Close
    570. 

  570. 	title2Open          title2Close
    571. 

  571. 	title3Open          title3Close
    572. 

  572. 	title4Open          title4Close
    573. 

  573. 	title5Open          title5Close
    574. 

  574. 	blocktitle1Open     blocktitle1Close
    575. 

  575. 	blocktitle2Open     blocktitle2Close
    576. 

  576. 	blocktitle3Open     blocktitle3Close
    577. 

  577. 

  578. 	paragraphOpen       paragraphClose
    579. 

  579. 	blockVerbOpen       blockVerbClose
    580. 

  580. 	blockQuoteOpen      blockQuoteClose blockQuoteLine
    581. 

  581. 	blockCommentOpen    blockCommentClose
    582. 

  582. 

  583. 	fontMonoOpen        fontMonoClose
    584. 

  584. 	fontBoldOpen        fontBoldClose
    585. 

  585. 	fontItalicOpen      fontItalicClose
    586. 

  586. 	fontUnderlineOpen   fontUnderlineClose
    587. 

  587. 	fontStrikeOpen      fontStrikeClose
    588. 

  588. 

  589. 	listOpen            listClose
    590. 

  590. 	listOpenCompact     listCloseCompact
    591. 

  591. 	listItemOpen        listItemClose     listItemLine
    592. 

  592. 	numlistOpen         numlistClose
    593. 

  593. 	numlistOpenCompact  numlistCloseCompact
    594. 

  594. 	numlistItemOpen     numlistItemClose  numlistItemLine
    595. 

  595. 	deflistOpen         deflistClose
    596. 

  596. 	deflistOpenCompact  deflistCloseCompact
    597. 

  597. 	deflistItem1Open    deflistItem1Close
    598. 

  598. 	deflistItem2Open    deflistItem2Close deflistItem2LinePrefix
    599. 

  599. 

  600. 	bar1                bar2
    601. 

  601. 	url                 urlMark
    602. 

  602. 	email               emailMark
    603. 

  603. 	img                 imgAlignLeft  imgAlignRight  imgAlignCenter
    604. 

  604. 	                   _imgAlignLeft _imgAlignRight _imgAlignCenter
    605. 

  605. 

  606. 	tableOpen           tableClose
    607. 

  607. 	_tableBorder        _tableAlignLeft      _tableAlignCenter
    608. 

  608. 	tableRowOpen        tableRowClose        tableRowSep
    609. 

  609. 	tableTitleRowOpen   tableTitleRowClose
    610. 

  610. 	tableCellOpen       tableCellClose       tableCellSep
    611. 

  611. 	tableTitleCellOpen  tableTitleCellClose  tableTitleCellSep
    612. 

  612. 	_tableColAlignLeft  _tableColAlignRight  _tableColAlignCenter
    613. 

  613. 	_tableCellAlignLeft _tableCellAlignRight _tableCellAlignCenter
    614. 

  614. 	_tableCellColSpan   tableColAlignSep
    615. 

  615. 	_tableCellMulticolOpen
    616. 

  616. 	_tableCellMulticolClose
    617. 

  617. 

  618. 	bodyOpen            bodyClose
    619. 

  619. 	cssOpen             cssClose
    620. 

  620. 	tocOpen             tocClose             TOC
    621. 

  621. 	anchor
    622. 

  622. 	comment
    623. 

  623. 	pageBreak
    624. 

  624. 	EOD
    625. 

  625. 	""".split()
    626. 

  626. 	
    627. 

  627. 	# TIP: \a represents the current text inside the mark
    628. 

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

  629. 	
    630. 

  630. 	alltags = {
    631. 

  631. 	
    632. 

  632. 	'art': {
    633. 

  633. 		'title1'               : '\a'                     ,
    634. 

  634. 		'title2'               : '\a'                     ,
    635. 

  635. 		'title3'               : '\a'                     ,
    636. 

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

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

  638. 		'blockQuoteLine'       : '\t'                     ,
    639. 

  639. 		'listItemOpen'         : '- '                     ,
    640. 

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

  641. 		'bar1'                 : aa_line(AA['bar1'], config['width']),
    642. 

  642. 		'bar2'                 : aa_line(AA['bar2'], config['width']),
    643. 

  643. 		'url'                  : '\a'                     ,
    644. 

  644. 		'urlMark'              : '\a (\a)'                ,
    645. 

  645. 		'email'                : '\a'                     ,
    646. 

  646. 		'emailMark'            : '\a (\a)'                ,
    647. 

  647. 		'img'                  : '[\a]'                   ,
    648. 

  648. 	},
    649. 

  649. 	
    650. 

  650. 	'txt': {
    651. 

  651. 		'title1'               : '  \a'      ,
    652. 

  652. 		'title2'               : '\t\a'      ,
    653. 

  653. 		'title3'               : '\t\t\a'    ,
    654. 

  654. 		'title4'               : '\t\t\t\a'  ,
    655. 

  655. 		'title5'               : '\t\t\t\t\a',
    656. 

  656. 		'blockQuoteLine'       : '\t'        ,
    657. 

  657. 		'listItemOpen'         : '- '        ,
    658. 

  658. 		'numlistItemOpen'      : '\a. '      ,
    659. 

  659. 		'bar1'                 : '\a'        ,
    660. 

  660. 		'url'                  : '\a'        ,
    661. 

  661. 		'urlMark'              : '\a (\a)'   ,
    662. 

  662. 		'email'                : '\a'        ,
    663. 

  663. 		'emailMark'            : '\a (\a)'   ,
    664. 

  664. 		'img'                  : '[\a]'      ,
    665. 

  665. 	},
    666. 

  666. 	
    667. 

  667. 	'html': {
    668. 

  668. 		'paragraphOpen'        : '<P>'            ,
    669. 

  669. 		'paragraphClose'       : '</P>'           ,
    670. 

  670. 		'title1'               : '~A~<H1>\a</H1>' ,
    671. 

  671. 		'title2'               : '~A~<H2>\a</H2>' ,
    672. 

  672. 		'title3'               : '~A~<H3>\a</H3>' ,
    673. 

  673. 		'title4'               : '~A~<H4>\a</H4>' ,
    674. 

  674. 		'title5'               : '~A~<H5>\a</H5>' ,
    675. 

  675. 		'anchor'               : '<A NAME="\a"></A>\n',
    676. 

  676. 		'blockVerbOpen'        : '<PRE>'          ,
    677. 

  677. 		'blockVerbClose'       : '</PRE>'         ,
    678. 

  678. 		'blockQuoteOpen'       : '<BLOCKQUOTE>'   ,
    679. 

  679. 		'blockQuoteClose'      : '</BLOCKQUOTE>'  ,
    680. 

  680. 		'fontMonoOpen'         : '<CODE>'         ,
    681. 

  681. 		'fontMonoClose'        : '</CODE>'        ,
    682. 

  682. 		'fontBoldOpen'         : '<B>'            ,
    683. 

  683. 		'fontBoldClose'        : '</B>'           ,
    684. 

  684. 		'fontItalicOpen'       : '<I>'            ,
    685. 

  685. 		'fontItalicClose'      : '</I>'           ,
    686. 

  686. 		'fontUnderlineOpen'    : '<U>'            ,
    687. 

  687. 		'fontUnderlineClose'   : '</U>'           ,
    688. 

  688. 		'fontStrikeOpen'       : '<S>'            ,
    689. 

  689. 		'fontStrikeClose'      : '</S>'           ,
    690. 

  690. 		'listOpen'             : '<UL>'           ,
    691. 

  691. 		'listClose'            : '</UL>'          ,
    692. 

  692. 		'listItemOpen'         : '<LI>'           ,
    693. 

  693. 		'numlistOpen'          : '<OL>'           ,
    694. 

  694. 		'numlistClose'         : '</OL>'          ,
    695. 

  695. 		'numlistItemOpen'      : '<LI>'           ,
    696. 

  696. 		'deflistOpen'          : '<DL>'           ,
    697. 

  697. 		'deflistClose'         : '</DL>'          ,
    698. 

  698. 		'deflistItem1Open'     : '<DT>'           ,
    699. 

  699. 		'deflistItem1Close'    : '</DT>'          ,
    700. 

  700. 		'deflistItem2Open'     : '<DD>'           ,
    701. 

  701. 		'bar1'                 : '<HR NOSHADE SIZE=1>'        ,
    702. 

  702. 		'bar2'                 : '<HR NOSHADE SIZE=5>'        ,
    703. 

  703. 		'url'                  : '<A HREF="\a">\a</A>'        ,
    704. 

  704. 		'urlMark'              : '<A HREF="\a">\a</A>'        ,
    705. 

  705. 		'email'                : '<A HREF="mailto:\a">\a</A>' ,
    706. 

  706. 		'emailMark'            : '<A HREF="mailto:\a">\a</A>' ,
    707. 

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

  708. 		'_imgAlignLeft'        : ' ALIGN="left"'  ,
    709. 

  709. 		'_imgAlignCenter'      : ' ALIGN="middle"',
    710. 

  710. 		'_imgAlignRight'       : ' ALIGN="right"' ,
    711. 

  711. 		'tableOpen'            : '<TABLE~A~~B~ CELLPADDING="4">',
    712. 

  712. 		'tableClose'           : '</TABLE>'       ,
    713. 

  713. 		'tableRowOpen'         : '<TR>'           ,
    714. 

  714. 		'tableRowClose'        : '</TR>'          ,
    715. 

  715. 		'tableCellOpen'        : '<TD~A~~S~>'     ,
    716. 

  716. 		'tableCellClose'       : '</TD>'          ,
    717. 

  717. 		'tableTitleCellOpen'   : '<TH~S~>'        ,
    718. 

  718. 		'tableTitleCellClose'  : '</TH>'          ,
    719. 

  719. 		'_tableBorder'         : ' BORDER="1"'    ,
    720. 

  720. 		'_tableAlignCenter'    : ' ALIGN="center"',
    721. 

  721. 		'_tableCellAlignRight' : ' ALIGN="right"' ,
    722. 

  722. 		'_tableCellAlignCenter': ' ALIGN="center"',
    723. 

  723. 		'_tableCellColSpan'    : ' COLSPAN="\a"'  ,
    724. 

  724. 		'cssOpen'              : '<STYLE TYPE="text/css">',
    725. 

  725. 		'cssClose'             : '</STYLE>'       ,
    726. 

  726. 		'comment'              : '<!-- \a -->'    ,
    727. 

  727. 		'EOD'                  : '</BODY></HTML>'
    728. 

  728. 	},
    729. 

  729. 	
    730. 

  730. 	#TIP xhtml inherits all HTML definitions (lowercased)
    731. 

  731. 	#TIP http://www.w3.org/TR/xhtml1/#guidelines
    732. 

  732. 	#TIP http://www.htmlref.com/samples/Chapt17/17_08.htm
    733. 

  733. 	'xhtml': {
    734. 

  734. 		'listItemClose'        : '</li>'          ,
    735. 

  735. 		'numlistItemClose'     : '</li>'          ,
    736. 

  736. 		'deflistItem2Close'    : '</dd>'          ,
    737. 

  737. 		'bar1'                 : '<hr class="light" />',
    738. 

  738. 		'bar2'                 : '<hr class="heavy" />',
    739. 

  739. 		'anchor'               : '<a id="\a" name="\a"></a>\n',
    740. 

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

  741. 	},
    742. 

  742. 	
    743. 

  743. 	'sgml': {
    744. 

  744. 		'paragraphOpen'        : '<p>'                ,
    745. 

  745. 		'title1'               : '<sect>\a~A~<p>'     ,
    746. 

  746. 		'title2'               : '<sect1>\a~A~<p>'    ,
    747. 

  747. 		'title3'               : '<sect2>\a~A~<p>'    ,
    748. 

  748. 		'title4'               : '<sect3>\a~A~<p>'    ,
    749. 

  749. 		'title5'               : '<sect4>\a~A~<p>'    ,
    750. 

  750. 		'anchor'               : '<label id="\a">'    ,
    751. 

  751. 		'blockVerbOpen'        : '<tscreen><verb>'    ,
    752. 

  752. 		'blockVerbClose'       : '</verb></tscreen>'  ,
    753. 

  753. 		'blockQuoteOpen'       : '<quote>'            ,
    754. 

  754. 		'blockQuoteClose'      : '</quote>'           ,
    755. 

  755. 		'fontMonoOpen'         : '<tt>'               ,
    756. 

  756. 		'fontMonoClose'        : '</tt>'              ,
    757. 

  757. 		'fontBoldOpen'         : '<bf>'               ,
    758. 

  758. 		'fontBoldClose'        : '</bf>'              ,
    759. 

  759. 		'fontItalicOpen'       : '<em>'               ,
    760. 

  760. 		'fontItalicClose'      : '</em>'              ,
    761. 

  761. 		'fontUnderlineOpen'    : '<bf><em>'           ,
    762. 

  762. 		'fontUnderlineClose'   : '</em></bf>'         ,
    763. 

  763. 		'listOpen'             : '<itemize>'          ,
    764. 

  764. 		'listClose'            : '</itemize>'         ,
    765. 

  765. 		'listItemOpen'         : '<item>'             ,
    766. 

  766. 		'numlistOpen'          : '<enum>'             ,
    767. 

  767. 		'numlistClose'         : '</enum>'            ,
    768. 

  768. 		'numlistItemOpen'      : '<item>'             ,
    769. 

  769. 		'deflistOpen'          : '<descrip>'          ,
    770. 

  770. 		'deflistClose'         : '</descrip>'         ,
    771. 

  771. 		'deflistItem1Open'     : '<tag>'              ,
    772. 

  772. 		'deflistItem1Close'    : '</tag>'             ,
    773. 

  773. 		'bar1'                 : '<!-- \a -->'        ,
    774. 

  774. 		'url'                  : '<htmlurl url="\a" name="\a">'        ,
    775. 

  775. 		'urlMark'              : '<htmlurl url="\a" name="\a">'        ,
    776. 

  776. 		'email'                : '<htmlurl url="mailto:\a" name="\a">' ,
    777. 

  777. 		'emailMark'            : '<htmlurl url="mailto:\a" name="\a">' ,
    778. 

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

  779. 		'tableOpen'            : '<table><tabular ca="~C~">'           ,
    780. 

  780. 		'tableClose'           : '</tabular></table>' ,
    781. 

  781. 		'tableRowSep'          : '<rowsep>'           ,
    782. 

  782. 		'tableCellSep'         : '<colsep>'           ,
    783. 

  783. 		'_tableColAlignLeft'   : 'l'                  ,
    784. 

  784. 		'_tableColAlignRight'  : 'r'                  ,
    785. 

  785. 		'_tableColAlignCenter' : 'c'                  ,
    786. 

  786. 		'comment'              : '<!-- \a -->'        ,
    787. 

  787. 		'TOC'                  : '<toc>'              ,
    788. 

  788. 		'EOD'                  : '</article>'
    789. 

  789. 	},
    790. 

  790. 	
    791. 

  791. 	'dbk': {
    792. 

  792. 		'paragraphOpen'        : '<para>'                            ,
    793. 

  793. 		'paragraphClose'       : '</para>'                           ,
    794. 

  794. 		'title1Open'           : '~A~<sect1><title>\a</title>'       ,
    795. 

  795. 		'title1Close'          : '</sect1>'                          ,
    796. 

  796. 		'title2Open'           : '~A~  <sect2><title>\a</title>'     ,
    797. 

  797. 		'title2Close'          : '  </sect2>'                        ,
    798. 

  798. 		'title3Open'           : '~A~    <sect3><title>\a</title>'   ,
    799. 

  799. 		'title3Close'          : '    </sect3>'                      ,
    800. 

  800. 		'title4Open'           : '~A~      <sect4><title>\a</title>' ,
    801. 

  801. 		'title4Close'          : '      </sect4>'                    ,
    802. 

  802. 		'title5Open'           : '~A~        <sect5><title>\a</title>',
    803. 

  803. 		'title5Close'          : '        </sect5>'                  ,
    804. 

  804. 		'anchor'               : '<anchor id="\a"/>\n'               ,
    805. 

  805. 		'blockVerbOpen'        : '<programlisting>'                  ,
    806. 

  806. 		'blockVerbClose'       : '</programlisting>'                 ,
    807. 

  807. 		'blockQuoteOpen'       : '<blockquote><para>'                ,
    808. 

  808. 		'blockQuoteClose'      : '</para></blockquote>'              ,
    809. 

  809. 		'fontMonoOpen'         : '<code>'                            ,
    810. 

  810. 		'fontMonoClose'        : '</code>'                           ,
    811. 

  811. 		'fontBoldOpen'         : '<emphasis role="bold">'            ,
    812. 

  812. 		'fontBoldClose'        : '</emphasis>'                       ,
    813. 

  813. 		'fontItalicOpen'       : '<emphasis>'                        ,
    814. 

  814. 		'fontItalicClose'      : '</emphasis>'                       ,
    815. 

  815. 		'fontUnderlineOpen'    : '<emphasis role="underline">'       ,
    816. 

  816. 		'fontUnderlineClose'   : '</emphasis>'                       ,
    817. 

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

  818. 		# 'fontStrikeClose'      : '</emphasis>'                       ,
    819. 

  819. 		'listOpen'             : '<itemizedlist>'                    ,
    820. 

  820. 		'listClose'            : '</itemizedlist>'                   ,
    821. 

  821. 		'listItemOpen'         : '<listitem><para>'                  ,
    822. 

  822. 		'listItemClose'        : '</para></listitem>'                ,
    823. 

  823. 		'numlistOpen'          : '<orderedlist numeration="arabic">' ,
    824. 

  824. 		'numlistClose'         : '</orderedlist>'                    ,
    825. 

  825. 		'numlistItemOpen'      : '<listitem><para>'                  ,
    826. 

  826. 		'numlistItemClose'     : '</para></listitem>'                ,
    827. 

  827. 		'deflistOpen'          : '<variablelist>'                    ,
    828. 

  828. 		'deflistClose'         : '</variablelist>'                   ,
    829. 

  829. 		'deflistItem1Open'     : '<varlistentry><term>'              ,
    830. 

  830. 		'deflistItem1Close'    : '</term>'                           ,
    831. 

  831. 		'deflistItem2Open'     : '<listitem><para>'                  ,
    832. 

  832. 		'deflistItem2Close'    : '</para></listitem></varlistentry>' ,
    833. 

  833. 		# 'bar1'                 : '<>'                                , # Don't know
    834. 

  834. 		# 'bar2'                 : '<>'                                , # Don't know
    835. 

  835. 		'url'                  : '<ulink url="\a">\a</ulink>'        ,
    836. 

  836. 		'urlMark'              : '<ulink url="\a">\a</ulink>'        ,
    837. 

  837. 		'email'                : '<email>\a</email>'                 ,
    838. 

  838. 		'emailMark'            : '<email>\a</email>'                 ,
    839. 

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

  840. 		# '_imgAlignLeft'        : ''                                 , # Don't know
    841. 

  841. 		# '_imgAlignCenter'      : ''                                 , # Don't know
    842. 

  842. 		# '_imgAlignRight'       : ''                                 , # Don't know
    843. 

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

  844. 		# 'tableClose'           : '</tbody></tgroup></informaltable>' ,
    845. 

  845. 		# 'tableRowOpen'         : '<row>'                             ,
    846. 

  846. 		# 'tableRowClose'        : '</row>'                            ,
    847. 

  847. 		# 'tableCellOpen'        : '<entry>'                           ,
    848. 

  848. 		# 'tableCellClose'       : '</entry>'                          ,
    849. 

  849. 		# 'tableTitleRowOpen'    : '<thead>'                           ,
    850. 

  850. 		# 'tableTitleRowClose'   : '</thead>'                          ,
    851. 

  851. 		# '_tableBorder'         : ' frame="all"'                      ,
    852. 

  852. 		# '_tableAlignCenter'    : ' align="center"'                   ,
    853. 

  853. 		# '_tableCellAlignRight' : ' align="right"'                    ,
    854. 

  854. 		# '_tableCellAlignCenter': ' align="center"'                   ,
    855. 

  855. 		# '_tableCellColSpan'    : ' COLSPAN="\a"'                     ,
    856. 

  856. 		'TOC'                  : '<index/>'                          ,
    857. 

  857. 		'comment'              : '<!-- \a -->'                       ,
    858. 

  858. 		'EOD'                  : '</article>'
    859. 

  859. 	},
    860. 

  860. 	
    861. 

  861. 	'tex': {
    862. 

  862. 		'title1'               : '~A~\section*{\a}'     ,
    863. 

  863. 		'title2'               : '~A~\\subsection*{\a}'   ,
    864. 

  864. 		'title3'               : '~A~\\subsubsection*{\a}',
    865. 

  865. 		# title 4/5: DIRTY: para+BF+\\+\n
    866. 

  866. 		'title4'               : '~A~\\paragraph{}\\textbf{\a}\\\\\n',
    867. 

  867. 		'title5'               : '~A~\\paragraph{}\\textbf{\a}\\\\\n',
    868. 

  868. 		'numtitle1'            : '\n~A~\section{\a}'      ,
    869. 

  869. 		'numtitle2'            : '~A~\\subsection{\a}'    ,
    870. 

  870. 		'numtitle3'            : '~A~\\subsubsection{\a}' ,
    871. 

  871. 		'anchor'               : '\\hypertarget{\a}{}\n'  ,
    872. 

  872. 		'blockVerbOpen'        : '\\begin{verbatim}'   ,
    873. 

  873. 		'blockVerbClose'       : '\\end{verbatim}'     ,
    874. 

  874. 		'blockQuoteOpen'       : '\\begin{quotation}'  ,
    875. 

  875. 		'blockQuoteClose'      : '\\end{quotation}'    ,
    876. 

  876. 		'fontMonoOpen'         : '\\texttt{'           ,
    877. 

  877. 		'fontMonoClose'        : '}'                   ,
    878. 

  878. 		'fontBoldOpen'         : '\\textbf{'           ,
    879. 

  879. 		'fontBoldClose'        : '}'                   ,
    880. 

  880. 		'fontItalicOpen'       : '\\textit{'           ,
    881. 

  881. 		'fontItalicClose'      : '}'                   ,
    882. 

  882. 		'fontUnderlineOpen'    : '\\underline{'        ,
    883. 

  883. 		'fontUnderlineClose'   : '}'                   ,
    884. 

  884. 		'fontStrikeOpen'       : '\\sout{'             ,
    885. 

  885. 		'fontStrikeClose'      : '}'                   ,
    886. 

  886. 		'listOpen'             : '\\begin{itemize}'    ,
    887. 

  887. 		'listClose'            : '\\end{itemize}'      ,
    888. 

  888. 		'listOpenCompact'      : '\\begin{compactitem}',
    889. 

  889. 		'listCloseCompact'     : '\\end{compactitem}'  ,
    890. 

  890. 		'listItemOpen'         : '\\item '             ,
    891. 

  891. 		'numlistOpen'          : '\\begin{enumerate}'  ,
    892. 

  892. 		'numlistClose'         : '\\end{enumerate}'    ,
    893. 

  893. 		'numlistOpenCompact'   : '\\begin{compactenum}',
    894. 

  894. 		'numlistCloseCompact'  : '\\end{compactenum}'  ,
    895. 

  895. 		'numlistItemOpen'      : '\\item '             ,
    896. 

  896. 		'deflistOpen'          : '\\begin{description}',
    897. 

  897. 		'deflistClose'         : '\\end{description}'  ,
    898. 

  898. 		'deflistOpenCompact'   : '\\begin{compactdesc}',
    899. 

  899. 		'deflistCloseCompact'  : '\\end{compactdesc}'  ,
    900. 

  900. 		'deflistItem1Open'     : '\\item['             ,
    901. 

  901. 		'deflistItem1Close'    : ']'                   ,
    902. 

  902. 		'bar1'                 : '\\hrulefill{}'       ,
    903. 

  903. 		'bar2'                 : '\\rule{\linewidth}{1mm}',
    904. 

  904. 		'url'                  : '\\htmladdnormallink{\a}{\a}',
    905. 

  905. 		'urlMark'              : '\\htmladdnormallink{\a}{\a}',
    906. 

  906. 		'email'                : '\\htmladdnormallink{\a}{mailto:\a}',
    907. 

  907. 		'emailMark'            : '\\htmladdnormallink{\a}{mailto:\a}',
    908. 

  908. 		'img'                  : '\\includegraphics{\a}',
    909. 

  909. 		'tableOpen'            : '\\begin{center}\\begin{tabular}{|~C~|}',
    910. 

  910. 		'tableClose'           : '\\end{tabular}\\end{center}',
    911. 

  911. 		'tableRowOpen'         : '\\hline ' ,
    912. 

  912. 		'tableRowClose'        : ' \\\\'    ,
    913. 

  913. 		'tableCellSep'         : ' & '      ,
    914. 

  914. 		'_tableColAlignLeft'   : 'l'        ,
    915. 

  915. 		'_tableColAlignRight'  : 'r'        ,
    916. 

  916. 		'_tableColAlignCenter' : 'c'        ,
    917. 

  917. 		'_tableCellAlignLeft'  : 'l'        ,
    918. 

  918. 		'_tableCellAlignRight' : 'r'        ,
    919. 

  919. 		'_tableCellAlignCenter': 'c'        ,
    920. 

  920. 		'_tableCellColSpan'    : '\a'       ,
    921. 

  921. 		'_tableCellMulticolOpen'  : '\\multicolumn{\a}{|~C~|}{',
    922. 

  922. 		'_tableCellMulticolClose' : '}',
    923. 

  923. 		'tableColAlignSep'     : '|'        ,
    924. 

  924. 		'comment'              : '% \a'     ,
    925. 

  925. 		'TOC'                  : '\\tableofcontents',
    926. 

  926. 		'pageBreak'            : '\\clearpage',
    927. 

  927. 		'EOD'                  : '\\end{document}'
    928. 

  928. 	},
    929. 

  929. 	
    930. 

  930. 	'lout': {
    931. 

  931. 		'paragraphOpen'        : '@LP'                     ,
    932. 

  932. 		'blockTitle1Open'      : '@BeginSections'          ,
    933. 

  933. 		'blockTitle1Close'     : '@EndSections'            ,
    934. 

  934. 		'blockTitle2Open'      : ' @BeginSubSections'      ,
    935. 

  935. 		'blockTitle2Close'     : ' @EndSubSections'        ,
    936. 

  936. 		'blockTitle3Open'      : '  @BeginSubSubSections'  ,
    937. 

  937. 		'blockTitle3Close'     : '  @EndSubSubSections'    ,
    938. 

  938. 		'title1Open'           : '~A~@Section @Title { \a } @Begin',
    939. 

  939. 		'title1Close'          : '@End @Section'           ,
    940. 

  940. 		'title2Open'           : '~A~ @SubSection @Title { \a } @Begin',
    941. 

  941. 		'title2Close'          : ' @End @SubSection'       ,
    942. 

  942. 		'title3Open'           : '~A~  @SubSubSection @Title { \a } @Begin',
    943. 

  943. 		'title3Close'          : '  @End @SubSubSection'   ,
    944. 

  944. 		'title4Open'           : '~A~@LP @LeftDisplay @B { \a }',
    945. 

  945. 		'title5Open'           : '~A~@LP @LeftDisplay @B { \a }',
    946. 

  946. 		'anchor'               : '@Tag { \a }\n'       ,
    947. 

  947. 		'blockVerbOpen'        : '@LP @ID @F @RawVerbatim @Begin',
    948. 

  948. 		'blockVerbClose'       : '@End @RawVerbatim'   ,
    949. 

  949. 		'blockQuoteOpen'       : '@QD {'               ,
    950. 

  950. 		'blockQuoteClose'      : '}'                   ,
    951. 

  951. 		# enclosed inside {} to deal with joined**words**
    952. 

  952. 		'fontMonoOpen'         : '{@F {'               ,
    953. 

  953. 		'fontMonoClose'        : '}}'                  ,
    954. 

  954. 		'fontBoldOpen'         : '{@B {'               ,
    955. 

  955. 		'fontBoldClose'        : '}}'                  ,
    956. 

  956. 		'fontItalicOpen'       : '{@II {'              ,
    957. 

  957. 		'fontItalicClose'      : '}}'                  ,
    958. 

  958. 		'fontUnderlineOpen'    : '{@Underline{'        ,
    959. 

  959. 		'fontUnderlineClose'   : '}}'                  ,
    960. 

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

  961. 		'listOpen'             : '@BulletList'         ,
    962. 

  962. 		'listClose'            : '@EndList'            ,
    963. 

  963. 		'listItemOpen'         : '@ListItem{'          ,
    964. 

  964. 		'listItemClose'        : '}'                   ,
    965. 

  965. 		'numlistOpen'          : '@NumberedList'       ,
    966. 

  966. 		'numlistClose'         : '@EndList'            ,
    967. 

  967. 		'numlistItemOpen'      : '@ListItem{'          ,
    968. 

  968. 		'numlistItemClose'     : '}'                   ,
    969. 

  969. 		'deflistOpen'          : '@TaggedList'         ,
    970. 

  970. 		'deflistClose'         : '@EndList'            ,
    971. 

  971. 		'deflistItem1Open'     : '@DropTagItem {'      ,
    972. 

  972. 		'deflistItem1Close'    : '}'                   ,
    973. 

  973. 		'deflistItem2Open'     : '{'                   ,
    974. 

  974. 		'deflistItem2Close'    : '}'                   ,
    975. 

  975. 		'bar1'                 : '@DP @FullWidthRule'  ,
    976. 

  976. 		'url'                  : '{blue @Colour { \a }}'      ,
    977. 

  977. 		'urlMark'              : '\a ({blue @Colour { \a }})' ,
    978. 

  978. 		'email'                : '{blue @Colour { \a }}'      ,
    979. 

  979. 		'emailMark'            : '\a ({blue Colour{ \a }})'   ,
    980. 

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

  981. 		'_imgAlignLeft'        : '@LeftDisplay '              ,
    982. 

  982. 		'_imgAlignRight'       : '@RightDisplay '             ,
    983. 

  983. 		'_imgAlignCenter'      : '@CentredDisplay '           ,
    984. 

  984. 		# lout tables are *way* complicated, no support for now
    985. 

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

  986. 		#'tableClose'           : '}'     ,
    987. 

  987. 		#'tableRowOpen'         : '@Rowa\n'       ,
    988. 

  988. 		#'tableTitleRowOpen'    : '@HeaderRowa'       ,
    989. 

  989. 		#'tableCenterAlign'     : '@CentredDisplay '         ,
    990. 

  990. 		#'tableCellOpen'        : '\a {'                     ,	# A, B, ...
    991. 

  991. 		#'tableCellClose'       : '}'                        ,
    992. 

  992. 		#'_tableBorder'         : '\nrule {yes}'             ,
    993. 

  993. 		'comment'              : '# \a'                     ,
    994. 

  994. 		# @MakeContents must be on the config file
    995. 

  995. 		'TOC'                  : '@DP @ContentsGoesHere @DP',
    996. 

  996. 		'pageBreak'            : '@NP'                      ,
    997. 

  997. 		'EOD'                  : '@End @Text'
    998. 

  998. 	},
    999. 

  999. 	
    1000. 

  1000. 	# http://moinmo.in/SyntaxReference
    1001. 

  1001. 	'moin': {
    1002. 

  1002. 		'title1'                : '= \a ='        ,
    1003. 

  1003. 		'title2'                : '== \a =='      ,
    1004. 

  1004. 		'title3'                : '=== \a ==='    ,
    1005. 

  1005. 		'title4'                : '==== \a ===='  ,
    1006. 

  1006. 		'title5'                : '===== \a =====',
    1007. 

  1007. 		'blockVerbOpen'         : '{{{'           ,
    1008. 

  1008. 		'blockVerbClose'        : '}}}'           ,
    1009. 

  1009. 		'blockQuoteLine'        : '  '            ,
    1010. 

  1010. 		'fontMonoOpen'          : '{{{'           ,
    1011. 

  1011. 		'fontMonoClose'         : '}}}'           ,
    1012. 

  1012. 		'fontBoldOpen'          : "'''"           ,
    1013. 

  1013. 		'fontBoldClose'         : "'''"           ,
    1014. 

  1014. 		'fontItalicOpen'        : "''"            ,
    1015. 

  1015. 		'fontItalicClose'       : "''"            ,
    1016. 

  1016. 		'fontUnderlineOpen'     : '__'            ,
    1017. 

  1017. 		'fontUnderlineClose'    : '__'            ,
    1018. 

  1018. 		'fontStrikeOpen'        : '--('           ,
    1019. 

  1019. 		'fontStrikeClose'       : ')--'           ,
    1020. 

  1020. 		'listItemOpen'          : ' * '           ,
    1021. 

  1021. 		'numlistItemOpen'       : ' \a. '         ,
    1022. 

  1022. 		'deflistItem1Open'      : ' '             ,
    1023. 

  1023. 		'deflistItem1Close'     : '::'            ,
    1024. 

  1024. 		'deflistItem2LinePrefix': ' :: '          ,
    1025. 

  1025. 		'bar1'                  : '----'          ,
    1026. 

  1026. 		'bar2'                  : '--------'      ,
    1027. 

  1027. 		'url'                   : '[\a]'          ,
    1028. 

  1028. 		'urlMark'               : '[\a \a]'       ,
    1029. 

  1029. 		'email'                 : '[\a]'          ,
    1030. 

  1030. 		'emailMark'             : '[\a \a]'       ,
    1031. 

  1031. 		'img'                   : '[\a]'          ,
    1032. 

  1032. 		'tableRowOpen'          : '||'            ,
    1033. 

  1033. 		'tableCellOpen'         : '~A~'           ,
    1034. 

  1034. 		'tableCellClose'        : '||'            ,
    1035. 

  1035. 		'tableTitleCellClose'   : '||'            ,
    1036. 

  1036. 		'_tableCellAlignRight'  : '<)>'           ,
    1037. 

  1037. 		'_tableCellAlignCenter' : '<:>'           ,
    1038. 

  1038. 		'comment'               : '/* \a */'      ,
    1039. 

  1039. 		'TOC'                   : '[[TableOfContents]]'
    1040. 

  1040. 	},
    1041. 

  1041. 

  1042. 	# http://code.google.com/p/support/wiki/WikiSyntax
    1043. 

  1043. 	'gwiki': {
    1044. 

  1044. 		'title1'               : '= \a ='        ,
    1045. 

  1045. 		'title2'               : '== \a =='      ,
    1046. 

  1046. 		'title3'               : '=== \a ==='    ,
    1047. 

  1047. 		'title4'               : '==== \a ===='  ,
    1048. 

  1048. 		'title5'               : '===== \a =====',
    1049. 

  1049. 		'blockVerbOpen'        : '{{{'           ,
    1050. 

  1050. 		'blockVerbClose'       : '}}}'           ,
    1051. 

  1051. 		'blockQuoteLine'       : '  '            ,
    1052. 

  1052. 		'fontMonoOpen'         : '{{{'           ,
    1053. 

  1053. 		'fontMonoClose'        : '}}}'           ,
    1054. 

  1054. 		'fontBoldOpen'         : '*'             ,
    1055. 

  1055. 		'fontBoldClose'        : '*'             ,
    1056. 

  1056. 		'fontItalicOpen'       : '_'             , # underline == italic
    1057. 

  1057. 		'fontItalicClose'      : '_'             ,
    1058. 

  1058. 		'fontStrikeOpen'       : '~~'            ,
    1059. 

  1059. 		'fontStrikeClose'      : '~~'            ,
    1060. 

  1060. 		'listItemOpen'         : ' * '           ,
    1061. 

  1061. 		'numlistItemOpen'      : ' # '           ,
    1062. 

  1062. 		'url'                  : '\a'            ,
    1063. 

  1063. 		'urlMark'              : '[\a \a]'       ,
    1064. 

  1064. 		'email'                : 'mailto:\a'     ,
    1065. 

  1065. 		'emailMark'            : '[mailto:\a \a]',
    1066. 

  1066. 		'img'                  : '[\a]'          ,
    1067. 

  1067. 		'tableRowOpen'         : '|| '           ,
    1068. 

  1068. 		'tableRowClose'        : ' ||'           ,
    1069. 

  1069. 		'tableCellSep'         : ' || '          ,
    1070. 

  1070. 	},
    1071. 

  1071. 

  1072. 	# http://powerman.name/doc/asciidoc
    1073. 

  1073. 	'adoc': {
    1074. 

  1074. 		'title1'               : '== \a'         ,
    1075. 

  1075. 		'title2'               : '=== \a'        ,
    1076. 

  1076. 		'title3'               : '==== \a'       ,
    1077. 

  1077. 		'title4'               : '===== \a'      ,
    1078. 

  1078. 		'title5'               : '===== \a'      ,
    1079. 

  1079. 		'blockVerbOpen'        : '----'          ,
    1080. 

  1080. 		'blockVerbClose'       : '----'          ,
    1081. 

  1081. 		'fontMonoOpen'         : '+'             ,
    1082. 

  1082. 		'fontMonoClose'        : '+'             ,
    1083. 

  1083. 		'fontBoldOpen'         : '*'             ,
    1084. 

  1084. 		'fontBoldClose'        : '*'             ,
    1085. 

  1085. 		'fontItalicOpen'       : '_'             ,
    1086. 

  1086. 		'fontItalicClose'      : '_'             ,
    1087. 

  1087. 		'listItemOpen'         : '- '            ,
    1088. 

  1088. 		'listItemLine'         : '\t'            ,
    1089. 

  1089. 		'numlistItemOpen'      : '. '            ,
    1090. 

  1090. 		'url'                  : '\a'            ,
    1091. 

  1091. 		'urlMark'              : '\a[\a]'        ,
    1092. 

  1092. 		'email'                : 'mailto:\a'     ,
    1093. 

  1093. 		'emailMark'            : 'mailto:\a[\a]' ,
    1094. 

  1094. 		'img'                  : 'image::\a[]'   ,
    1095. 

  1095. 	},
    1096. 

  1096. 

  1097. 	# http://wiki.splitbrain.org/wiki:syntax
    1098. 

  1098. 	# Hint: <br> is \\ $
    1099. 

  1099. 	# Hint: You can add footnotes ((This is a footnote))
    1100. 

  1100. 	'doku': {
    1101. 

  1101. 		'title1'               : '===== \a =====',
    1102. 

  1102. 		'title2'               : '==== \a ===='  ,
    1103. 

  1103. 		'title3'               : '=== \a ==='    ,
    1104. 

  1104. 		'title4'               : '== \a =='      ,
    1105. 

  1105. 		'title5'               : '= \a ='        ,
    1106. 

  1106. 		# DokuWiki uses '  ' identation to mark verb blocks (see indentverbblock)
    1107. 

  1107. 		'blockQuoteLine'       : '>'             ,
    1108. 

  1108. 		'fontMonoOpen'         : "''"            ,
    1109. 

  1109. 		'fontMonoClose'        : "''"            ,
    1110. 

  1110. 		'fontBoldOpen'         : "**"            ,
    1111. 

  1111. 		'fontBoldClose'        : "**"            ,
    1112. 

  1112. 		'fontItalicOpen'       : "//"            ,
    1113. 

  1113. 		'fontItalicClose'      : "//"            ,
    1114. 

  1114. 		'fontUnderlineOpen'    : "__"            ,
    1115. 

  1115. 		'fontUnderlineClose'   : "__"            ,
    1116. 

  1116. 		'fontStrikeOpen'       : '<del>'         ,
    1117. 

  1117. 		'fontStrikeClose'      : '</del>'        ,
    1118. 

  1118. 		'listItemOpen'         : '  * '          ,
    1119. 

  1119. 		'numlistItemOpen'      : '  - '          ,
    1120. 

  1120. 		'bar1'                 : '----'          ,
    1121. 

  1121. 		'url'                  : '[[\a]]'        ,
    1122. 

  1122. 		'urlMark'              : '[[\a|\a]]'     ,
    1123. 

  1123. 		'email'                : '[[\a]]'        ,
    1124. 

  1124. 		'emailMark'            : '[[\a|\a]]'     ,
    1125. 

  1125. 		'img'                  : '{{\a}}'        ,
    1126. 

  1126. 		'imgAlignLeft'         : '{{\a }}'       ,
    1127. 

  1127. 		'imgAlignRight'        : '{{ \a}}'       ,
    1128. 

  1128. 		'imgAlignCenter'       : '{{ \a }}'      ,
    1129. 

  1129. 		'tableTitleRowOpen'    : '^ '            ,
    1130. 

  1130. 		'tableTitleRowClose'   : ' ^'            ,
    1131. 

  1131. 		'tableTitleCellSep'    : ' ^ '           ,
    1132. 

  1132. 		'tableRowOpen'         : '| '            ,
    1133. 

  1133. 		'tableRowClose'        : ' |'            ,
    1134. 

  1134. 		'tableCellSep'         : ' | '           ,
    1135. 

  1135. 		# DokuWiki has no attributes. The content must be aligned!
    1136. 

  1136. 		# '_tableCellAlignRight' : '<)>'           , # ??
    1137. 

  1137. 		# '_tableCellAlignCenter': '<:>'           , # ??
    1138. 

  1138. 		# DokuWiki colspan is the same as txt2tags' with multiple |||
    1139. 

  1139. 		# 'comment'             : '## \a'         , # ??
    1140. 

  1140. 		# TOC is automatic
    1141. 

  1141. 	},
    1142. 

  1142. 	
    1143. 

  1143. 	# http://www.pmwiki.org/wiki/PmWiki/TextFormattingRules
    1144. 

  1144. 	'pmw': {
    1145. 

  1145. 		'title1'               : '~A~! \a '      ,
    1146. 

  1146. 		'title2'               : '~A~!! \a '     ,
    1147. 

  1147. 		'title3'               : '~A~!!! \a '    ,
    1148. 

  1148. 		'title4'               : '~A~!!!! \a '   ,
    1149. 

  1149. 		'title5'               : '~A~!!!!! \a '  ,
    1150. 

  1150. 		'blockQuoteOpen'       : '->'            ,
    1151. 

  1151. 		'blockQuoteClose'      : '\n'            ,
    1152. 

  1152. 		# In-text font
    1153. 

  1153. 		'fontLargeOpen'        : "[+"            ,
    1154. 

  1154. 		'fontLargeClose'       : "+]"            ,
    1155. 

  1155. 		'fontLargerOpen'       : "[++"           ,
    1156. 

  1156. 		'fontLargerClose'      : "++]"           ,
    1157. 

  1157. 		'fontSmallOpen'        : "[-"            ,
    1158. 

  1158. 		'fontSmallClose'       : "-]"            ,
    1159. 

  1159. 		'fontLargerOpen'       : "[--"           ,
    1160. 

  1160. 		'fontLargerClose'      : "--]"           ,
    1161. 

  1161. 		'fontMonoOpen'         : "@@"            ,
    1162. 

  1162. 		'fontMonoClose'        : "@@"            ,
    1163. 

  1163. 		'fontBoldOpen'         : "'''"           ,
    1164. 

  1164. 		'fontBoldClose'        : "'''"           ,
    1165. 

  1165. 		'fontItalicOpen'       : "''"            ,
    1166. 

  1166. 		'fontItalicClose'      : "''"            ,
    1167. 

  1167. 		'fontUnderlineOpen'    : "{+"            ,
    1168. 

  1168. 		'fontUnderlineClose'   : "+}"            ,
    1169. 

  1169. 		'fontStrikeOpen'       : '{-'            ,
    1170. 

  1170. 		'fontStrikeClose'      : '-}'            ,
    1171. 

  1171. 		# Lists
    1172. 

  1172. 		'listItemLine'          : '*'            ,
    1173. 

  1173. 		'numlistItemLine'       : '#'            ,
    1174. 

  1174. 		'deflistItem1Open'      : ': '           ,
    1175. 

  1175. 		'deflistItem1Close'     : ':'            ,
    1176. 

  1176. 		'deflistItem2LineOpen'  : '::'           ,
    1177. 

  1177. 		'deflistItem2LineClose' : ':'            ,
    1178. 

  1178. 		# Verbatim block
    1179. 

  1179. 		'blockVerbOpen'        : '[@'            ,
    1180. 

  1180. 		'blockVerbClose'       : '@]'            ,
    1181. 

  1181. 		'bar1'                 : '----'          ,
    1182. 

  1182. 		# URL, email and anchor
    1183. 

  1183. 		'url'                   : '\a'           ,
    1184. 

  1184. 		'urlMark'               : '[[\a -> \a]]' ,
    1185. 

  1185. 		'email'                 : '\a'           ,
    1186. 

  1186. 		'emailMark'             : '[[\a -> mailto:\a]]',
    1187. 

  1187. 		'anchor'                : '[[#\a]]\n'    ,
    1188. 

  1188. 		# Image markup
    1189. 

  1189. 		'img'                   : '\a'           ,
    1190. 

  1190. 		#'imgAlignLeft'         : '{{\a }}'       ,
    1191. 

  1191. 		#'imgAlignRight'        : '{{ \a}}'       ,
    1192. 

  1192. 		#'imgAlignCenter'       : '{{ \a }}'      ,
    1193. 

  1193. 		# Table attributes
    1194. 

  1194. 		'tableTitleRowOpen'    : '||! '          ,
    1195. 

  1195. 		'tableTitleRowClose'   : '||'            ,
    1196. 

  1196. 		'tableTitleCellSep'    : ' ||!'          ,
    1197. 

  1197. 		'tableRowOpen'         : '||'            ,
    1198. 

  1198. 		'tableRowClose'        : '||'            ,
    1199. 

  1199. 		'tableCellSep'         : ' ||'           ,
    1200. 

  1200. 	},
    1201. 

  1201. 	
    1202. 

  1202. 	# http://en.wikipedia.org/wiki/Help:Editing
    1203. 

  1203. 	'wiki': {
    1204. 

  1204. 		'title1'                : '== \a =='        ,
    1205. 

  1205. 		'title2'                : '=== \a ==='      ,
    1206. 

  1206. 		'title3'                : '==== \a ===='    ,
    1207. 

  1207. 		'title4'                : '===== \a ====='  ,
    1208. 

  1208. 		'title5'                : '====== \a ======',
    1209. 

  1209. 		'blockVerbOpen'         : '<pre>'           ,
    1210. 

  1210. 		'blockVerbClose'        : '</pre>'          ,
    1211. 

  1211. 		'blockQuoteOpen'        : '<blockquote>'    ,
    1212. 

  1212. 		'blockQuoteClose'       : '</blockquote>'   ,
    1213. 

  1213. 		'fontMonoOpen'          : '<tt>'            ,
    1214. 

  1214. 		'fontMonoClose'         : '</tt>'           ,
    1215. 

  1215. 		'fontBoldOpen'          : "'''"             ,
    1216. 

  1216. 		'fontBoldClose'         : "'''"             ,
    1217. 

  1217. 		'fontItalicOpen'        : "''"              ,
    1218. 

  1218. 		'fontItalicClose'       : "''"              ,
    1219. 

  1219. 		'fontUnderlineOpen'     : '<u>'             ,
    1220. 

  1220. 		'fontUnderlineClose'    : '</u>'            ,
    1221. 

  1221. 		'fontStrikeOpen'        : '<s>'             ,
    1222. 

  1222. 		'fontStrikeClose'       : '</s>'            ,
    1223. 

  1223. 		#XXX Mixed lists not working: *#* list inside numlist inside list
    1224. 

  1224. 		'listItemLine'          : '*'               ,
    1225. 

  1225. 		'numlistItemLine'       : '#'               ,
    1226. 

  1226. 		'deflistItem1Open'      : '; '              ,
    1227. 

  1227. 		'deflistItem2LinePrefix': ': '            ,
    1228. 

  1228. 		'bar1'                  : '----'            ,
    1229. 

  1229. 		'url'                   : '[\a]'            ,
    1230. 

  1230. 		'urlMark'               : '[\a \a]'         ,
    1231. 

  1231. 		'email'                 : 'mailto:\a'       ,
    1232. 

  1232. 		'emailMark'             : '[mailto:\a \a]'  ,
    1233. 

  1233. 		# [[Image:foo.png|right|Optional alt/caption text]] (right, left, center, none)
    1234. 

  1234. 		'img'                   : '[[Image:\a~A~]]' ,
    1235. 

  1235. 		'_imgAlignLeft'         : '|left'           ,
    1236. 

  1236. 		'_imgAlignCenter'       : '|center'         ,
    1237. 

  1237. 		'_imgAlignRight'        : '|right'          ,
    1238. 

  1238. 		# {| border="1" cellspacing="0" cellpadding="4" align="center"
    1239. 

  1239. 		'tableOpen'             : '{|~A~~B~ cellpadding="4"',
    1240. 

  1240. 		'tableClose'            : '|}'              ,
    1241. 

  1241. 		'tableRowOpen'          : '|-\n| '          ,
    1242. 

  1242. 		'tableTitleRowOpen'     : '|-\n! '          ,
    1243. 

  1243. 		'tableCellSep'          : ' || '            ,
    1244. 

  1244. 		'tableTitleCellSep'     : ' !! '            ,
    1245. 

  1245. 		'_tableBorder'          : ' border="1"'     ,
    1246. 

  1246. 		'_tableAlignCenter'     : ' align="center"' ,
    1247. 

  1247. 		'comment'               : '<!-- \a -->'     ,
    1248. 

  1248. 		'TOC'                   : '__TOC__'         ,
    1249. 

  1249. 	},
    1250. 

  1250. 	
    1251. 

  1251. 	# http://www.inference.phy.cam.ac.uk/mackay/mgp/SYNTAX
    1252. 

  1252. 	# http://en.wikipedia.org/wiki/MagicPoint
    1253. 

  1253. 	'mgp': {
    1254. 

  1254. 		'paragraphOpen'         : '%font "normal", size 5'     ,
    1255. 

  1255. 		'title1'                : '%page\n\n\a\n'              ,
    1256. 

  1256. 		'title2'                : '%page\n\n\a\n'              ,
    1257. 

  1257. 		'title3'                : '%page\n\n\a\n'              ,
    1258. 

  1258. 		'title4'                : '%page\n\n\a\n'              ,
    1259. 

  1259. 		'title5'                : '%page\n\n\a\n'              ,
    1260. 

  1260. 		'blockVerbOpen'         : '%font "mono"'               ,
    1261. 

  1261. 		'blockVerbClose'        : '%font "normal"'             ,
    1262. 

  1262. 		'blockQuoteOpen'        : '%prefix "       "'          ,
    1263. 

  1263. 		'blockQuoteClose'       : '%prefix "  "'               ,
    1264. 

  1264. 		'fontMonoOpen'          : '\n%cont, font "mono"\n'     ,
    1265. 

  1265. 		'fontMonoClose'         : '\n%cont, font "normal"\n'   ,
    1266. 

  1266. 		'fontBoldOpen'          : '\n%cont, font "normal-b"\n' ,
    1267. 

  1267. 		'fontBoldClose'         : '\n%cont, font "normal"\n'   ,
    1268. 

  1268. 		'fontItalicOpen'        : '\n%cont, font "normal-i"\n' ,
    1269. 

  1269. 		'fontItalicClose'       : '\n%cont, font "normal"\n'   ,
    1270. 

  1270. 		'fontUnderlineOpen'     : '\n%cont, fore "cyan"\n'     ,
    1271. 

  1271. 		'fontUnderlineClose'    : '\n%cont, fore "white"\n'    ,
    1272. 

  1272. 		'listItemLine'          : '\t'                         ,
    1273. 

  1273. 		'numlistItemLine'       : '\t'                         ,
    1274. 

  1274. 		'numlistItemOpen'       : '\a. '                       ,
    1275. 

  1275. 		'deflistItem1Open'      : '\t\n%cont, font "normal-b"\n',
    1276. 

  1276. 		'deflistItem1Close'     : '\n%cont, font "normal"\n'   ,
    1277. 

  1277. 		'bar1'                  : '%bar "white" 5'             ,
    1278. 

  1278. 		'bar2'                  : '%pause'                     ,
    1279. 

  1279. 		'url'                   : '\n%cont, fore "cyan"\n\a'   +\
    1280. 

  1280. 		                          '\n%cont, fore "white"\n'    ,
    1281. 

  1281. 		'urlMark'               : '\a \n%cont, fore "cyan"\n\a'+\
    1282. 

  1282. 		                          '\n%cont, fore "white"\n'    ,
    1283. 

  1283. 		'email'                 : '\n%cont, fore "cyan"\n\a'   +\
    1284. 

  1284. 		                          '\n%cont, fore "white"\n'    ,
    1285. 

  1285. 		'emailMark'             : '\a \n%cont, fore "cyan"\n\a'+\
    1286. 

  1286. 		                          '\n%cont, fore "white"\n'    ,
    1287. 

  1287. 		'img'                   : '~A~\n%newimage "\a"\n%left\n',
    1288. 

  1288. 		'_imgAlignLeft'         : '\n%left'                    ,
    1289. 

  1289. 		'_imgAlignRight'        : '\n%right'                   ,
    1290. 

  1290. 		'_imgAlignCenter'       : '\n%center'                  ,
    1291. 

  1291. 		'comment'               : '%% \a'                      ,
    1292. 

  1292. 		'pageBreak'             : '%page\n\n\n'                ,
    1293. 

  1293. 		'EOD'                   : '%%EOD'
    1294. 

  1294. 	},
    1295. 

  1295. 	
    1296. 

  1296. 	# man groff_man ; man 7 groff
    1297. 

  1297. 	'man': {
    1298. 

  1298. 		'paragraphOpen'         : '.P'     ,
    1299. 

  1299. 		'title1'                : '.SH \a' ,
    1300. 

  1300. 		'title2'                : '.SS \a' ,
    1301. 

  1301. 		'title3'                : '.SS \a' ,
    1302. 

  1302. 		'title4'                : '.SS \a' ,
    1303. 

  1303. 		'title5'                : '.SS \a' ,
    1304. 

  1304. 		'blockVerbOpen'         : '.nf'    ,
    1305. 

  1305. 		'blockVerbClose'        : '.fi\n'  ,
    1306. 

  1306. 		'blockQuoteOpen'        : '.RS'    ,
    1307. 

  1307. 		'blockQuoteClose'       : '.RE'    ,
    1308. 

  1308. 		'fontBoldOpen'          : '\\fB'   ,
    1309. 

  1309. 		'fontBoldClose'         : '\\fR'   ,
    1310. 

  1310. 		'fontItalicOpen'        : '\\fI'   ,
    1311. 

  1311. 		'fontItalicClose'       : '\\fR'   ,
    1312. 

  1312. 		'listOpen'              : '.RS'    ,
    1313. 

  1313. 		'listItemOpen'          : '.IP \(bu 3\n',
    1314. 

  1314. 		'listClose'             : '.RE'    ,
    1315. 

  1315. 		'numlistOpen'           : '.RS'    ,
    1316. 

  1316. 		'numlistItemOpen'       : '.IP \a. 3\n',
    1317. 

  1317. 		'numlistClose'          : '.RE'    ,
    1318. 

  1318. 		'deflistItem1Open'      : '.TP\n'  ,
    1319. 

  1319. 		'bar1'                  : '\n\n'   ,
    1320. 

  1320. 		'url'                   : '\a'     ,
    1321. 

  1321. 		'urlMark'               : '\a (\a)',
    1322. 

  1322. 		'email'                 : '\a'     ,
    1323. 

  1323. 		'emailMark'             : '\a (\a)',
    1324. 

  1324. 		'img'                   : '\a'     ,
    1325. 

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

  1326. 		'tableClose'            : '.TE'     ,
    1327. 

  1327. 		'tableRowOpen'          : ' '       ,
    1328. 

  1328. 		'tableCellSep'          : '^'       ,
    1329. 

  1329. 		'_tableAlignCenter'     : 'center, ',
    1330. 

  1330. 		'_tableBorder'          : 'allbox, ',
    1331. 

  1331. 		'_tableColAlignLeft'    : 'l'       ,
    1332. 

  1332. 		'_tableColAlignRight'   : 'r'       ,
    1333. 

  1333. 		'_tableColAlignCenter'  : 'c'       ,
    1334. 

  1334. 		'comment'               : '.\\" \a'
    1335. 

  1335. 	},
    1336. 

  1336. 	
    1337. 

  1337. 	'pm6': {
    1338. 

  1338. 		'paragraphOpen'         : '<@Normal:>'    ,
    1339. 

  1339. 		'title1'                : '<@Title1:>\a',
    1340. 

  1340. 		'title2'                : '<@Title2:>\a',
    1341. 

  1341. 		'title3'                : '<@Title3:>\a',
    1342. 

  1342. 		'title4'                : '<@Title4:>\a',
    1343. 

  1343. 		'title5'                : '<@Title5:>\a',
    1344. 

  1344. 		'blockVerbOpen'         : '<@PreFormat:>' ,
    1345. 

  1345. 		'blockQuoteLine'        : '<@Quote:>'     ,
    1346. 

  1346. 		'fontMonoOpen'          : '<FONT "Lucida Console"><SIZE 9>' ,
    1347. 

  1347. 		'fontMonoClose'         : '<SIZE$><FONT$>',
    1348. 

  1348. 		'fontBoldOpen'          : '<B>'           ,
    1349. 

  1349. 		'fontBoldClose'         : '<P>'           ,
    1350. 

  1350. 		'fontItalicOpen'        : '<I>'           ,
    1351. 

  1351. 		'fontItalicClose'       : '<P>'           ,
    1352. 

  1352. 		'fontUnderlineOpen'     : '<U>'           ,
    1353. 

  1353. 		'fontUnderlineClose'    : '<P>'           ,
    1354. 

  1354. 		'listOpen'              : '<@Bullet:>'    ,
    1355. 

  1355. 		'listItemOpen'          : '\x95\t'        ,  # \x95 == ~U
    1356. 

  1356. 		'numlistOpen'           : '<@Bullet:>'    ,
    1357. 

  1357. 		'numlistItemOpen'       : '\x95\t'        ,
    1358. 

  1358. 		'bar1'                  : '\a'            ,
    1359. 

  1359. 		'url'                   : '<U>\a<P>'      ,  # underline
    1360. 

  1360. 		'urlMark'               : '\a <U>\a<P>'   ,
    1361. 

  1361. 		'email'                 : '\a'            ,
    1362. 

  1362. 		'emailMark'             : '\a \a'         ,
    1363. 

  1363. 		'img'                   : '\a'
    1364. 

  1364. 	},
    1365. 

  1365. 	# http://www.wikicreole.org/wiki/AllMarkup
    1366. 

  1366. 	'creole': {
    1367. 

  1367. 		'title1'               : '= \a ='        ,
    1368. 

  1368. 		'title2'               : '== \a =='      ,
    1369. 

  1369. 		'title3'               : '=== \a ==='    ,
    1370. 

  1370. 		'title4'               : '==== \a ===='  ,
    1371. 

  1371. 		'title5'               : '===== \a =====',
    1372. 

  1372. 		'blockVerbOpen'        : '{{{'           ,
    1373. 

  1373. 		'blockVerbClose'       : '}}}'           ,
    1374. 

  1374. 		'blockQuoteLine'       : '  '            ,
    1375. 

  1375. 	#	'fontMonoOpen'         : '##'            ,  # planned for 2.0,
    1376. 

  1376. 	#	'fontMonoClose'        : '##'            ,  # meanwhile we disable it
    1377. 

  1377. 		'fontBoldOpen'         : '**'            ,
    1378. 

  1378. 		'fontBoldClose'        : '**'            ,
    1379. 

  1379. 		'fontItalicOpen'       : '//'            ,
    1380. 

  1380. 		'fontItalicClose'      : '//'            ,
    1381. 

  1381. 		'fontUnderlineOpen'    : '//'            ,  # no underline in 1.0, planned for 2.0,
    1382. 

  1382. 		'fontUnderlineClose'   : '//'            ,  # meanwhile we can use italic (emphasized)
    1383. 

  1383. 	#	'fontStrikeOpen'       : '--'            ,  # planned for 2.0,
    1384. 

  1384. 	#	'fontStrikeClose'      : '--'            ,  # meanwhile we disable it
    1385. 

  1385. 		'listItemLine'          : '*'            ,
    1386. 

  1386. 		'numlistItemLine'       : '#'            ,
    1387. 

  1387. 		'deflistItem2LinePrefix': ':'            ,
    1388. 

  1388. 		'bar1'                  : '----'         ,
    1389. 

  1389. 		'url'                  : '[[\a]]'        ,
    1390. 

  1390. 		'urlMark'              : '[[\a|\a]]'     ,
    1391. 

  1391. 		'img'                  : '{{\a}}'        ,
    1392. 

  1392. 		'tableTitleRowOpen'    : '|= '           ,
    1393. 

  1393. 		'tableTitleRowClose'   : '|'             ,
    1394. 

  1394. 		'tableTitleCellSep'    : ' |= '          ,
    1395. 

  1395. 		'tableRowOpen'         : '| '            ,
    1396. 

  1396. 		'tableRowClose'        : ' |'            ,
    1397. 

  1397. 		'tableCellSep'         : ' | '           ,
    1398. 

  1398. 		# TODO: placeholder (mark for unknown syntax)
    1399. 

  1399. 		# if possible: http://www.wikicreole.org/wiki/Placeholder
    1400. 

  1400. 	}
    1401. 

  1401. 	}
    1402. 

  1402. 	
    1403. 

  1403. 	# Exceptions for --css-sugar
    1404. 

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

  1405. 		# Change just HTML because XHTML inherits it
    1406. 

  1406. 		htmltags = alltags['html']
    1407. 

  1407. 		# Table with no cellpadding
    1408. 

  1408. 		htmltags['tableOpen'] = htmltags['tableOpen'].replace(' CELLPADDING="4"', '')
    1409. 

  1409. 		# DIVs
    1410. 

  1410. 		htmltags['tocOpen' ] = '<DIV CLASS="toc">'
    1411. 

  1411. 		htmltags['tocClose'] = '</DIV>'
    1412. 

  1412. 		htmltags['bodyOpen'] = '<DIV CLASS="body" ID="body">'
    1413. 

  1413. 		htmltags['bodyClose']= '</DIV>'
    1414. 

  1414. 	
    1415. 

  1415. 	# Make the HTML -> XHTML inheritance
    1416. 

  1416. 	xhtml = alltags['html'].copy()
    1417. 

  1417. 	for key in xhtml.keys(): xhtml[key] = xhtml[key].lower()
    1418. 

  1418. 	# Some like HTML tags as lowercase, some don't... (headers out)
    1419. 

  1419. 	if HTML_LOWER: alltags['html'] = xhtml.copy()
    1420. 

  1420. 	xhtml.update(alltags['xhtml'])
    1421. 

  1421. 	alltags['xhtml'] = xhtml.copy()
    1422. 

  1422. 

  1423. 	# Compose the target tags dictionary
    1424. 

  1424. 	tags = {}
    1425. 

  1425. 	target_tags = alltags[config['target']].copy()
    1426. 

  1426. 	
    1427. 

  1427. 	for key in keys: tags[key] = '' # create empty keys
    1428. 

  1428. 	for key in target_tags.keys():
    1429. 

  1429. 		tags[key] = maskEscapeChar(target_tags[key]) # populate
    1430. 

  1430. 

  1431. 	# Map strong line to pagebreak
    1432. 

  1432. 	if rules['mapbar2pagebreak'] and tags['pageBreak']:
    1433. 

  1433. 		tags['bar2'] = tags['pageBreak']
    1434. 

  1434. 

  1435. 	# Map strong line to separator if not defined
    1436. 

  1436. 	if not tags['bar2'] and tags['bar1']:
    1437. 

  1437. 		tags['bar2'] = tags['bar1']
    1438. 

  1438. 

  1439. 	return tags
    1440. 

  1440. 

  1441. 

  1442. ##############################################################################
    1443. 

  1443. 

  1444. 

  1445. def getRules(config):
    1446. 

  1446. 	"Returns all the target-specific syntax rules"
    1447. 

  1447. 	
    1448. 

  1448. 	ret = {}
    1449. 

  1449. 	allrules = [
    1450. 

  1450. 	
    1451. 

  1451. 		# target rules (ON/OFF)
    1452. 

  1452. 		'linkable',             # target supports external links
    1453. 

  1453. 		'tableable',            # target supports tables
    1454. 

  1454. 		'imglinkable',          # target supports images as links
    1455. 

  1455. 		'imgalignable',         # target supports image alignment
    1456. 

  1456. 		'imgasdefterm',         # target supports image as definition term
    1457. 

  1457. 		'autonumberlist',       # target supports numbered lists natively
    1458. 

  1458. 		'autonumbertitle',      # target supports numbered titles natively
    1459. 

  1459. 		'stylable',             # target supports external style files
    1460. 

  1460. 		'parainsidelist',       # lists items supports paragraph
    1461. 

  1461. 		'compactlist',          # separate enclosing tags for compact lists
    1462. 

  1462. 		'spacedlistitem',       # lists support blank lines between items
    1463. 

  1463. 		'listnotnested',        # lists cannot be nested
    1464. 

  1464. 		'quotenotnested',       # quotes cannot be nested
    1465. 

  1465. 		'verbblocknotescaped',  # don't escape specials in verb block
    1466. 

  1466. 		'verbblockfinalescape', # do final escapes in verb block
    1467. 

  1467. 		'escapeurl',            # escape special in link URL
    1468. 

  1468. 		'labelbeforelink',      # label comes before the link on the tag
    1469. 

  1469. 		'onelinepara',          # dump paragraph as a single long line
    1470. 

  1470. 		'tabletitlerowinbold',  # manually bold any cell on table titles
    1471. 

  1471. 		'tablecellstrip',       # strip extra spaces from each table cell
    1472. 

  1472. 		'tablecellspannable',   # the table cells can have span attribute
    1473. 

  1473. 		'tablecellmulticol',    # separate open+close tags for multicol cells
    1474. 

  1474. 		'barinsidequote',       # bars are allowed inside quote blocks
    1475. 

  1475. 		'finalescapetitle',     # perform final escapes on title lines
    1476. 

  1476. 		'autotocnewpagebefore', # break page before automatic TOC
    1477. 

  1477. 		'autotocnewpageafter',  # break page after automatic TOC
    1478. 

  1478. 		'autotocwithbars',      # automatic TOC surrounded by bars
    1479. 

  1479. 		'mapbar2pagebreak',     # map the strong bar to a page break
    1480. 

  1480. 		'titleblocks',          # titles must be on open/close section blocks
    1481. 

  1481. 	
    1482. 

  1482. 		# Target code beautify (ON/OFF)
    1483. 

  1483. 		'indentverbblock',      # add leading spaces to verb block lines
    1484. 

  1484. 		'breaktablecell',       # break lines after any table cell
    1485. 

  1485. 		'breaktablelineopen',   # break line after opening table line
    1486. 

  1486. 		'notbreaklistopen',     # don't break line after opening a new list
    1487. 

  1487. 		'keepquoteindent',      # don't remove the leading TABs on quotes
    1488. 

  1488. 		'keeplistindent',       # don't remove the leading spaces on lists
    1489. 

  1489. 		'blankendautotoc',      # append a blank line at the auto TOC end
    1490. 

  1490. 		'tagnotindentable',     # tags must be placed at the line beginning
    1491. 

  1491. 		'spacedlistitemopen',   # append a space after the list item open tag
    1492. 

  1492. 		'spacednumlistitemopen',# append a space after the numlist item open tag
    1493. 

  1493. 		'deflisttextstrip',     # strip the contents of the deflist text
    1494. 

  1494. 		'blanksaroundpara',     # put a blank line before and after paragraphs
    1495. 

  1495. 		'blanksaroundverb',     # put a blank line before and after verb blocks
    1496. 

  1496. 		'blanksaroundquote',    # put a blank line before and after quotes
    1497. 

  1497. 		'blanksaroundlist',     # put a blank line before and after lists
    1498. 

  1498. 		'blanksaroundnumlist',  # put a blank line before and after numlists
    1499. 

  1499. 		'blanksarounddeflist',  # put a blank line before and after deflists
    1500. 

  1500. 		'blanksaroundtable',    # put a blank line before and after tables
    1501. 

  1501. 		'blanksaroundbar',      # put a blank line before and after bars
    1502. 

  1502. 		'blanksaroundtitle',    # put a blank line before and after titles
    1503. 

  1503. 		'blanksaroundnumtitle', # put a blank line before and after numtitles
    1504. 

  1504. 	
    1505. 

  1505. 		# Value settings
    1506. 

  1506. 		'listmaxdepth',         # maximum depth for lists
    1507. 

  1507. 		'quotemaxdepth',        # maximum depth for quotes
    1508. 

  1508. 		'tablecellaligntype',   # type of table cell align: cell, column
    1509. 

  1509. 	]
    1510. 

  1510. 	
    1511. 

  1511. 	rules_bank = {
    1512. 

  1512. 		'txt': {
    1513. 

  1513. 			'indentverbblock':1,
    1514. 

  1514. 			'spacedlistitem':1,
    1515. 

  1515. 			'parainsidelist':1,
    1516. 

  1516. 			'keeplistindent':1,
    1517. 

  1517. 			'barinsidequote':1,
    1518. 

  1518. 			'autotocwithbars':1,
    1519. 

  1519. 

  1520. 			'blanksaroundpara':1,
    1521. 

  1521. 			'blanksaroundverb':1,
    1522. 

  1522. 			'blanksaroundquote':1,
    1523. 

  1523. 			'blanksaroundlist':1,
    1524. 

  1524. 			'blanksaroundnumlist':1,
    1525. 

  1525. 			'blanksarounddeflist':1,
    1526. 

  1526. 			'blanksaroundtable':1,
    1527. 

  1527. 			'blanksaroundbar':1,
    1528. 

  1528. 			'blanksaroundtitle':1,
    1529. 

  1529. 			'blanksaroundnumtitle':1,
    1530. 

  1530. 		},
    1531. 

  1531. 		'art': {
    1532. 

  1532. 			#TIP art inherits all TXT rules
    1533. 

  1533. 		},
    1534. 

  1534. 		'html': {
    1535. 

  1535. 			'indentverbblock':1,
    1536. 

  1536. 			'linkable':1,
    1537. 

  1537. 			'stylable':1,
    1538. 

  1538. 			'escapeurl':1,
    1539. 

  1539. 			'imglinkable':1,
    1540. 

  1540. 			'imgalignable':1,
    1541. 

  1541. 			'imgasdefterm':1,
    1542. 

  1542. 			'autonumberlist':1,
    1543. 

  1543. 			'spacedlistitem':1,
    1544. 

  1544. 			'parainsidelist':1,
    1545. 

  1545. 			'tableable':1,
    1546. 

  1546. 			'tablecellstrip':1,
    1547. 

  1547. 			'breaktablecell':1,
    1548. 

  1548. 			'breaktablelineopen':1,
    1549. 

  1549. 			'keeplistindent':1,
    1550. 

  1550. 			'keepquoteindent':1,
    1551. 

  1551. 			'barinsidequote':1,
    1552. 

  1552. 			'autotocwithbars':1,
    1553. 

  1553. 			'tablecellspannable':1,
    1554. 

  1554. 			'tablecellaligntype':'cell',
    1555. 

  1555. 

  1556. 			# 'blanksaroundpara':1,
    1557. 

  1557. 			'blanksaroundverb':1,
    1558. 

  1558. 			# 'blanksaroundquote':1,
    1559. 

  1559. 			'blanksaroundlist':1,
    1560. 

  1560. 			'blanksaroundnumlist':1,
    1561. 

  1561. 			'blanksarounddeflist':1,
    1562. 

  1562. 			'blanksaroundtable':1,
    1563. 

  1563. 			'blanksaroundbar':1,
    1564. 

  1564. 			'blanksaroundtitle':1,
    1565. 

  1565. 			'blanksaroundnumtitle':1,
    1566. 

  1566. 		},
    1567. 

  1567. 		'xhtml': {
    1568. 

  1568. 			#TIP xhtml inherits all HTML rules
    1569. 

  1569. 		},
    1570. 

  1570. 		'sgml': {
    1571. 

  1571. 			'linkable':1,
    1572. 

  1572. 			'escapeurl':1,
    1573. 

  1573. 			'autonumberlist':1,
    1574. 

  1574. 			'spacedlistitem':1,
    1575. 

  1575. 			'tableable':1,
    1576. 

  1576. 			'tablecellstrip':1,
    1577. 

  1577. 			'blankendautotoc':1,
    1578. 

  1578. 			'quotenotnested':1,
    1579. 

  1579. 			'keeplistindent':1,
    1580. 

  1580. 			'keepquoteindent':1,
    1581. 

  1581. 			'barinsidequote':1,
    1582. 

  1582. 			'finalescapetitle':1,
    1583. 

  1583. 			'tablecellaligntype':'column',
    1584. 

  1584. 

  1585. 			'blanksaroundpara':1,
    1586. 

  1586. 			'blanksaroundverb':1,
    1587. 

  1587. 			'blanksaroundquote':1,
    1588. 

  1588. 			'blanksaroundlist':1,
    1589. 

  1589. 			'blanksaroundnumlist':1,
    1590. 

  1590. 			'blanksarounddeflist':1,
    1591. 

  1591. 			'blanksaroundtable':1,
    1592. 

  1592. 			'blanksaroundbar':1,
    1593. 

  1593. 			'blanksaroundtitle':1,
    1594. 

  1594. 			'blanksaroundnumtitle':1,
    1595. 

  1595. 		},
    1596. 

  1596. 		'dbk': {
    1597. 

  1597. 			'linkable':1,
    1598. 

  1598. 			'tableable':0, # activate when table tags are ready
    1599. 

  1599. 			'imglinkable':1,
    1600. 

  1600. 			'imgalignable':1,
    1601. 

  1601. 			'imgasdefterm':1,
    1602. 

  1602. 			'autonumberlist':1,
    1603. 

  1603. 			'autonumbertitle':1,
    1604. 

  1604. 			'parainsidelist':1,
    1605. 

  1605. 			'spacedlistitem':1,
    1606. 

  1606. 			'titleblocks':1,
    1607. 

  1607. 		},
    1608. 

  1608. 		'mgp': {
    1609. 

  1609. 			'tagnotindentable':1,
    1610. 

  1610. 			'spacedlistitem':1,
    1611. 

  1611. 			'imgalignable':1,
    1612. 

  1612. 			'autotocnewpagebefore':1,
    1613. 

  1613. 

  1614. 			'blanksaroundpara':1,
    1615. 

  1615. 			'blanksaroundverb':1,
    1616. 

  1616. 			# 'blanksaroundquote':1,
    1617. 

  1617. 			'blanksaroundlist':1,
    1618. 

  1618. 			'blanksaroundnumlist':1,
    1619. 

  1619. 			'blanksarounddeflist':1,
    1620. 

  1620. 			'blanksaroundtable':1,
    1621. 

  1621. 			'blanksaroundbar':1,
    1622. 

  1622. 			# 'blanksaroundtitle':1,
    1623. 

  1623. 			# 'blanksaroundnumtitle':1,
    1624. 

  1624. 		},
    1625. 

  1625. 		'tex': {
    1626. 

  1626. 			'stylable':1,
    1627. 

  1627. 			'escapeurl':1,
    1628. 

  1628. 			'autonumberlist':1,
    1629. 

  1629. 			'autonumbertitle':1,
    1630. 

  1630. 			'spacedlistitem':1,
    1631. 

  1631. 			'compactlist':1,
    1632. 

  1632. 			'parainsidelist':1,
    1633. 

  1633. 			'tableable':1,
    1634. 

  1634. 			'tablecellstrip':1,
    1635. 

  1635. 			'tabletitlerowinbold':1,
    1636. 

  1636. 			'verbblocknotescaped':1,
    1637. 

  1637. 			'keeplistindent':1,
    1638. 

  1638. 			'listmaxdepth':4,  # deflist is 6
    1639. 

  1639. 			'quotemaxdepth':6,
    1640. 

  1640. 			'barinsidequote':1,
    1641. 

  1641. 			'finalescapetitle':1,
    1642. 

  1642. 			'autotocnewpageafter':1,
    1643. 

  1643. 			'mapbar2pagebreak':1,
    1644. 

  1644. 			'tablecellaligntype':'column',
    1645. 

  1645. 			'tablecellmulticol':1,
    1646. 

  1646. 

  1647. 			'blanksaroundpara':1,
    1648. 

  1648. 			'blanksaroundverb':1,
    1649. 

  1649. 			# 'blanksaroundquote':1,
    1650. 

  1650. 			'blanksaroundlist':1,
    1651. 

  1651. 			'blanksaroundnumlist':1,
    1652. 

  1652. 			'blanksarounddeflist':1,
    1653. 

  1653. 			'blanksaroundtable':1,
    1654. 

  1654. 			'blanksaroundbar':1,
    1655. 

  1655. 			'blanksaroundtitle':1,
    1656. 

  1656. 			'blanksaroundnumtitle':1,
    1657. 

  1657. 		},
    1658. 

  1658. 		'lout': {
    1659. 

  1659. 			'keepquoteindent':1,
    1660. 

  1660. 			'deflisttextstrip':1,
    1661. 

  1661. 			'escapeurl':1,
    1662. 

  1662. 			'verbblocknotescaped':1,
    1663. 

  1663. 			'imgalignable':1,
    1664. 

  1664. 			'mapbar2pagebreak':1,
    1665. 

  1665. 			'titleblocks':1,
    1666. 

  1666. 			'autonumberlist':1,
    1667. 

  1667. 			'parainsidelist':1,
    1668. 

  1668. 

  1669. 			'blanksaroundpara':1,
    1670. 

  1670. 			'blanksaroundverb':1,
    1671. 

  1671. 			# 'blanksaroundquote':1,
    1672. 

  1672. 			'blanksaroundlist':1,
    1673. 

  1673. 			'blanksaroundnumlist':1,
    1674. 

  1674. 			'blanksarounddeflist':1,
    1675. 

  1675. 			'blanksaroundtable':1,
    1676. 

  1676. 			'blanksaroundbar':1,
    1677. 

  1677. 			'blanksaroundtitle':1,
    1678. 

  1678. 			'blanksaroundnumtitle':1,
    1679. 

  1679. 		},
    1680. 

  1680. 		'moin': {
    1681. 

  1681. 			'spacedlistitem':1,
    1682. 

  1682. 			'linkable':1,
    1683. 

  1683. 			'keeplistindent':1,
    1684. 

  1684. 			'tableable':1,
    1685. 

  1685. 			'barinsidequote':1,
    1686. 

  1686. 			'tabletitlerowinbold':1,
    1687. 

  1687. 			'tablecellstrip':1,
    1688. 

  1688. 			'autotocwithbars':1,
    1689. 

  1689. 			'tablecellaligntype':'cell',
    1690. 

  1690. 			'deflisttextstrip':1,
    1691. 

  1691. 

  1692. 			'blanksaroundpara':1,
    1693. 

  1693. 			'blanksaroundverb':1,
    1694. 

  1694. 			# 'blanksaroundquote':1,
    1695. 

  1695. 			'blanksaroundlist':1,
    1696. 

  1696. 			'blanksaroundnumlist':1,
    1697. 

  1697. 			'blanksarounddeflist':1,
    1698. 

  1698. 			'blanksaroundtable':1,
    1699. 

  1699. 			# 'blanksaroundbar':1,
    1700. 

  1700. 			'blanksaroundtitle':1,
    1701. 

  1701. 			'blanksaroundnumtitle':1,
    1702. 

  1702. 		},
    1703. 

  1703. 		'gwiki': {
    1704. 

  1704. 			'spacedlistitem':1,
    1705. 

  1705. 			'linkable':1,
    1706. 

  1706. 			'keeplistindent':1,
    1707. 

  1707. 			'tableable':1,
    1708. 

  1708. 			'tabletitlerowinbold':1,
    1709. 

  1709. 			'tablecellstrip':1,
    1710. 

  1710. 			'autonumberlist':1,
    1711. 

  1711. 

  1712. 			'blanksaroundpara':1,
    1713. 

  1713. 			'blanksaroundverb':1,
    1714. 

  1714. 			# 'blanksaroundquote':1,
    1715. 

  1715. 			'blanksaroundlist':1,
    1716. 

  1716. 			'blanksaroundnumlist':1,
    1717. 

  1717. 			'blanksarounddeflist':1,
    1718. 

  1718. 			'blanksaroundtable':1,
    1719. 

  1719. 			# 'blanksaroundbar':1,
    1720. 

  1720. 			'blanksaroundtitle':1,
    1721. 

  1721. 			'blanksaroundnumtitle':1,
    1722. 

  1722. 		},
    1723. 

  1723. 		'adoc': {
    1724. 

  1724. 			'spacedlistitem':1,
    1725. 

  1725. 			'linkable':1,
    1726. 

  1726. 			'keeplistindent':1,
    1727. 

  1727. 			'autonumberlist':1,
    1728. 

  1728. 			'autonumbertitle':1,
    1729. 

  1729. 			'listnotnested':1,
    1730. 

  1730. 			'blanksaroundpara':1,
    1731. 

  1731. 			'blanksaroundverb':1,
    1732. 

  1732. 			'blanksaroundlist':1,
    1733. 

  1733. 			'blanksaroundnumlist':1,
    1734. 

  1734. 			'blanksarounddeflist':1,
    1735. 

  1735. 			'blanksaroundtable':1,
    1736. 

  1736. 			'blanksaroundtitle':1,
    1737. 

  1737. 			'blanksaroundnumtitle':1,
    1738. 

  1738. 		},
    1739. 

  1739. 		'doku': {
    1740. 

  1740. 			'indentverbblock':1, # DokuWiki uses '  ' to mark verb blocks
    1741. 

  1741. 			'spacedlistitem':1,
    1742. 

  1742. 			'linkable':1,
    1743. 

  1743. 			'keeplistindent':1,
    1744. 

  1744. 			'tableable':1,
    1745. 

  1745. 			'barinsidequote':1,
    1746. 

  1746. 			'tablecellstrip':1,
    1747. 

  1747. 			'autotocwithbars':1,
    1748. 

  1748. 			'autonumberlist':1,
    1749. 

  1749. 			'imgalignable':1,
    1750. 

  1750. 			'tablecellaligntype':'cell',
    1751. 

  1751. 

  1752. 			'blanksaroundpara':1,
    1753. 

  1753. 			'blanksaroundverb':1,
    1754. 

  1754. 			# 'blanksaroundquote':1,
    1755. 

  1755. 			'blanksaroundlist':1,
    1756. 

  1756. 			'blanksaroundnumlist':1,
    1757. 

  1757. 			'blanksarounddeflist':1,
    1758. 

  1758. 			'blanksaroundtable':1,
    1759. 

  1759. 			'blanksaroundbar':1,
    1760. 

  1760. 			'blanksaroundtitle':1,
    1761. 

  1761. 			'blanksaroundnumtitle':1,
    1762. 

  1762. 		},
    1763. 

  1763. 		'pmw': {
    1764. 

  1764. 			'indentverbblock':1,
    1765. 

  1765. 			'spacedlistitem':1,
    1766. 

  1766. 			'linkable':1,
    1767. 

  1767. 			'labelbeforelink':1,
    1768. 

  1768. 			# 'keeplistindent':1,
    1769. 

  1769. 			'tableable':1,
    1770. 

  1770. 			'barinsidequote':1,
    1771. 

  1771. 			'tablecellstrip':1,
    1772. 

  1772. 			'autotocwithbars':1,
    1773. 

  1773. 			'autonumberlist':1,
    1774. 

  1774. 			'spacedlistitemopen':1,
    1775. 

  1775. 			'spacednumlistitemopen':1,
    1776. 

  1776. 			'imgalignable':1,
    1777. 

  1777. 			'tabletitlerowinbold':1,
    1778. 

  1778. 			'tablecellaligntype':'cell',
    1779. 

  1779. 

  1780. 			'blanksaroundpara':1,
    1781. 

  1781. 			'blanksaroundverb':1,
    1782. 

  1782. 			'blanksaroundquote':1,
    1783. 

  1783. 			'blanksaroundlist':1,
    1784. 

  1784. 			'blanksaroundnumlist':1,
    1785. 

  1785. 			'blanksarounddeflist':1,
    1786. 

  1786. 			'blanksaroundtable':1,
    1787. 

  1787. 			'blanksaroundbar':1,
    1788. 

  1788. 			'blanksaroundtitle':1,
    1789. 

  1789. 			'blanksaroundnumtitle':1,
    1790. 

  1790. 		},
    1791. 

  1791. 		'wiki': {
    1792. 

  1792. 			'linkable':1,
    1793. 

  1793. 			'tableable':1,
    1794. 

  1794. 			'tablecellstrip':1,
    1795. 

  1795. 			'autotocwithbars':1,
    1796. 

  1796. 			'spacedlistitemopen':1,
    1797. 

  1797. 			'spacednumlistitemopen':1,
    1798. 

  1798. 			'deflisttextstrip':1,
    1799. 

  1799. 			'autonumberlist':1,
    1800. 

  1800. 			'imgalignable':1,
    1801. 

  1801. 

  1802. 			'blanksaroundpara':1,
    1803. 

  1803. 			'blanksaroundverb':1,
    1804. 

  1804. 			# 'blanksaroundquote':1,
    1805. 

  1805. 			'blanksaroundlist':1,
    1806. 

  1806. 			'blanksaroundnumlist':1,
    1807. 

  1807. 			'blanksarounddeflist':1,
    1808. 

  1808. 			'blanksaroundtable':1,
    1809. 

  1809. 			'blanksaroundbar':1,
    1810. 

  1810. 			'blanksaroundtitle':1,
    1811. 

  1811. 			'blanksaroundnumtitle':1,
    1812. 

  1812. 		},
    1813. 

  1813. 		'man': {
    1814. 

  1814. 			'spacedlistitem':1,
    1815. 

  1815. 			'tagnotindentable':1,
    1816. 

  1816. 			'tableable':1,
    1817. 

  1817. 			'tablecellaligntype':'column',
    1818. 

  1818. 			'tabletitlerowinbold':1,
    1819. 

  1819. 			'tablecellstrip':1,
    1820. 

  1820. 			'barinsidequote':1,
    1821. 

  1821. 			'parainsidelist':0,
    1822. 

  1822. 

  1823. 			'blanksaroundpara':1,
    1824. 

  1824. 			'blanksaroundverb':1,
    1825. 

  1825. 			# 'blanksaroundquote':1,
    1826. 

  1826. 			'blanksaroundlist':1,
    1827. 

  1827. 			'blanksaroundnumlist':1,
    1828. 

  1828. 			'blanksarounddeflist':1,
    1829. 

  1829. 			'blanksaroundtable':1,
    1830. 

  1830. 			# 'blanksaroundbar':1,
    1831. 

  1831. 			'blanksaroundtitle':1,
    1832. 

  1832. 			'blanksaroundnumtitle':1,
    1833. 

  1833. 		},
    1834. 

  1834. 		'pm6': {
    1835. 

  1835. 			'keeplistindent':1,
    1836. 

  1836. 			'verbblockfinalescape':1,
    1837. 

  1837. 			#TODO add support for these
    1838. 

  1838. 			# maybe set a JOINNEXT char and do it on addLineBreaks()
    1839. 

  1839. 			'notbreaklistopen':1,
    1840. 

  1840. 			'barinsidequote':1,
    1841. 

  1841. 			'autotocwithbars':1,
    1842. 

  1842. 			'onelinepara':1,
    1843. 

  1843. 

  1844. 			'blanksaroundpara':1,
    1845. 

  1845. 			'blanksaroundverb':1,
    1846. 

  1846. 			# 'blanksaroundquote':1,
    1847. 

  1847. 			'blanksaroundlist':1,
    1848. 

  1848. 			'blanksaroundnumlist':1,
    1849. 

  1849. 			'blanksarounddeflist':1,
    1850. 

  1850. 			# 'blanksaroundtable':1,
    1851. 

  1851. 			# 'blanksaroundbar':1,
    1852. 

  1852. 			'blanksaroundtitle':1,
    1853. 

  1853. 			'blanksaroundnumtitle':1,
    1854. 

  1854. 		},
    1855. 

  1855. 		'creole': {
    1856. 

  1856. 			'linkable':1,
    1857. 

  1857. 			'tableable':1,
    1858. 

  1858. 			'imglinkable':1,
    1859. 

  1859. 			'tablecellstrip':1,
    1860. 

  1860. 			'autotocwithbars':1,
    1861. 

  1861. 			'spacedlistitemopen':1,
    1862. 

  1862. 			'spacednumlistitemopen':1,
    1863. 

  1863. 			'deflisttextstrip':1,
    1864. 

  1864. 			'verbblocknotescaped':1,
    1865. 

  1865. 			'blanksaroundpara':1,
    1866. 

  1866. 			'blanksaroundverb':1,
    1867. 

  1867. 			'blanksaroundquote':1,
    1868. 

  1868. 			'blanksaroundlist':1,
    1869. 

  1869. 			'blanksaroundnumlist':1,
    1870. 

  1870. 			'blanksarounddeflist':1,
    1871. 

  1871. 			'blanksaroundtable':1,
    1872. 

  1872. 			'blanksaroundbar':1,
    1873. 

  1873. 			'blanksaroundtitle':1,
    1874. 

  1874. 		},
    1875. 

  1875. 	}
    1876. 

  1876. 	
    1877. 

  1877. 	# Exceptions for --css-sugar
    1878. 

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

  1879. 		rules_bank['html']['indentverbblock'] = 0
    1880. 

  1880. 		rules_bank['html']['autotocwithbars'] = 0
    1881. 

  1881. 	
    1882. 

  1882. 	# Get the target specific rules
    1883. 

  1883. 	if config['target'] == 'xhtml':
    1884. 

  1884. 		myrules = rules_bank['html'].copy()   # inheritance
    1885. 

  1885. 		myrules.update(rules_bank['xhtml'])   # get XHTML specific
    1886. 

  1886. 	elif config['target'] == 'art':
    1887. 

  1887. 		myrules = rules_bank['txt'].copy()    # inheritance
    1888. 

  1888. 		if config['slides']:
    1889. 

  1889. 			myrules['blanksaroundtitle'] = 0
    1890. 

  1890. 			myrules['blanksaroundnumtitle'] = 0
    1891. 

  1891. 	else:
    1892. 

  1892. 		myrules = rules_bank[config['target']].copy()
    1893. 

  1893. 	
    1894. 

  1894. 	# Populate return dictionary
    1895. 

  1895. 	for key in allrules: ret[key] = 0        # reset all
    1896. 

  1896. 	ret.update(myrules)                      # get rules
    1897. 

  1897. 	
    1898. 

  1898. 	return ret
    1899. 

  1899. 

  1900. 

  1901. ##############################################################################
    1902. 

  1902. 

  1903. 

  1904. def getRegexes():
    1905. 

  1905. 	"Returns all the regexes used to find the t2t marks"
    1906. 

  1906. 	
    1907. 

  1907. 	bank = {
    1908. 

  1908. 	'blockVerbOpen':
    1909. 

  1909. 		re.compile(r'^```\s*$'),
    1910. 

  1910. 	'blockVerbClose':
    1911. 

  1911. 		re.compile(r'^```\s*$'),
    1912. 

  1912. 	'blockRawOpen':
    1913. 

  1913. 		re.compile(r'^"""\s*$'),
    1914. 

  1914. 	'blockRawClose':
    1915. 

  1915. 		re.compile(r'^"""\s*$'),
    1916. 

  1916. 	'blockTaggedOpen':
    1917. 

  1917. 		re.compile(r"^'''\s*$"),
    1918. 

  1918. 	'blockTaggedClose':
    1919. 

  1919. 		re.compile(r"^'''\s*$"),
    1920. 

  1920. 	'blockCommentOpen':
    1921. 

  1921. 		re.compile(r'^%%%\s*$'),
    1922. 

  1922. 	'blockCommentClose':
    1923. 

  1923. 		re.compile(r'^%%%\s*$'),
    1924. 

  1924. 	'quote':
    1925. 

  1925. 		re.compile(r'^\t+'),
    1926. 

  1926. 	'1lineVerb':
    1927. 

  1927. 		re.compile(r'^``` (?=.)'),
    1928. 

  1928. 	'1lineRaw':
    1929. 

  1929. 		re.compile(r'^""" (?=.)'),
    1930. 

  1930. 	'1lineTagged':
    1931. 

  1931. 		re.compile(r"^''' (?=.)"),
    1932. 

  1932. 	# mono, raw, bold, italic, underline:
    1933. 

  1933. 	# - marks must be glued with the contents, no boundary spaces
    1934. 

  1934. 	# - they are greedy, so in ****bold****, turns to <b>**bold**</b>
    1935. 

  1935. 	'fontMono':
    1936. 

  1936. 		re.compile(  r'``([^\s](|.*?[^\s])`*)``'),
    1937. 

  1937. 	'raw':
    1938. 

  1938. 		re.compile(  r'""([^\s](|.*?[^\s])"*)""'),
    1939. 

  1939. 	'tagged':
    1940. 

  1940. 		re.compile(  r"''([^\s](|.*?[^\s])'*)''"),
    1941. 

  1941. 	'fontBold':
    1942. 

  1942. 		re.compile(r'\*\*([^\s](|.*?[^\s])\**)\*\*'),
    1943. 

  1943. 	'fontItalic':
    1944. 

  1944. 		re.compile(  r'//([^\s](|.*?[^\s])/*)//'),
    1945. 

  1945. 	'fontUnderline':
    1946. 

  1946. 		re.compile(  r'__([^\s](|.*?[^\s])_*)__'),
    1947. 

  1947. 	'fontStrike':
    1948. 

  1948. 		re.compile(  r'--([^\s](|.*?[^\s])-*)--'),
    1949. 

  1949. 	'list':
    1950. 

  1950. 		re.compile(r'^( *)(-) (?=[^ ])'),
    1951. 

  1951. 	'numlist':
    1952. 

  1952. 		re.compile(r'^( *)(\+) (?=[^ ])'),
    1953. 

  1953. 	'deflist':
    1954. 

  1954. 		re.compile(r'^( *)(:) (.*)$'),
    1955. 

  1955. 	'listclose':
    1956. 

  1956. 		re.compile(r'^( *)([-+:])\s*$'),
    1957. 

  1957. 	'bar':
    1958. 

  1958. 		re.compile(r'^(\s*)([_=-]{20,})\s*$'),
    1959. 

  1959. 	'table':
    1960. 

  1960. 		re.compile(r'^ *\|\|? '),
    1961. 

  1961. 	'blankline':
    1962. 

  1962. 		re.compile(r'^\s*$'),
    1963. 

  1963. 	'comment':
    1964. 

  1964. 		re.compile(r'^%'),
    1965. 

  1965. 	
    1966. 

  1966. 	# Auxiliary tag regexes
    1967. 

  1967. 	'_imgAlign'        : re.compile(r'~A~', re.I),
    1968. 

  1968. 	'_tableAlign'      : re.compile(r'~A~', re.I),
    1969. 

  1969. 	'_anchor'          : re.compile(r'~A~', re.I),
    1970. 

  1970. 	'_tableBorder'     : re.compile(r'~B~', re.I),
    1971. 

  1971. 	'_tableColAlign'   : re.compile(r'~C~', re.I),
    1972. 

  1972. 	'_tableCellColSpan': re.compile(r'~S~', re.I),
    1973. 

  1973. 	'_tableCellAlign'  : re.compile(r'~A~', re.I),
    1974. 

  1974. 	}
    1975. 

  1975. 	
    1976. 

  1976. 	# Special char to place data on TAGs contents  (\a == bell)
    1977. 

  1977. 	bank['x'] = re.compile('\a')
    1978. 

  1978. 	
    1979. 

  1979. 	# %%macroname [ (formatting) ]
    1980. 

  1980. 	bank['macros'] = re.compile(r'%%%%(?P<name>%s)\b(\((?P<fmt>.*?)\))?' % (
    1981. 

  1981. 		'|'.join(MACROS.keys())), re.I)
    1982. 

  1982. 	
    1983. 

  1983. 	# %%TOC special macro for TOC positioning
    1984. 

  1984. 	bank['toc'] = re.compile(r'^ *%%toc\s*$', re.I)
    1985. 

  1985. 	
    1986. 

  1986. 	# Almost complicated title regexes ;)
    1987. 

  1987. 	titskel = r'^ *(?P<id>%s)(?P<txt>%s)\1(\[(?P<label>[\w-]*)\])?\s*$'
    1988. 

  1988. 	bank[   'title'] = re.compile(titskel%('[=]{1,5}','[^=](|.*[^=])'))
    1989. 

  1989. 	bank['numtitle'] = re.compile(titskel%('[+]{1,5}','[^+](|.*[^+])'))
    1990. 

  1990. 	
    1991. 

  1991. 	### Complicated regexes begin here ;)
    1992. 

  1992. 	#
    1993. 

  1993. 	# Textual descriptions on --help's style: [...] is optional, | is OR
    1994. 

  1994. 	
    1995. 

  1995. 	
    1996. 

  1996. 	### First, some auxiliary variables
    1997. 

  1997. 	#
    1998. 

  1998. 	
    1999. 

  1999. 	# [image.EXT]
    2000. 

  2000. 	patt_img = r'\[([\w_,.+%$#@!?+~/-]+\.(png|jpe?g|gif|eps|bmp))\]'
    2001. 

  2001. 	
    2002. 

  2002. 	# Link things
    2003. 

  2003. 	# http://www.gbiv.com/protocols/uri/rfc/rfc3986.html
    2004. 

  2004. 	# pchar: A-Za-z._~- / %FF / !$&'()*+,;= / :@
    2005. 

  2005. 	# Recomended order: scheme://user:pass@domain/path?query=foo#anchor
    2006. 

  2006. 	# Also works      : scheme://user:pass@domain/path#anchor?query=foo
    2007. 

  2007. 	# TODO form: !'():
    2008. 

  2008. 	urlskel = {
    2009. 

  2009. 		'proto' : r'(https?|ftp|news|telnet|gopher|wais)://',
    2010. 

  2010. 		'guess' : r'(www[23]?|ftp)\.',         # w/out proto, try to guess
    2011. 

  2011. 		'login' : r'A-Za-z0-9_.-',             # for ftp://login@domain.com
    2012. 

  2012. 		'pass'  : r'[^ @]*',                   # for ftp://login:pass@dom.com
    2013. 

  2013. 		'chars' : r'A-Za-z0-9%._/~:,=$@&+-',   # %20(space), :80(port), D&D
    2014. 

  2014. 		'anchor': r'A-Za-z0-9%._-',            # %nn(encoded)
    2015. 

  2015. 		'form'  : r'A-Za-z0-9/%&=+:;.,$@*_-',  # .,@*_-(as is)
    2016. 

  2016. 		'punct' : r'.,;:!?'
    2017. 

  2017. 	}
    2018. 

  2018. 	
    2019. 

  2019. 	# username [ :password ] @
    2020. 

  2020. 	patt_url_login = r'([%s]+(:%s)?@)?'%(urlskel['login'],urlskel['pass'])
    2021. 

  2021. 	
    2022. 

  2022. 	# [ http:// ] [ username:password@ ] domain.com [ / ]
    2023. 

  2023. 	#     [ #anchor | ?form=data ]
    2024. 

  2024. 	retxt_url = r'\b(%s%s|%s)[%s]+\b/*(\?[%s]+)?(#[%s]*)?'%(
    2025. 

  2025. 		urlskel['proto'],patt_url_login, urlskel['guess'],
    2026. 

  2026. 		urlskel['chars'],urlskel['form'],urlskel['anchor'])
    2027. 

  2027. 	
    2028. 

  2028. 	# filename | [ filename ] #anchor
    2029. 

  2029. 	retxt_url_local = r'[%s]+|[%s]*(#[%s]*)'%(
    2030. 

  2030. 		urlskel['chars'],urlskel['chars'],urlskel['anchor'])
    2031. 

  2031. 	
    2032. 

  2032. 	# user@domain [ ?form=data ]
    2033. 

  2033. 	patt_email = r'\b[%s]+@([A-Za-z0-9_-]+\.)+[A-Za-z]{2,4}\b(\?[%s]+)?'%(
    2034. 

  2034. 		urlskel['login'],urlskel['form'])
    2035. 

  2035. 	
    2036. 

  2036. 	# Saving for future use
    2037. 

  2037. 	bank['_urlskel'] = urlskel
    2038. 

  2038. 	
    2039. 

  2039. 	### And now the real regexes
    2040. 

  2040. 	#
    2041. 

  2041. 	
    2042. 

  2042. 	bank['email'] = re.compile(patt_email,re.I)
    2043. 

  2043. 	
    2044. 

  2044. 	# email | url
    2045. 

  2045. 	bank['link'] = re.compile(r'%s|%s'%(retxt_url,patt_email), re.I)
    2046. 

  2046. 	
    2047. 

  2047. 	# \[ label | imagetag    url | email | filename \]
    2048. 

  2048. 	bank['linkmark'] = re.compile(
    2049. 

  2049. 		r'\[(?P<label>%s|[^]]+) (?P<link>%s|%s|%s)\]'%(
    2050. 

  2050. 			patt_img, retxt_url, patt_email, retxt_url_local),
    2051. 

  2051. 		re.L+re.I)
    2052. 

  2052. 	
    2053. 

  2053. 	# Image
    2054. 

  2054. 	bank['img'] = re.compile(patt_img, re.L+re.I)
    2055. 

  2055. 	
    2056. 

  2056. 	# Special things
    2057. 

  2057. 	bank['special'] = re.compile(r'^%!\s*')
    2058. 

  2058. 	return bank
    2059. 

  2059. ### END OF regex nightmares
    2060. 

  2060. 

  2061. ################# functions for the ASCII Art backend ########################
    2062. 

  2062. 

  2063. def aa_line(char, length):
    2064. 

  2064. 	return char * length
    2065. 

  2065. 

  2066. def aa_box(txt, length):
    2067. 

  2067. 	len_txt = len(txt)
    2068. 

  2068. 	nspace = (length - len_txt - 4) / 2
    2069. 

  2069. 	line_box = " " * nspace + AA['corner'] + AA['border'] * (len_txt + 2) + AA['corner']
    2070. 

  2070. 	# <----- nspace " " -----> "+" <----- len_txt+2 "-" -----> "+"
    2071. 

  2071. 	#                           +-------------------------------+
    2072. 

  2072. 	#                           | all theeeeeeeeeeeeeeeeee text |
    2073. 

  2073. 	# <----- nspace " " -----> "| " <--------- txt ---------> " |"
    2074. 

  2074. 	line_txt = " " * nspace + AA['side'] + ' ' + txt + ' ' + AA['side']
    2075. 

  2075. 	return [line_box, line_txt, line_box]
    2076. 

  2076. 

  2077. def aa_header(header_data, length, n, end):
    2078. 

  2078. 	header = [aa_line(AA['bar2'], length)]
    2079. 

  2079. 	header.extend(['']*n)
    2080. 

  2080. 	for h in 'HEADER1', 'HEADER2', 'HEADER3':
    2081. 

  2081. 		if header_data[h]:
    2082. 

  2082. 			header.extend(aa_box(header_data[h], length))
    2083. 

  2083. 			header.extend(['']*n)
    2084. 

  2084. 	header.extend(['']*end)
    2085. 

  2085. 	header.append(aa_line(AA['bar2'], length))
    2086. 

  2086. 	return header
    2087. 

  2087. 

  2088. def aa_slide(title, length):
    2089. 

  2089. 	res = [aa_line(AA['bar2'], length)]
    2090. 

  2090. 	res.append('')
    2091. 

  2091. 	res.append(title.center(length))
    2092. 

  2092. 	res.append('')
    2093. 

  2093. 	res.append(aa_line(AA['bar2'], length))
    2094. 

  2094. 	return res
    2095. 

  2095. 

  2096. def aa_table(table):
    2097. 

  2097.     data = [row[2:-2].split(' | ') for row in table]
    2098. 

  2098.     n = max([len(line) for line in data])
    2099. 

  2099.     data = [line + (n - len(line)) * [''] for line in data]
    2100. 

  2100.     tab = []
    2101. 

  2101.     for i in range(n):
    2102. 

  2102.         tab.append([line[i] for line in data])
    2103. 

  2103.     length = [max([len(el) for el in line]) for line in tab]
    2104. 

  2104.     res = "+"
    2105. 

  2105.     for i in range(n):
    2106. 

  2106.         res = res + (length[i] + 2) * "-" + '+'
    2107. 

  2107.     ret = []
    2108. 

  2108.     for line in data:
    2109. 

  2109.         aff = "|"
    2110. 

  2110.         ret.append(res)
    2111. 

  2111.         for j,el in enumerate(line):
    2112. 

  2112.             aff = aff + " " + el + (length[j] - len(el) + 1) * " " + "|"
    2113. 

  2113.         ret.append(aff)
    2114. 

  2114.     ret.append(res)
    2115. 

  2115.     return ret
    2116. 

  2116. 

  2117. ##############################################################################
    2118. 

  2118. 

  2119. class error(Exception):
    2120. 

  2120. 	pass
    2121. 

  2121. def echo(msg):   # for quick debug
    2122. 

  2122. 	print '\033[32;1m%s\033[m'%msg
    2123. 

  2123. def Quit(msg=''):
    2124. 

  2124. 	if msg: print msg
    2125. 

  2125. 	sys.exit(0)
    2126. 

  2126. def Error(msg):
    2127. 

  2127. 	msg = _("%s: Error: ")%my_name + msg
    2128. 

  2128. 	raise error, msg
    2129. 

  2129. def getTraceback():
    2130. 

  2130. 	try:
    2131. 

  2131. 		from traceback import format_exception
    2132. 

  2132. 		etype, value, tb = sys.exc_info()
    2133. 

  2133. 		return ''.join(format_exception(etype, value, tb))
    2134. 

  2134. 	except: pass
    2135. 

  2135. def getUnknownErrorMessage():
    2136. 

  2136. 	msg = '%s\n%s (%s):\n\n%s'%(
    2137. 

  2137. 		_('Sorry! Txt2tags aborted by an unknown error.'),
    2138. 

  2138. 		_('Please send the following Error Traceback to the author'),
    2139. 

  2139. 		my_email, getTraceback())
    2140. 

  2140. 	return msg
    2141. 

  2141. def Message(msg,level):
    2142. 

  2142. 	if level <= VERBOSE and not QUIET:
    2143. 

  2143. 		prefix = '-'*5
    2144. 

  2144. 		print "%s %s"%(prefix*level, msg)
    2145. 

  2145. def Debug(msg,id_=0,linenr=None):
    2146. 

  2146. 	"Show debug messages, categorized (colored or not)"
    2147. 

  2147. 	if QUIET or not DEBUG: return
    2148. 

  2148. 	if int(id_) not in range(8): id_ = 0
    2149. 

  2149. 	# 0:black 1:red 2:green 3:yellow 4:blue 5:pink 6:cyan 7:white ;1:light
    2150. 

  2150. 	ids            = ['INI','CFG','SRC','BLK','HLD','GUI','OUT','DET']
    2151. 

  2151. 	colors_bgdark  = ['7;1','1;1','3;1','6;1','4;1','5;1','2;1','7;1']
    2152. 

  2152. 	colors_bglight = ['0'  ,'1'  ,'3'  ,'6'  ,'4'  ,'5'  ,'2'  ,'0'  ]
    2153. 

  2153. 	if linenr is not None: msg = "LINE %04d: %s"%(linenr,msg)
    2154. 

  2154. 	if COLOR_DEBUG:
    2155. 

  2155. 		if BG_LIGHT: color = colors_bglight[id_]
    2156. 

  2156. 		else       : color = colors_bgdark[id_]
    2157. 

  2157. 		msg = '\033[3%sm%s\033[m'%(color,msg)
    2158. 

  2158. 	print "++ %s: %s"%(ids[id_],msg)
    2159. 

  2159. 

  2160. def Readfile(file_path, remove_linebreaks=0, ignore_error=0):
    2161. 

  2161. 	data = []
    2162. 

  2162. 	if file_path == '-':
    2163. 

  2163. 		try:
    2164. 

  2164. 			data = sys.stdin.readlines()
    2165. 

  2165. 		except:
    2166. 

  2166. 			if not ignore_error:
    2167. 

  2167. 				Error(_('You must feed me with data on STDIN!'))
    2168. 

  2168. 	else:
    2169. 

  2169. 		try:
    2170. 

  2170. 			f = open(file_path)
    2171. 

  2171. 			data = f.readlines()
    2172. 

  2172. 			f.close()
    2173. 

  2173. 		except:
    2174. 

  2174. 			if not ignore_error:
    2175. 

  2175. 				Error(_("Cannot read file:") + ' ' + file_path)
    2176. 

  2176. 	if remove_linebreaks:
    2177. 

  2177. 		data = map(lambda x:re.sub('[\n\r]+$', '', x), data)
    2178. 

  2178. 	Message(_("File read (%d lines): %s") % (len(data), file_path), 2)
    2179. 

  2179. 	return data
    2180. 

  2180. 

  2181. def Savefile(file_path, contents):
    2182. 

  2182. 	try:
    2183. 

  2183. 		f = open(file_path, 'wb')
    2184. 

  2184. 	except:
    2185. 

  2185. 		Error(_("Cannot open file for writing:") + ' ' + file_path)
    2186. 

  2186. 	if type(contents) == type([]):
    2187. 

  2187. 		doit = f.writelines
    2188. 

  2188. 	else:
    2189. 

  2189. 		doit = f.write
    2190. 

  2190. 	doit(contents)
    2191. 

  2191. 	f.close()
    2192. 

  2192. 

  2193. def showdic(dic):
    2194. 

  2194. 	for k in dic.keys(): print "%15s : %s" % (k,dic[k])
    2195. 

  2195. def dotted_spaces(txt=''):
    2196. 

  2196. 	return txt.replace(' ', '.')
    2197. 

  2197. 

  2198. # TIP: win env vars http://www.winnetmag.com/Article/ArticleID/23873/23873.html
    2199. 

  2199. def get_rc_path():
    2200. 

  2200. 	"Return the full path for the users' RC file"
    2201. 

  2201. 	# Try to get the path from an env var. if yes, we're done
    2202. 

  2202. 	user_defined = os.environ.get('T2TCONFIG')
    2203. 

  2203. 	if user_defined: return user_defined
    2204. 

  2204. 	# Env var not found, so perform automatic path composing
    2205. 

  2205. 	# Set default filename according system platform
    2206. 

  2206. 	rc_names = {'default':'.txt2tagsrc', 'win':'_t2trc'}
    2207. 

  2207. 	rc_file = rc_names.get(sys.platform[:3]) or rc_names['default']
    2208. 

  2208. 	# The file must be on the user directory, but where is this dir?
    2209. 

  2209. 	rc_dir_search = ['HOME', 'HOMEPATH']
    2210. 

  2210. 	for var in rc_dir_search:
    2211. 

  2211. 		rc_dir = os.environ.get(var)
    2212. 

  2212. 		if rc_dir: break
    2213. 

  2213. 	# rc dir found, now we must join dir+file to compose the full path
    2214. 

  2214. 	if rc_dir:
    2215. 

  2215. 		# Compose path and return it if the file exists
    2216. 

  2216. 		rc_path = os.path.join(rc_dir, rc_file)
    2217. 

  2217. 		# On windows, prefix with the drive (%homedrive%: 2k/XP/NT)
    2218. 

  2218. 		if sys.platform.startswith('win'):
    2219. 

  2219. 			rc_drive = os.environ.get('HOMEDRIVE')
    2220. 

  2220. 			rc_path = os.path.join(rc_drive,rc_path)
    2221. 

  2221. 		return rc_path
    2222. 

  2222. 	# Sorry, not found
    2223. 

  2223. 	return ''
    2224. 

  2224. 

  2225. 

  2226. 

  2227. ##############################################################################
    2228. 

  2228. 

  2229. class CommandLine:
    2230. 

  2230. 	"""
    2231. 

  2231. 	Command Line class - Masters command line
    2232. 

  2232. 

  2233. 	This class checks and extract data from the provided command line.
    2234. 

  2234. 	The --long options and flags are taken from the global OPTIONS,
    2235. 

  2235. 	FLAGS and ACTIONS dictionaries. The short options are registered
    2236. 

  2236. 	here, and also their equivalence to the long ones.
    2237. 

  2237. 

  2238. 	_compose_short_opts() -> str
    2239. 

  2239. 	_compose_long_opts() -> list
    2240. 

  2240. 		Compose the valid short and long options list, on the
    2241. 

  2241. 		'getopt' format.
    2242. 

  2242. 

  2243. 	parse() -> (opts, args)
    2244. 

  2244. 		Call getopt to check and parse the command line.
    2245. 

  2245. 		It expects to receive the command line as a list, and
    2246. 

  2246. 		without the program name (sys.argv[1:]).
    2247. 

  2247. 

  2248. 	get_raw_config() -> [RAW config]
    2249. 

  2249. 		Scans command line and convert the data to the RAW config
    2250. 

  2250. 		format. See ConfigMaster class to the RAW format description.
    2251. 

  2251. 		Optional 'ignore' and 'filter_' arguments are used to filter
    2252. 

  2252. 		in or out specified keys.
    2253. 

  2253. 

  2254. 	compose_cmdline(dict) -> [Command line]
    2255. 

  2255. 		Compose a command line list from an already parsed config
    2256. 

  2256. 		dictionary, generated from RAW by ConfigMaster(). Use
    2257. 

  2257. 		this to compose an optimal command line for a group of
    2258. 

  2258. 		options.
    2259. 

  2259. 	
    2260. 

  2260. 	The get_raw_config() calls parse(), so the typical use of this
    2261. 

  2261. 	class is:
    2262. 

  2262. 	
    2263. 

  2263.             raw = CommandLine().get_raw_config(sys.argv[1:])
    2264. 

  2264. 	"""
    2265. 

  2265. 	def __init__(self):
    2266. 

  2266. 		self.all_options = OPTIONS.keys()
    2267. 

  2267. 		self.all_flags   = FLAGS.keys()
    2268. 

  2268. 		self.all_actions = ACTIONS.keys()
    2269. 

  2269. 		
    2270. 

  2270. 		# short:long options equivalence
    2271. 

  2271. 		self.short_long = {
    2272. 

  2272. 			'C':'config-file',
    2273. 

  2273. 			'h':'help',
    2274. 

  2274. 			'H':'no-headers',
    2275. 

  2275. 			'i':'infile',
    2276. 

  2276. 			'n':'enum-title',
    2277. 

  2277. 			'o':'outfile',
    2278. 

  2278. 			'q':'quiet',
    2279. 

  2279. 			't':'target',
    2280. 

  2280. 			'v':'verbose',
    2281. 

  2281. 			'V':'version',
    2282. 

  2282. 		}
    2283. 

  2283. 		
    2284. 

  2284. 		# Compose valid short and long options data for getopt
    2285. 

  2285. 		self.short_opts = self._compose_short_opts()
    2286. 

  2286. 		self.long_opts  = self._compose_long_opts()
    2287. 

  2287. 	
    2288. 

  2288. 	def _compose_short_opts(self):
    2289. 

  2289. 		"Returns a string like 'hVt:o' with all short options/flags"
    2290. 

  2290. 		ret = []
    2291. 

  2291. 		for opt in self.short_long.keys():
    2292. 

  2292. 			long_ = self.short_long[opt]
    2293. 

  2293. 			if long_ in self.all_options: # is flag or option?
    2294. 

  2294. 				opt = opt+':'        # option: have param
    2295. 

  2295. 			ret.append(opt)
    2296. 

  2296. 		#Debug('Valid SHORT options: %s'%ret)
    2297. 

  2297. 		return ''.join(ret)
    2298. 

  2298. 	
    2299. 

  2299. 	def _compose_long_opts(self):
    2300. 

  2300. 		"Returns a list with all the valid long options/flags"
    2301. 

  2301. 		ret = map(lambda x:x+'=', self.all_options)          # add =
    2302. 

  2302. 		ret.extend(self.all_flags)                           # flag ON
    2303. 

  2303. 		ret.extend(self.all_actions)                         # actions
    2304. 

  2304. 		ret.extend(map(lambda x:'no-'+x, self.all_flags))    # add no-*
    2305. 

  2305. 		ret.extend(['no-style','no-encoding'])               # turn OFF
    2306. 

  2306. 		ret.extend(['no-outfile','no-infile'])               # turn OFF
    2307. 

  2307. 		ret.extend(['no-dump-config', 'no-dump-source'])     # turn OFF
    2308. 

  2308. 		ret.extend(['no-targets'])                           # turn OFF
    2309. 

  2309. 		#Debug('Valid LONG options: %s'%ret)
    2310. 

  2310. 		return ret
    2311. 

  2311. 	
    2312. 

  2312. 	def _tokenize(self, cmd_string=''):
    2313. 

  2313. 		"Convert a command line string to a list"
    2314. 

  2314. 		#TODO protect quotes contents -- Don't use it, pass cmdline as list
    2315. 

  2315. 		return cmd_string.split()
    2316. 

  2316. 	
    2317. 

  2317. 	def parse(self, cmdline=[]):
    2318. 

  2318. 		"Check/Parse a command line list     TIP: no program name!"
    2319. 

  2319. 		# Get the valid options
    2320. 

  2320. 		short, long_ = self.short_opts, self.long_opts
    2321. 

  2321. 		# Parse it!
    2322. 

  2322. 		try:
    2323. 

  2323. 			opts, args = getopt.getopt(cmdline, short, long_)
    2324. 

  2324. 		except getopt.error, errmsg:
    2325. 

  2325. 			Error(_("%s (try --help)")%errmsg)
    2326. 

  2326. 		return (opts, args)
    2327. 

  2327. 	
    2328. 

  2328. 	def get_raw_config(self, cmdline=[], ignore=[], filter_=[], relative=0):
    2329. 

  2329. 		"Returns the options/arguments found as RAW config"
    2330. 

  2330. 		
    2331. 

  2331. 		if not cmdline: return []
    2332. 

  2332. 		ret = []
    2333. 

  2333. 		
    2334. 

  2334. 		# We need lists, not strings (such as from %!options)
    2335. 

  2335. 		if type(cmdline) in (type(''), type(u'')):
    2336. 

  2336. 			cmdline = self._tokenize(cmdline)
    2337. 

  2337. 

  2338. 		# Extract name/value pair of all configs, check for invalid names
    2339. 

  2339. 		options, arguments = self.parse(cmdline[:])
    2340. 

  2340. 

  2341. 		# Some cleanup on the raw config
    2342. 

  2342. 		for name, value in options:
    2343. 

  2343. 			
    2344. 

  2344. 			# Remove leading - and --
    2345. 

  2345. 			name = re.sub('^--?', '', name)
    2346. 

  2346. 

  2347. 			# Fix old misspelled --suGGar, --no-suGGar
    2348. 

  2348. 			name = name.replace('suggar', 'sugar')
    2349. 

  2349. 

  2350. 			# Translate short option to long
    2351. 

  2351. 			if len(name) == 1:
    2352. 

  2352. 				name = self.short_long[name]
    2353. 

  2353. 

  2354. 			# Outfile exception: path relative to PWD
    2355. 

  2355. 			if name == 'outfile' and relative and value not in [STDOUT, MODULEOUT]:
    2356. 

  2356. 				value = os.path.abspath(value)
    2357. 

  2357. 

  2358. 			# -C, --config-file inclusion, path relative to PWD
    2359. 

  2359. 			if name == 'config-file':
    2360. 

  2360. 				ret.extend(ConfigLines().include_config_file(value))
    2361. 

  2361. 				continue
    2362. 

  2362. 			
    2363. 

  2363. 			# Save this config
    2364. 

  2364. 			ret.append(['all', name, value])
    2365. 

  2365. 		
    2366. 

  2366. 		# All configuration was read and saved
    2367. 

  2367. 		
    2368. 

  2368. 		# Get infile, if any
    2369. 

  2369. 		while arguments:
    2370. 

  2370. 			infile = arguments.pop(0)
    2371. 

  2371. 			ret.append(['all', 'infile', infile])
    2372. 

  2372. 		
    2373. 

  2373. 		# Apply 'ignore' and 'filter_' rules (filter_ is stronger)
    2374. 

  2374. 		if (ignore or filter_):
    2375. 

  2375. 			filtered = []
    2376. 

  2376. 			for target, name, value in ret:
    2377. 

  2377. 				if (filter_ and name in filter_) or \
    2378. 

  2378. 				   (ignore and name not in ignore):
    2379. 

  2379. 					filtered.append([target, name, value])
    2380. 

  2380. 			ret = filtered[:]
    2381. 

  2381. 		
    2382. 

  2382. 		# Add the original command line string as 'realcmdline'
    2383. 

  2383. 		ret.append( ['all', 'realcmdline', cmdline] )
    2384. 

  2384. 		
    2385. 

  2385. 		return ret
    2386. 

  2386. 	
    2387. 

  2387. 	def compose_cmdline(self, conf={}, no_check=0):
    2388. 

  2388. 		"compose a full (and diet) command line from CONF dict"
    2389. 

  2389. 		if not conf: return []
    2390. 

  2390. 		args = []
    2391. 

  2391. 		dft_options = OPTIONS.copy()
    2392. 

  2392. 		cfg = conf.copy()
    2393. 

  2393. 		valid_opts = self.all_options + self.all_flags
    2394. 

  2394. 		use_short = {'no-headers':'H', 'enum-title':'n'}
    2395. 

  2395. 		# Remove useless options
    2396. 

  2396. 		if not no_check and cfg.get('toc-only'):
    2397. 

  2397. 			if cfg.has_key('no-headers'):
    2398. 

  2398. 				del cfg['no-headers']
    2399. 

  2399. 			if cfg.has_key('outfile'):
    2400. 

  2400. 				del cfg['outfile']      # defaults to STDOUT
    2401. 

  2401. 			if cfg.get('target') == 'txt':
    2402. 

  2402. 				del cfg['target']       # already default
    2403. 

  2403. 			args.append('--toc-only')  # must be the first
    2404. 

  2404. 			del cfg['toc-only']
    2405. 

  2405. 		# Add target type
    2406. 

  2406. 		if cfg.has_key('target'):
    2407. 

  2407. 			args.append('-t '+cfg['target'])
    2408. 

  2408. 			del cfg['target']
    2409. 

  2409. 		# Add other options
    2410. 

  2410. 		for key in cfg.keys():
    2411. 

  2411. 			if key not in valid_opts: continue  # may be a %!setting
    2412. 

  2412. 			if key == 'outfile' or key == 'infile': continue # later
    2413. 

  2413. 			val = cfg[key]
    2414. 

  2414. 			if not val: continue
    2415. 

  2415. 			# Default values are useless on cmdline
    2416. 

  2416. 			if val == dft_options.get(key): continue
    2417. 

  2417. 			# -short format
    2418. 

  2418. 			if key in use_short.keys():
    2419. 

  2419. 				args.append('-'+use_short[key])
    2420. 

  2420. 				continue
    2421. 

  2421. 			# --long format
    2422. 

  2422. 			if key in self.all_flags: # add --option
    2423. 

  2423. 				args.append('--'+key)
    2424. 

  2424. 			else:                     # add --option=value
    2425. 

  2425. 				args.append('--%s=%s'%(key,val))
    2426. 

  2426. 		# The outfile using -o
    2427. 

  2427. 		if cfg.has_key('outfile') and \
    2428. 

  2428. 		   cfg['outfile'] != dft_options.get('outfile'):
    2429. 

  2429. 			args.append('-o '+cfg['outfile'])
    2430. 

  2430. 		# Place input file(s) always at the end
    2431. 

  2431. 		if cfg.has_key('infile'):
    2432. 

  2432. 			args.append(' '.join(cfg['infile']))
    2433. 

  2433. 		# Return as a nice list
    2434. 

  2434. 		Debug("Diet command line: %s"%' '.join(args), 1)
    2435. 

  2435. 		return args
    2436. 

  2436. 

  2437. ##############################################################################
    2438. 

  2438. 

  2439. class SourceDocument:
    2440. 

  2440. 	"""
    2441. 

  2441. 	SourceDocument class - scan document structure, extract data
    2442. 

  2442. 	
    2443. 

  2443. 	It knows about full files. It reads a file and identify all
    2444. 

  2444. 	the areas beginning (Head,Conf,Body). With this info it can
    2445. 

  2445. 	extract each area contents.
    2446. 

  2446. 	Note: the original line break is removed.
    2447. 

  2447. 	
    2448. 

  2448. 	DATA:
    2449. 

  2449. 	  self.arearef - Save Head, Conf, Body init line number
    2450. 

  2450. 	  self.areas   - Store the area names which are not empty
    2451. 

  2451. 	  self.buffer  - The full file contents (with NO \\r, \\n)
    2452. 

  2452. 

  2453. 	METHODS:
    2454. 

  2454. 	  get()   - Access the contents of an Area. Example:
    2455. 

  2455. 	            config = SourceDocument(file).get('conf')
    2456. 

  2456. 	
    2457. 

  2457. 	  split() - Get all the document Areas at once. Example:
    2458. 

  2458. 	            head, conf, body = SourceDocument(file).split()
    2459. 

  2459. 	
    2460. 

  2460. 	RULES:
    2461. 

  2461. 	    * The document parts are sequential: Head, Conf and Body.
    2462. 

  2462. 	    * One ends when the next begins.
    2463. 

  2463. 	    * The Conf Area is optional, so a document can have just
    2464. 

  2464. 	      Head and Body Areas.
    2465. 

  2465. 	
    2466. 

  2466. 	    These are the Areas limits:
    2467. 

  2467. 	      - Head Area: the first three lines
    2468. 

  2468. 	      - Body Area: from the first valid text line to the end
    2469. 

  2469. 	      - Conf Area: the comments between Head and Body Areas
    2470. 

  2470. 

  2471. 	    Exception: If the first line is blank, this means no
    2472. 

  2472. 	    header info, so the Head Area is just the first line.
    2473. 

  2473. 	"""
    2474. 

  2474. 	def __init__(self, filename='', contents=[]):
    2475. 

  2475. 		self.areas = ['head','conf','body']
    2476. 

  2476. 		self.arearef = []
    2477. 

  2477. 		self.areas_fancy = ''
    2478. 

  2478. 		self.filename = filename
    2479. 

  2479. 		self.buffer = []
    2480. 

  2480. 		if filename:
    2481. 

  2481. 			self.scan_file(filename)
    2482. 

  2482. 		elif contents:
    2483. 

  2483. 			self.scan(contents)
    2484. 

  2484. 	
    2485. 

  2485. 	def split(self):
    2486. 

  2486. 		"Returns all document parts, splitted into lists."
    2487. 

  2487. 		return self.get('head'), self.get('conf'), self.get('body')
    2488. 

  2488. 	
    2489. 

  2489. 	def get(self, areaname):
    2490. 

  2490. 		"Returns head|conf|body contents from self.buffer"
    2491. 

  2491. 		# Sanity
    2492. 

  2492. 		if areaname not in self.areas: return []
    2493. 

  2493. 		if not self.buffer           : return []
    2494. 

  2494. 		# Go get it
    2495. 

  2495. 		bufini = 1
    2496. 

  2496. 		bufend = len(self.buffer)
    2497. 

  2497. 		if   areaname == 'head':
    2498. 

  2498. 			ini = bufini
    2499. 

  2499. 			end = self.arearef[1] or self.arearef[2] or bufend
    2500. 

  2500. 		elif areaname == 'conf':
    2501. 

  2501. 			ini = self.arearef[1]
    2502. 

  2502. 			end = self.arearef[2] or bufend
    2503. 

  2503. 		elif areaname == 'body':
    2504. 

  2504. 			ini = self.arearef[2]
    2505. 

  2505. 			end = bufend
    2506. 

  2506. 		else:
    2507. 

  2507. 			Error("Unknown Area name '%s'"%areaname)
    2508. 

  2508. 		lines = self.buffer[ini:end]
    2509. 

  2509. 		# Make sure head will always have 3 lines
    2510. 

  2510. 		while areaname == 'head' and len(lines) < 3:
    2511. 

  2511. 			lines.append('')
    2512. 

  2512. 		return lines
    2513. 

  2513. 	
    2514. 

  2514. 	def scan_file(self, filename):
    2515. 

  2515. 		Debug("source file: %s"%filename)
    2516. 

  2516. 		Message(_("Loading source document"),1)
    2517. 

  2517. 		buf = Readfile(filename, remove_linebreaks=1)
    2518. 

  2518. 		self.scan(buf)
    2519. 

  2519. 	
    2520. 

  2520. 	def scan(self, lines):
    2521. 

  2521. 		"Run through source file and identify head/conf/body areas"
    2522. 

  2522. 		buf = lines
    2523. 

  2523. 		if len(buf) == 0:
    2524. 

  2524. 			Error(_('The input file is empty: %s')%self.filename)
    2525. 

  2525. 		cfg_parser = ConfigLines().parse_line
    2526. 

  2526. 		buf.insert(0, '')                         # text start at pos 1
    2527. 

  2527. 		ref = [1,4,0]
    2528. 

  2528. 		if not buf[1].strip():                    # no header
    2529. 

  2529. 			ref[0] = 0 ; ref[1] = 2
    2530. 

  2530. 		rgx = getRegexes()
    2531. 

  2531. 		on_comment_block = 0
    2532. 

  2532. 		for i in xrange(ref[1],len(buf)):         # find body init:
    2533. 

  2533. 			# Handle comment blocks inside config area
    2534. 

  2534. 			if not on_comment_block \
    2535. 

  2535. 			   and rgx['blockCommentOpen'].search(buf[i]):
    2536. 

  2536. 				on_comment_block = 1
    2537. 

  2537. 				continue
    2538. 

  2538. 			if on_comment_block \
    2539. 

  2539. 			   and rgx['blockCommentOpen'].search(buf[i]):
    2540. 

  2540. 				on_comment_block = 0
    2541. 

  2541. 				continue
    2542. 

  2542. 			if on_comment_block: continue
    2543. 

  2543. 			
    2544. 

  2544. 			if buf[i].strip() and (           # ... not blank and
    2545. 

  2545. 			   buf[i][0] != '%' or            # ... not comment or
    2546. 

  2546. 			   rgx['macros'].match(buf[i]) or # ... %%macro
    2547. 

  2547. 			   rgx['toc'].match(buf[i])    or # ... %%toc
    2548. 

  2548. 			   cfg_parser(buf[i],'include')[1] or # ... %!include
    2549. 

  2549. 			   cfg_parser(buf[i],'csv')[1]        # ... %!csv
    2550. 

  2550. 			):
    2551. 

  2551. 				ref[2] = i ; break
    2552. 

  2552. 		if ref[1] == ref[2]: ref[1] = 0           # no conf area
    2553. 

  2553. 		for i in 0,1,2:                           # del !existent
    2554. 

  2554. 			if ref[i] >= len(buf): ref[i] = 0 # title-only
    2555. 

  2555. 			if not ref[i]: self.areas[i] = ''
    2556. 

  2556. 		Debug('Head,Conf,Body start line: %s'%ref)
    2557. 

  2557. 		self.arearef = ref                        # save results
    2558. 

  2558. 		self.buffer  = buf
    2559. 

  2559. 		# Fancyness sample: head conf body (1 4 8)
    2560. 

  2560. 		self.areas_fancy = "%s (%s)"%(
    2561. 

  2561. 			' '.join(self.areas),
    2562. 

  2562. 			' '.join(map(str, map(lambda x:x or '', ref))))
    2563. 

  2563. 		Message(_("Areas found: %s")%self.areas_fancy, 2)
    2564. 

  2564. 	
    2565. 

  2565. 	def get_raw_config(self):
    2566. 

  2566. 		"Handy method to get the CONF area RAW config (if any)"
    2567. 

  2567. 		if not self.areas.count('conf'): return []
    2568. 

  2568. 		Message(_("Scanning source document CONF area"),1)
    2569. 

  2569. 		raw = ConfigLines(
    2570. 

  2570. 			file_=self.filename, lines=self.get('conf'),
    2571. 

  2571. 			first_line=self.arearef[1]).get_raw_config()
    2572. 

  2572. 		Debug("document raw config: %s"%raw, 1)
    2573. 

  2573. 		return raw
    2574. 

  2574. 

  2575. ##############################################################################
    2576. 

  2576. 

  2577. class ConfigMaster:
    2578. 

  2578. 	"""
    2579. 

  2579. 	ConfigMaster class - the configuration wizard
    2580. 

  2580. 	
    2581. 

  2581. 	This class is the configuration master. It knows how to handle
    2582. 

  2582. 	the RAW and PARSED config format. It also performs the sanity
    2583. 

  2583. 	checking for a given configuration.
    2584. 

  2584. 	
    2585. 

  2585. 	DATA:
    2586. 

  2586. 	  self.raw         - Stores the config on the RAW format
    2587. 

  2587. 	  self.parsed      - Stores the config on the PARSED format
    2588. 

  2588. 	  self.defaults    - Stores the default values for all keys
    2589. 

  2589. 	  self.off         - Stores the OFF values for all keys
    2590. 

  2590. 	  self.multi       - List of keys which can have multiple values
    2591. 

  2591. 	  self.numeric     - List of keys which value must be a number
    2592. 

  2592. 	  self.incremental - List of keys which are incremental
    2593. 

  2593. 	
    2594. 

  2594.         RAW FORMAT:
    2595. 

  2595. 	  The RAW format is a list of lists, being each mother list item
    2596. 

  2596. 	  a full configuration entry. Any entry is a 3 item list, on
    2597. 

  2597. 	  the following format: [ TARGET, KEY, VALUE ]
    2598. 

  2598. 	  Being a list, the order is preserved, so it's easy to use
    2599. 

  2599. 	  different kinds of configs, as CONF area and command line,
    2600. 

  2600. 	  respecting the precedence.
    2601. 

  2601. 	  The special target 'all' is used when no specific target was
    2602. 

  2602. 	  defined on the original config.
    2603. 

  2603. 	
    2604. 

  2604. 	PARSED FORMAT:
    2605. 

  2605. 	  The PARSED format is a dictionary, with all the 'key : value'
    2606. 

  2606. 	  found by reading the RAW config. The self.target contents
    2607. 

  2607. 	  matters, so this dictionary only contains the target's
    2608. 

  2608. 	  config. The configs of other targets are ignored.
    2609. 

  2609. 	
    2610. 

  2610. 	The CommandLine and ConfigLines classes have the get_raw_config()
    2611. 

  2611. 	method which convert the configuration found to the RAW format.
    2612. 

  2612. 	Just feed it to parse() and get a brand-new ready-to-use config
    2613. 

  2613. 	dictionary. Example:
    2614. 

  2614. 	
    2615. 

  2615. 	    >>> raw = CommandLine().get_raw_config(['-n', '-H'])
    2616. 

  2616. 	    >>> print raw
    2617. 

  2617. 	    [['all', 'enum-title', ''], ['all', 'no-headers', '']]
    2618. 

  2618. 	    >>> parsed = ConfigMaster(raw).parse()
    2619. 

  2619. 	    >>> print parsed
    2620. 

  2620. 	    {'enum-title': 1, 'headers': 0}
    2621. 

  2621. 	"""
    2622. 

  2622. 	def __init__(self, raw=[], target=''):
    2623. 

  2623. 		self.raw          = raw
    2624. 

  2624. 		self.target       = target
    2625. 

  2625. 		self.parsed       = {}
    2626. 

  2626. 		self.dft_options  = OPTIONS.copy()
    2627. 

  2627. 		self.dft_flags    = FLAGS.copy()
    2628. 

  2628. 		self.dft_actions  = ACTIONS.copy()
    2629. 

  2629. 		self.dft_settings = SETTINGS.copy()
    2630. 

  2630. 		self.defaults     = self._get_defaults()
    2631. 

  2631. 		self.off          = self._get_off()
    2632. 

  2632. 		self.incremental  = ['verbose']
    2633. 

  2633. 		self.numeric      = ['toc-level', 'split', 'width', 'height']
    2634. 

  2634. 		self.multi        = ['infile', 'preproc', 'postproc', 'options', 'style']
    2635. 

  2635. 	
    2636. 

  2636. 	def _get_defaults(self):
    2637. 

  2637. 		"Get the default values for all config/options/flags"
    2638. 

  2638. 		empty = {}
    2639. 

  2639. 		for kw in CONFIG_KEYWORDS: empty[kw] = ''
    2640. 

  2640. 		empty.update(self.dft_options)
    2641. 

  2641. 		empty.update(self.dft_flags)
    2642. 

  2642. 		empty.update(self.dft_actions)
    2643. 

  2643. 		empty.update(self.dft_settings)
    2644. 

  2644. 		empty['realcmdline'] = ''  # internal use only
    2645. 

  2645. 		empty['sourcefile']  = ''  # internal use only
    2646. 

  2646. 		return empty
    2647. 

  2647. 	
    2648. 

  2648. 	def _get_off(self):
    2649. 

  2649. 		"Turns OFF all the config/options/flags"
    2650. 

  2650. 		off = {}
    2651. 

  2651. 		for key in self.defaults.keys():
    2652. 

  2652. 			kind = type(self.defaults[key])
    2653. 

  2653. 			if kind == type(9):
    2654. 

  2654. 				off[key] = 0
    2655. 

  2655. 			elif kind == type('') or kind == type(u''):
    2656. 

  2656. 				off[key] = ''
    2657. 

  2657. 			elif kind == type([]):
    2658. 

  2658. 				off[key] = []
    2659. 

  2659. 			else:
    2660. 

  2660. 				Error('ConfigMaster: %s: Unknown type' % key)
    2661. 

  2661. 		return off
    2662. 

  2662. 	
    2663. 

  2663. 	def _check_target(self):
    2664. 

  2664. 		"Checks if the target is already defined. If not, do it"
    2665. 

  2665. 		if not self.target:
    2666. 

  2666. 			self.target = self.find_value('target')
    2667. 

  2667. 	
    2668. 

  2668. 	def get_target_raw(self):
    2669. 

  2669. 		"Returns the raw config for self.target or 'all'"
    2670. 

  2670. 		ret = []
    2671. 

  2671. 		self._check_target()
    2672. 

  2672. 		for entry in self.raw:
    2673. 

  2673. 			if entry[0] == self.target or entry[0] == 'all':
    2674. 

  2674. 				ret.append(entry)
    2675. 

  2675. 		return ret
    2676. 

  2676. 	
    2677. 

  2677. 	def add(self, key, val):
    2678. 

  2678. 		"Adds the key:value pair to the config dictionary (if needed)"
    2679. 

  2679. 		# %!options
    2680. 

  2680. 		if key == 'options':
    2681. 

  2681. 			ignoreme = self.dft_actions.keys() + ['target']
    2682. 

  2682. 			ignoreme.remove('dump-config')
    2683. 

  2683. 			ignoreme.remove('dump-source')
    2684. 

  2684. 			ignoreme.remove('targets')
    2685. 

  2685. 			raw_opts = CommandLine().get_raw_config(
    2686. 

  2686. 				val, ignore=ignoreme)
    2687. 

  2687. 			for target, key, val in raw_opts:
    2688. 

  2688. 				self.add(key, val)
    2689. 

  2689. 			return
    2690. 

  2690. 		# The no- prefix turns OFF this key
    2691. 

  2691. 		if key.startswith('no-'):
    2692. 

  2692. 			key = key[3:]              # remove prefix
    2693. 

  2693. 			val = self.off.get(key)    # turn key OFF
    2694. 

  2694. 		# Is this key valid?
    2695. 

  2695. 		if key not in self.defaults.keys():
    2696. 

  2696. 			Debug('Bogus Config %s:%s'%(key,val),1)
    2697. 

  2697. 			return
    2698. 

  2698. 		# Is this value the default one?
    2699. 

  2699. 		if val == self.defaults.get(key):
    2700. 

  2700. 			# If default value, remove previous key:val
    2701. 

  2701. 			if self.parsed.has_key(key):
    2702. 

  2702. 				del self.parsed[key]
    2703. 

  2703. 			# Nothing more to do
    2704. 

  2704. 			return
    2705. 

  2705. 		# Flags ON comes empty. we'll add the 1 value now
    2706. 

  2706. 		if val == '' and (
    2707. 

  2707. 		   key in self.dft_flags.keys() or
    2708. 

  2708. 		   key in self.dft_actions.keys()):
    2709. 

  2709. 			val = 1
    2710. 

  2710. 		# Multi value or single?
    2711. 

  2711. 		if key in self.multi:
    2712. 

  2712. 			# First one? start new list
    2713. 

  2713. 			if not self.parsed.has_key(key):
    2714. 

  2714. 				self.parsed[key] = []
    2715. 

  2715. 			self.parsed[key].append(val)
    2716. 

  2716. 		# Incremental value? so let's add it
    2717. 

  2717. 		elif key in self.incremental:
    2718. 

  2718. 			self.parsed[key] = (self.parsed.get(key) or 0) + val
    2719. 

  2719. 		else:
    2720. 

  2720. 			self.parsed[key] = val
    2721. 

  2721. 		fancykey = dotted_spaces("%12s"%key)
    2722. 

  2722. 		Message(_("Added config %s : %s")%(fancykey,val),3)
    2723. 

  2723. 	
    2724. 

  2724. 	def get_outfile_name(self, config={}):
    2725. 

  2725. 		"Dirname is the same for {in,out}file"
    2726. 

  2726. 		infile, outfile = config['sourcefile'], config['outfile']
    2727. 

  2727. 		if outfile and outfile not in (STDOUT, MODULEOUT) \
    2728. 

  2728. 		   and not os.path.isabs(outfile):
    2729. 

  2729. 			outfile = os.path.join(os.path.dirname(infile), outfile)
    2730. 

  2730. 		if infile == STDIN    and not outfile: outfile = STDOUT
    2731. 

  2731. 		if infile == MODULEIN and not outfile: outfile = MODULEOUT
    2732. 

  2732. 		if not outfile and (infile and config.get('target')):
    2733. 

  2733. 			basename = re.sub('\.(txt|t2t)$','',infile)
    2734. 

  2734. 			outfile = "%s.%s"%(basename, config['target'])
    2735. 

  2735. 		Debug(" infile: '%s'"%infile , 1)
    2736. 

  2736. 		Debug("outfile: '%s'"%outfile, 1)
    2737. 

  2737. 		return outfile
    2738. 

  2738. 	
    2739. 

  2739. 	def sanity(self, config, gui=0):
    2740. 

  2740. 		"Basic config sanity checking"
    2741. 

  2741. 		global AA
    2742. 

  2742. 		if not config: return {}
    2743. 

  2743. 		target = config.get('target')
    2744. 

  2744. 		# Some actions don't require target specification
    2745. 

  2745. 		if not target:
    2746. 

  2746. 			for action in NO_TARGET:
    2747. 

  2747. 				if config.get(action):
    2748. 

  2748. 					target = 'txt'
    2749. 

  2749. 					break
    2750. 

  2750. 		# On GUI, some checking are skipped
    2751. 

  2751. 		if not gui:
    2752. 

  2752. 			# We *need* a target
    2753. 

  2753. 			if not target:
    2754. 

  2754. 				Error(_('No target specified (try --help)') + '\n\n' +
    2755. 

  2755. 				_('Please inform a target using the -t option or the %!target command.') + '\n' +
    2756. 

  2756. 				_('Example:') + ' %s -t html %s' % (my_name, _('file.t2t')) + '\n\n' +
    2757. 

  2757. 				_("Run 'txt2tags --targets' to see all the available targets."))
    2758. 

  2758. 			# And of course, an infile also
    2759. 

  2759. 			# TODO#1: It seems that this checking is never reached
    2760. 

  2760. 			if not config.get('infile'):
    2761. 

  2761. 				Error(_('Missing input file (try --help)'))
    2762. 

  2762. 			# Is the target valid?
    2763. 

  2763. 			if not TARGETS.count(target):
    2764. 

  2764. 				Error(_("Invalid target '%s'") % target + '\n\n' +
    2765. 

  2765. 				_("Run 'txt2tags --targets' to see all the available targets."))
    2766. 

  2766. 		# Ensure all keys are present
    2767. 

  2767. 		empty = self.defaults.copy() ; empty.update(config)
    2768. 

  2768. 		config = empty.copy()
    2769. 

  2769. 		# Check integers options
    2770. 

  2770. 		for key in config.keys():
    2771. 

  2771. 			if key in self.numeric:
    2772. 

  2772. 				try:
    2773. 

  2773. 					config[key] = int(config[key])
    2774. 

  2774. 				except ValueError:
    2775. 

  2775. 					Error(_('--%s value must be a number') % key)
    2776. 

  2776. 		# Check split level value
    2777. 

  2777. 		if config['split'] not in (0,1,2):
    2778. 

  2778. 			Error(_('Option --split must be 0, 1 or 2'))
    2779. 

  2779. 		# Slides needs width and height
    2780. 

  2780. 		if config['slides'] and target == 'art':
    2781. 

  2781. 			if not config['width']:
    2782. 

  2782. 				config['width'] = DFT_SLIDE_WIDTH
    2783. 

  2783. 			if not config['height']:
    2784. 

  2784. 				config['height'] = DFT_SLIDE_HEIGHT
    2785. 

  2785. 		# ASCII Art needs a width
    2786. 

  2786. 		if target == 'art' and not config['width']:
    2787. 

  2787. 			config['width'] = DFT_TEXT_WIDTH
    2788. 

  2788. 		# Check/set user ASCII Art formatting characters
    2789. 

  2789. 		if config['art-chars']:
    2790. 

  2790. 			if len(config['art-chars']) != len(AA_VALUES):
    2791. 

  2791. 				Error(_("--art-chars: Expected %i chars, got %i") % (
    2792. 

  2792. 					len(AA_VALUES), len(config['art-chars'])))
    2793. 

  2793. 			else:
    2794. 

  2794. 				AA = dict(zip(AA_KEYS, config['art-chars']))
    2795. 

  2795. 		# --toc-only is stronger than others
    2796. 

  2796. 		if config['toc-only']:
    2797. 

  2797. 			config['headers'] = 0
    2798. 

  2798. 			config['toc']     = 0
    2799. 

  2799. 			config['split']   = 0
    2800. 

  2800. 			config['gui']     = 0
    2801. 

  2801. 			config['outfile'] = config['outfile'] or STDOUT
    2802. 

  2802. 		# Splitting is disable for now (future: HTML only, no STDOUT)
    2803. 

  2803. 		config['split'] = 0
    2804. 

  2804. 		# Restore target
    2805. 

  2805. 		config['target'] = target
    2806. 

  2806. 		# Set output file name
    2807. 

  2807. 		config['outfile'] = self.get_outfile_name(config)
    2808. 

  2808. 		# Checking suicide
    2809. 

  2809. 		if config['sourcefile'] == config['outfile'] and \
    2810. 

  2810. 		   config['outfile'] not in [STDOUT,MODULEOUT] and not gui:
    2811. 

  2811. 			Error(_("Input and Output files are the same: %s") % config['outfile'])
    2812. 

  2812. 		return config
    2813. 

  2813. 	
    2814. 

  2814. 	def parse(self):
    2815. 

  2815. 		"Returns the parsed config for the current target"
    2816. 

  2816. 		raw = self.get_target_raw()
    2817. 

  2817. 		for target, key, value in raw:
    2818. 

  2818. 			self.add(key, value)
    2819. 

  2819. 		Message(_("Added the following keys: %s") % ', '.join(self.parsed.keys()), 2)
    2820. 

  2820. 		return self.parsed.copy()
    2821. 

  2821. 	
    2822. 

  2822. 	def find_value(self, key='', target=''):
    2823. 

  2823. 		"Scans ALL raw config to find the desired key"
    2824. 

  2824. 		ret = []
    2825. 

  2825. 		# Scan and save all values found
    2826. 

  2826. 		for targ, k, val in self.raw:
    2827. 

  2827. 			if k == key and (targ == target or targ == 'all'):
    2828. 

  2828. 				ret.append(val)
    2829. 

  2829. 		if not ret: return ''
    2830. 

  2830. 		# If not multi value, return only the last found
    2831. 

  2831. 		if key in self.multi: return ret
    2832. 

  2832. 		else                : return ret[-1]
    2833. 

  2833. 

  2834. ########################################################################
    2835. 

  2835. 

  2836. class ConfigLines:
    2837. 

  2837. 	"""
    2838. 

  2838. 	ConfigLines class - the config file data extractor
    2839. 

  2839. 	
    2840. 

  2840. 	This class reads and parse the config lines on the %!key:val
    2841. 

  2841. 	format, converting it to RAW config. It deals with user
    2842. 

  2842. 	config file (RC file), source document CONF area and
    2843. 

  2843. 	%!includeconf directives.
    2844. 

  2844. 

  2845. 	Call it passing a file name or feed the desired config lines.
    2846. 

  2846. 	Then just call the get_raw_config() method and wait to
    2847. 

  2847. 	receive the full config data on the RAW format. This method
    2848. 

  2848. 	also follows the possible %!includeconf directives found on
    2849. 

  2849. 	the config lines. Example:
    2850. 

  2850. 

  2851. 		raw = ConfigLines(file=".txt2tagsrc").get_raw_config()
    2852. 

  2852. 

  2853. 	The parse_line() method is also useful to be used alone,
    2854. 

  2854. 	to identify and tokenize a single config line. For example,
    2855. 

  2855. 	to get the %!include command components, on the source
    2856. 

  2856. 	document BODY:
    2857. 

  2857. 	
    2858. 

  2858. 		target, key, value = ConfigLines().parse_line(body_line)
    2859. 

  2859. 	"""
    2860. 

  2860. 	def __init__(self, file_='', lines=[], first_line=1):
    2861. 

  2861. 		self.file = file_ or 'NOFILE'
    2862. 

  2862. 		self.lines = lines
    2863. 

  2863. 		self.first_line = first_line
    2864. 

  2864. 	
    2865. 

  2865. 	def load_lines(self):
    2866. 

  2866. 		"Make sure we've loaded the file contents into buffer"
    2867. 

  2867. 		if not self.lines and not self.file:
    2868. 

  2868. 			Error("ConfigLines: No file or lines provided")
    2869. 

  2869. 		if not self.lines:
    2870. 

  2870. 			self.lines = self.read_config_file(self.file)
    2871. 

  2871. 	
    2872. 

  2872. 	def read_config_file(self, filename=''):
    2873. 

  2873. 		"Read a Config File contents, aborting on invalid line"
    2874. 

  2874. 		if not filename: return []
    2875. 

  2875. 		errormsg = _("Invalid CONFIG line on %s")+"\n%03d:%s"
    2876. 

  2876. 		lines = Readfile(filename, remove_linebreaks=1)
    2877. 

  2877. 		# Sanity: try to find invalid config lines
    2878. 

  2878. 		for i in xrange(len(lines)):
    2879. 

  2879. 			line = lines[i].rstrip()
    2880. 

  2880. 			if not line: continue  # empty
    2881. 

  2881. 			if line[0] != '%': Error(errormsg%(filename,i+1,line))
    2882. 

  2882. 		return lines
    2883. 

  2883. 	
    2884. 

  2884. 	def include_config_file(self, file_=''):
    2885. 

  2885. 		"Perform the %!includeconf action, returning RAW config"
    2886. 

  2886. 		if not file_: return []
    2887. 

  2887. 		# Current dir relative to the current file (self.file)
    2888. 

  2888. 		current_dir = os.path.dirname(self.file)
    2889. 

  2889. 		file_ = os.path.join(current_dir, file_)
    2890. 

  2890. 		# Read and parse included config file contents
    2891. 

  2891. 		lines = self.read_config_file(file_)
    2892. 

  2892. 		return ConfigLines(file_=file_, lines=lines).get_raw_config()
    2893. 

  2893. 	
    2894. 

  2894. 	def get_raw_config(self):
    2895. 

  2895. 		"Scan buffer and extract all config as RAW (including includes)"
    2896. 

  2896. 		ret = []
    2897. 

  2897. 		self.load_lines()
    2898. 

  2898. 		first = self.first_line
    2899. 

  2899. 		for i in xrange(len(self.lines)):
    2900. 

  2900. 			line = self.lines[i]
    2901. 

  2901. 			Message(_("Processing line %03d: %s")%(first+i,line),2)
    2902. 

  2902. 			target, key, val = self.parse_line(line)
    2903. 

  2903. 			if not key: continue    # no config on this line
    2904. 

  2904. 			if key == 'includeconf':
    2905. 

  2905. 				err = _('A file cannot include itself (loop!)')
    2906. 

  2906. 				if val == self.file:
    2907. 

  2907. 					Error("%s: %%!includeconf: %s" % (err, self.file))
    2908. 

  2908. 				more_raw = self.include_config_file(val)
    2909. 

  2909. 				ret.extend(more_raw)
    2910. 

  2910. 				Message(_("Finished Config file inclusion: %s") % val, 2)
    2911. 

  2911. 			else:
    2912. 

  2912. 				ret.append([target, key, val])
    2913. 

  2913. 				Message(_("Added %s")%key,3)
    2914. 

  2914. 		return ret
    2915. 

  2915. 	
    2916. 

  2916. 	def parse_line(self, line='', keyname='', target=''):
    2917. 

  2917. 		"Detects %!key:val config lines and extract data from it"
    2918. 

  2918. 		empty = ['', '', '']
    2919. 

  2919. 		if not line: return empty
    2920. 

  2920. 		no_target = ['target', 'includeconf']
    2921. 

  2921. 		re_name   = keyname or '[a-z]+'
    2922. 

  2922. 		re_target = target  or '[a-z]*'
    2923. 

  2923. 		# XXX TODO <value>\S.+?  requires TWO chars, breaks %!include:a
    2924. 

  2924. 		cfgregex  = re.compile("""
    2925. 

  2925. 			^%%!\s*               # leading id with opt spaces
    2926. 

  2926. 			(?P<name>%s)\s*       # config name
    2927. 

  2927. 			(\((?P<target>%s)\))? # optional target spec inside ()
    2928. 

  2928. 			\s*:\s*               # key:value delimiter with opt spaces
    2929. 

  2929. 			(?P<value>\S.+?)      # config value
    2930. 

  2930. 			\s*$                  # rstrip() spaces and hit EOL
    2931. 

  2931. 			"""%(re_name, re_target), re.I+re.VERBOSE)
    2932. 

  2932. 		prepostregex = re.compile("""
    2933. 

  2933. 		                              # ---[ PATTERN ]---
    2934. 

  2934. 			^( "([^"]*)"          # "double quoted" or
    2935. 

  2935. 			| '([^']*)'           # 'single quoted' or
    2936. 

  2936. 			| ([^\s]+)            # single_word
    2937. 

  2937. 			)
    2938. 

  2938. 			\s+                   # separated by spaces
    2939. 

  2939. 		
    2940. 

  2940. 		                              # ---[ REPLACE ]---
    2941. 

  2941. 			( "([^"]*)"           # "double quoted" or
    2942. 

  2942. 			| '([^']*)'           # 'single quoted' or
    2943. 

  2943. 			| (.*)                # anything
    2944. 

  2944. 			)
    2945. 

  2945. 			\s*$
    2946. 

  2946. 			""", re.VERBOSE)
    2947. 

  2947. 		guicolors = re.compile("^([^\s]+\s+){3}[^\s]+") # 4 tokens
    2948. 

  2948. 		
    2949. 

  2949. 		# Give me a match or get out
    2950. 

  2950. 		match = cfgregex.match(line)
    2951. 

  2951. 		if not match: return empty
    2952. 

  2952. 		
    2953. 

  2953. 		# Save information about this config
    2954. 

  2954. 		name   = (match.group('name') or '').lower()
    2955. 

  2955. 		target = (match.group('target') or 'all').lower()
    2956. 

  2956. 		value  = match.group('value')
    2957. 

  2957. 		
    2958. 

  2958. 		# %!keyword(target) not allowed for these
    2959. 

  2959. 		if name in no_target and match.group('target'):
    2960. 

  2960. 			Error(
    2961. 

  2961. 				_("You can't use (target) with %s") % ('%!' + name)
    2962. 

  2962. 				+ "\n%s" % line)
    2963. 

  2963. 		
    2964. 

  2964. 		# Force no_target keywords to be valid for all targets
    2965. 

  2965. 		if name in no_target:
    2966. 

  2966. 			target = 'all'
    2967. 

  2967. 		
    2968. 

  2968. 		# Special config for GUI colors
    2969. 

  2969. 		if name == 'guicolors':
    2970. 

  2970. 			valmatch = guicolors.search(value)
    2971. 

  2971. 			if not valmatch: return empty
    2972. 

  2972. 			value = re.split('\s+', value)
    2973. 

  2973. 		
    2974. 

  2974. 		# Special config with two quoted values (%!preproc: "foo" 'bar')
    2975. 

  2975. 		if name == 'preproc' or name == 'postproc':
    2976. 

  2976. 			valmatch = prepostregex.search(value)
    2977. 

  2977. 			if not valmatch: return empty
    2978. 

  2978. 			getval = valmatch.group
    2979. 

  2979. 			patt   = getval(2) or getval(3) or getval(4) or ''
    2980. 

  2980. 			repl   = getval(6) or getval(7) or getval(8) or ''
    2981. 

  2981. 			value  = (patt, repl)
    2982. 

  2982. 		return [target, name, value]
    2983. 

  2983. 

  2984. ##############################################################################
    2985. 

  2985. 

  2986. class MaskMaster:
    2987. 

  2987. 	"(Un)Protect important structures from escaping and formatting"
    2988. 

  2988. 	def __init__(self):
    2989. 

  2989. 		self.linkmask  = 'vvvLINKvvv'
    2990. 

  2990. 		self.monomask  = 'vvvMONOvvv'
    2991. 

  2991. 		self.macromask = 'vvvMACROvvv'
    2992. 

  2992. 		self.rawmask   = 'vvvRAWvvv'
    2993. 

  2993. 		self.taggedmask= 'vvvTAGGEDvvv'
    2994. 

  2994. 		self.tocmask   = 'vvvTOCvvv'
    2995. 

  2995. 		self.macroman  = MacroMaster()
    2996. 

  2996. 		self.reset()
    2997. 

  2997. 	
    2998. 

  2998. 	def reset(self):
    2999. 

  2999. 		self.linkbank = []
    3000. 

  3000. 		self.monobank = []
    3001. 

  3001. 		self.macrobank = []
    3002. 

  3002. 		self.rawbank = []
    3003. 

  3003. 		self.taggedbank = []
    3004. 

  3004. 	
    3005. 

  3005. 	def mask(self, line=''):
    3006. 

  3006. 		global AUTOTOC
    3007. 

  3007. 

  3008. 		# The verbatim, raw and tagged inline marks are mutually exclusive.
    3009. 

  3009. 		# This means that one can't appear inside the other.
    3010. 

  3010. 		# If found, the inner marks must be ignored.
    3011. 

  3011. 		# Example: ``foo ""bar"" ''baz''``
    3012. 

  3012. 		# In HTML: <code>foo ""bar"" ''baz''</code>
    3013. 

  3013. 		#
    3014. 

  3014. 		# The trick here is to protect the mark who appears first on the line.
    3015. 

  3015. 		# The three regexes are tried and the one with the lowest index wins.
    3016. 

  3016. 		# If none is found (else), we get out of the loop.
    3017. 

  3017. 		#
    3018. 

  3018. 		while True:
    3019. 

  3019. 			
    3020. 

  3020. 			# Try to match the line for the three marks
    3021. 

  3021. 			# Note: 'z' > 999999
    3022. 

  3022. 			#
    3023. 

  3023. 			t = r = v = 'z'
    3024. 

  3024. 			try: t = regex['tagged'].search(line).start()
    3025. 

  3025. 			except: pass
    3026. 

  3026. 			try: r = regex['raw'].search(line).start()
    3027. 

  3027. 			except: pass
    3028. 

  3028. 			try: v = regex['fontMono'].search(line).start()
    3029. 

  3029. 			except: pass
    3030. 

  3030. 

  3031. 			# Protect tagged text
    3032. 

  3032. 			if t >= 0 and t < r and t < v:
    3033. 

  3033. 				txt = regex['tagged'].search(line).group(1)
    3034. 

  3034. 				self.taggedbank.append(txt)
    3035. 

  3035. 				line = regex['tagged'].sub(self.taggedmask,line,1)
    3036. 

  3036. 

  3037. 			# Protect raw text
    3038. 

  3038. 			elif r >= 0 and r < t and r < v:
    3039. 

  3039. 				txt = regex['raw'].search(line).group(1)
    3040. 

  3040. 				txt = doEscape(TARGET,txt)
    3041. 

  3041. 				self.rawbank.append(txt)
    3042. 

  3042. 				line = regex['raw'].sub(self.rawmask,line,1)
    3043. 

  3043. 

  3044. 			# Protect verbatim text
    3045. 

  3045. 			elif v >= 0 and v < t and v < r:
    3046. 

  3046. 				txt = regex['fontMono'].search(line).group(1)
    3047. 

  3047. 				txt = doEscape(TARGET,txt)
    3048. 

  3048. 				self.monobank.append(txt)
    3049. 

  3049. 				line = regex['fontMono'].sub(self.monomask,line,1)
    3050. 

  3050. 			else:
    3051. 

  3051. 				break
    3052. 

  3052. 			
    3053. 

  3053. 		# Protect macros
    3054. 

  3054. 		while regex['macros'].search(line):
    3055. 

  3055. 			txt = regex['macros'].search(line).group()
    3056. 

  3056. 			self.macrobank.append(txt)
    3057. 

  3057. 			line = regex['macros'].sub(self.macromask,line,1)
    3058. 

  3058. 		
    3059. 

  3059. 		# Protect TOC location
    3060. 

  3060. 		while regex['toc'].search(line):
    3061. 

  3061. 			line = regex['toc'].sub(self.tocmask,line)
    3062. 

  3062. 			AUTOTOC = 0
    3063. 

  3063. 		
    3064. 

  3064. 		# Protect URLs and emails
    3065. 

  3065. 		while regex['linkmark'].search(line) or \
    3066. 

  3066. 		      regex['link'    ].search(line):
    3067. 

  3067. 			
    3068. 

  3068. 			# Try to match plain or named links
    3069. 

  3069. 			match_link  = regex['link'].search(line)
    3070. 

  3070. 			match_named = regex['linkmark'].search(line)
    3071. 

  3071. 			
    3072. 

  3072. 			# Define the current match
    3073. 

  3073. 			if match_link and match_named:
    3074. 

  3074. 				# Both types found, which is the first?
    3075. 

  3075. 				m = match_link
    3076. 

  3076. 				if match_named.start() < match_link.start():
    3077. 

  3077. 					m = match_named
    3078. 

  3078. 			else:
    3079. 

  3079. 				# Just one type found, we're fine
    3080. 

  3080. 				m = match_link or match_named
    3081. 

  3081. 			
    3082. 

  3082. 			# Extract link data and apply mask
    3083. 

  3083. 			if m == match_link:              # plain link
    3084. 

  3084. 				link = m.group()
    3085. 

  3085. 				label = ''
    3086. 

  3086. 				link_re = regex['link']
    3087. 

  3087. 			else:                            # named link
    3088. 

  3088. 				link = m.group('link')
    3089. 

  3089. 				label = m.group('label').rstrip()
    3090. 

  3090. 				link_re = regex['linkmark']
    3091. 

  3091. 			line = link_re.sub(self.linkmask,line,1)
    3092. 

  3092. 			
    3093. 

  3093. 			# Save link data to the link bank
    3094. 

  3094. 			self.linkbank.append((label, link))
    3095. 

  3095. 		return line
    3096. 

  3096. 	
    3097. 

  3097. 	def undo(self, line):
    3098. 

  3098. 		
    3099. 

  3099. 		# url & email
    3100. 

  3100. 		for label,url in self.linkbank:
    3101. 

  3101. 			link = get_tagged_link(label, url)
    3102. 

  3102. 			line = line.replace(self.linkmask, link, 1)
    3103. 

  3103. 		
    3104. 

  3104. 		# Expand macros
    3105. 

  3105. 		for macro in self.macrobank:
    3106. 

  3106. 			macro = self.macroman.expand(macro)
    3107. 

  3107. 			line = line.replace(self.macromask, macro, 1)
    3108. 

  3108. 		
    3109. 

  3109. 		# Expand verb
    3110. 

  3110. 		for mono in self.monobank:
    3111. 

  3111. 			open_,close = TAGS['fontMonoOpen'],TAGS['fontMonoClose']
    3112. 

  3112. 			line = line.replace(self.monomask, open_+mono+close, 1)
    3113. 

  3113. 		
    3114. 

  3114. 		# Expand raw
    3115. 

  3115. 		for raw in self.rawbank:
    3116. 

  3116. 			line = line.replace(self.rawmask, raw, 1)
    3117. 

  3117. 

  3118. 		# Expand tagged
    3119. 

  3119. 		for tagged in self.taggedbank:
    3120. 

  3120. 			line = line.replace(self.taggedmask, tagged, 1)
    3121. 

  3121. 		
    3122. 

  3122. 		return line
    3123. 

  3123. 

  3124. 

  3125. ##############################################################################
    3126. 

  3126. 

  3127. 

  3128. class TitleMaster:
    3129. 

  3129. 	"Title things"
    3130. 

  3130. 	def __init__(self):
    3131. 

  3131. 		self.count = ['',0,0,0,0,0]
    3132. 

  3132. 		self.toc   = []
    3133. 

  3133. 		self.level = 0
    3134. 

  3134. 		self.kind  = ''
    3135. 

  3135. 		self.txt   = ''
    3136. 

  3136. 		self.label = ''
    3137. 

  3137. 		self.tag   = ''
    3138. 

  3138. 		self.tag_hold = []
    3139. 

  3139. 		self.last_level = 0
    3140. 

  3140. 		self.count_id = ''
    3141. 

  3141. 		self.user_labels = {}
    3142. 

  3142. 		self.anchor_count = 0
    3143. 

  3143. 		self.anchor_prefix = 'toc'
    3144. 

  3144. 	
    3145. 

  3145. 	def _open_close_blocks(self):
    3146. 

  3146. 		"Open new title blocks, closing the previous (if any)"
    3147. 

  3147. 		if not rules['titleblocks']: return
    3148. 

  3148. 		tag = ''
    3149. 

  3149. 		last = self.last_level
    3150. 

  3150. 		curr = self.level
    3151. 

  3151. 		
    3152. 

  3152. 		# Same level, just close the previous
    3153. 

  3153. 		if curr == last:
    3154. 

  3154. 			tag = TAGS.get('title%dClose'%last)
    3155. 

  3155. 			if tag: self.tag_hold.append(tag)
    3156. 

  3156. 		
    3157. 

  3157. 		# Section -> subsection, more depth
    3158. 

  3158. 		while curr > last:
    3159. 

  3159. 			last += 1
    3160. 

  3160. 			
    3161. 

  3161. 			# Open the new block of subsections
    3162. 

  3162. 			tag = TAGS.get('blockTitle%dOpen'%last)
    3163. 

  3163. 			if tag: self.tag_hold.append(tag)
    3164. 

  3164. 			
    3165. 

  3165. 			# Jump from title1 to title3 or more
    3166. 

  3166. 			# Fill the gap with an empty section
    3167. 

  3167. 			if curr - last > 0:
    3168. 

  3168. 				tag = TAGS.get('title%dOpen'%last)
    3169. 

  3169. 				tag = regex['x'].sub('', tag)      # del \a
    3170. 

  3170. 				if tag: self.tag_hold.append(tag)
    3171. 

  3171. 		
    3172. 

  3172. 		# Section <- subsection, less depth
    3173. 

  3173. 		while curr < last:
    3174. 

  3174. 			# Close the current opened subsection
    3175. 

  3175. 			tag = TAGS.get('title%dClose'%last)
    3176. 

  3176. 			if tag: self.tag_hold.append(tag)
    3177. 

  3177. 			
    3178. 

  3178. 			# Close the current opened block of subsections
    3179. 

  3179. 			tag = TAGS.get('blockTitle%dClose'%last)
    3180. 

  3180. 			if tag: self.tag_hold.append(tag)
    3181. 

  3181. 			
    3182. 

  3182. 			last -= 1
    3183. 

  3183. 			
    3184. 

  3184. 			# Close the previous section of the same level
    3185. 

  3185. 			# The subsections were under it
    3186. 

  3186. 			if curr == last:
    3187. 

  3187. 				tag = TAGS.get('title%dClose'%last)
    3188. 

  3188. 				if tag: self.tag_hold.append(tag)
    3189. 

  3189. 	
    3190. 

  3190. 	def add(self, line):
    3191. 

  3191. 		"Parses a new title line."
    3192. 

  3192. 		if not line: return
    3193. 

  3193. 		self._set_prop(line)
    3194. 

  3194. 		self._open_close_blocks()
    3195. 

  3195. 		self._set_count_id()
    3196. 

  3196. 		self._set_label()
    3197. 

  3197. 		self._save_toc_info()
    3198. 

  3198. 	
    3199. 

  3199. 	def close_all(self):
    3200. 

  3200. 		"Closes all opened title blocks"
    3201. 

  3201. 		ret = []
    3202. 

  3202. 		ret.extend(self.tag_hold)
    3203. 

  3203. 		while self.level:
    3204. 

  3204. 			tag = TAGS.get('title%dClose'%self.level)
    3205. 

  3205. 			if tag: ret.append(tag)
    3206. 

  3206. 			tag = TAGS.get('blockTitle%dClose'%self.level)
    3207. 

  3207. 			if tag: ret.append(tag)
    3208. 

  3208. 			self.level -= 1
    3209. 

  3209. 		return ret
    3210. 

  3210. 	
    3211. 

  3211. 	def _save_toc_info(self):
    3212. 

  3212. 		"Save TOC info, used by self.dump_marked_toc()"
    3213. 

  3213. 		self.toc.append((self.level, self.count_id, self.txt, self.label))
    3214. 

  3214. 	
    3215. 

  3215. 	def _set_prop(self, line=''):
    3216. 

  3216. 		"Extract info from original line and set data holders."
    3217. 

  3217. 		# Detect title type (numbered or not)
    3218. 

  3218. 		id_ = line.lstrip()[0]
    3219. 

  3219. 		if   id_ == '=': kind = 'title'
    3220. 

  3220. 		elif id_ == '+': kind = 'numtitle'
    3221. 

  3221. 		else: Error("Unknown Title ID '%s'"%id_)
    3222. 

  3222. 		# Extract line info
    3223. 

  3223. 		match = regex[kind].search(line)
    3224. 

  3224. 		level = len(match.group('id'))
    3225. 

  3225. 		txt   = match.group('txt').strip()
    3226. 

  3226. 		label = match.group('label')
    3227. 

  3227. 		# Parse info & save
    3228. 

  3228. 		if CONF['enum-title']: kind = 'numtitle'  # force
    3229. 

  3229. 		if rules['titleblocks']:
    3230. 

  3230. 			self.tag = TAGS.get('%s%dOpen'%(kind,level)) or \
    3231. 

  3231. 			           TAGS.get('title%dOpen'%level)
    3232. 

  3232. 		else:
    3233. 

  3233. 			self.tag = TAGS.get(kind+`level`) or \
    3234. 

  3234. 			           TAGS.get('title'+`level`)
    3235. 

  3235. 		self.last_level = self.level
    3236. 

  3236. 		self.kind  = kind
    3237. 

  3237. 		self.level = level
    3238. 

  3238. 		self.txt   = txt
    3239. 

  3239. 		self.label = label
    3240. 

  3240. 	
    3241. 

  3241. 	def _set_count_id(self):
    3242. 

  3242. 		"Compose and save the title count identifier (if needed)."
    3243. 

  3243. 		count_id = ''
    3244. 

  3244. 		if self.kind == 'numtitle' and not rules['autonumbertitle']:
    3245. 

  3245. 			# Manually increase title count
    3246. 

  3246. 			self.count[self.level] += 1
    3247. 

  3247. 			# Reset sublevels count (if any)
    3248. 

  3248. 			max_levels = len(self.count)
    3249. 

  3249. 			if self.level < max_levels-1:
    3250. 

  3250. 				for i in xrange(self.level+1, max_levels):
    3251. 

  3251. 					self.count[i] = 0
    3252. 

  3252. 			# Compose count id from hierarchy
    3253. 

  3253. 			for i in xrange(self.level):
    3254. 

  3254. 				count_id= "%s%d."%(count_id, self.count[i+1])
    3255. 

  3255. 		self.count_id = count_id
    3256. 

  3256. 	
    3257. 

  3257. 	def _set_label(self):
    3258. 

  3258. 		"Compose and save title label, used by anchors."
    3259. 

  3259. 		# Remove invalid chars from label set by user
    3260. 

  3260. 		self.label = re.sub('[^A-Za-z0-9_-]', '', self.label or '')
    3261. 

  3261. 		# Generate name as 15 first :alnum: chars
    3262. 

  3262. 		#TODO how to translate safely accented chars to plain?
    3263. 

  3263. 		#self.label = re.sub('[^A-Za-z0-9]', '', self.txt)[:15]
    3264. 

  3264. 		# 'tocN' label - sequential count, ignoring 'toc-level'
    3265. 

  3265. 		#self.label = self.anchor_prefix + str(len(self.toc)+1)
    3266. 

  3266. 	
    3267. 

  3267. 	def _get_tagged_anchor(self):
    3268. 

  3268. 		"Return anchor if user defined a label, or TOC is on."
    3269. 

  3269. 		ret = ''
    3270. 

  3270. 		label = self.label
    3271. 

  3271. 		if CONF['toc'] and self.level <= CONF['toc-level']:
    3272. 

  3272. 			# This count is needed bcos self.toc stores all
    3273. 

  3273. 			# titles, regardless of the 'toc-level' setting,
    3274. 

  3274. 			# so we can't use self.toc length to number anchors
    3275. 

  3275. 			self.anchor_count += 1
    3276. 

  3276. 			# Autonumber label (if needed)
    3277. 

  3277. 			label = label or '%s%s' % (self.anchor_prefix, self.anchor_count)
    3278. 

  3278. 		if label and TAGS['anchor']:
    3279. 

  3279. 			ret = regex['x'].sub(label,TAGS['anchor'])
    3280. 

  3280. 		return ret
    3281. 

  3281. 	
    3282. 

  3282. 	def _get_full_title_text(self):
    3283. 

  3283. 		"Returns the full title contents, already escaped."
    3284. 

  3284. 		ret = self.txt
    3285. 

  3285. 		# Insert count_id (if any) before text
    3286. 

  3286. 		if self.count_id:
    3287. 

  3287. 			ret = '%s %s'%(self.count_id, ret)
    3288. 

  3288. 		# Escape specials
    3289. 

  3289. 		ret = doEscape(TARGET, ret)
    3290. 

  3290. 		# Same targets needs final escapes on title lines
    3291. 

  3291. 		# It's here because there is a 'continue' after title
    3292. 

  3292. 		if rules['finalescapetitle']:
    3293. 

  3293. 			ret = doFinalEscape(TARGET, ret)
    3294. 

  3294. 		return ret
    3295. 

  3295. 	
    3296. 

  3296. 	def get(self):
    3297. 

  3297. 		"Returns the tagged title as a list."
    3298. 

  3298. 		global AA_TITLE
    3299. 

  3299. 		ret = []
    3300. 

  3300. 		
    3301. 

  3301. 		# Maybe some anchoring before?
    3302. 

  3302. 		anchor = self._get_tagged_anchor()
    3303. 

  3303. 		self.tag = regex['_anchor'].sub(anchor, self.tag)
    3304. 

  3304. 		
    3305. 

  3305. 		### Compose & escape title text (TOC uses unescaped)
    3306. 

  3306. 		full_title = self._get_full_title_text()
    3307. 

  3307. 		
    3308. 

  3308. 		# Close previous section area
    3309. 

  3309. 		ret.extend(self.tag_hold)
    3310. 

  3310. 		self.tag_hold = []
    3311. 

  3311. 		
    3312. 

  3312. 		tagged = regex['x'].sub(full_title, self.tag)
    3313. 

  3313. 

  3314. 		# Adds "underline" on TXT target
    3315. 

  3315. 		if TARGET == 'txt':
    3316. 

  3316. 			if BLOCK.count > 1: ret.append('') # blank line before
    3317. 

  3317. 			ret.append(tagged)
    3318. 

  3318. 			# Get the right letter count for UTF
    3319. 

  3319. 			if CONF['encoding'].lower() == 'utf-8':
    3320. 

  3320. 				i = len(full_title.decode('utf-8'))
    3321. 

  3321. 			else:
    3322. 

  3322. 				i = len(full_title)
    3323. 

  3323. 			ret.append(regex['x'].sub('='*i, self.tag))
    3324. 

  3324. 		elif TARGET == 'art' and self.level == 1:
    3325. 

  3325. 			if CONF['slides'] :
    3326. 

  3326. 				AA_TITLE = tagged
    3327. 

  3327. 			else :
    3328. 

  3328. 				if BLOCK.count > 1: ret.append('') # blank line before
    3329. 

  3329. 				ret.extend(aa_box(tagged, CONF['width']))
    3330. 

  3330. 		elif TARGET == 'art':
    3331. 

  3331. 			level = 'level'+str(self.level)
    3332. 

  3332. 			if BLOCK.count > 1: ret.append('') # blank line before
    3333. 

  3333. 			ret.append(tagged)
    3334. 

  3334. 			ret.append(AA[level] * len(full_title))
    3335. 

  3335. 		else:
    3336. 

  3336. 			ret.append(tagged)
    3337. 

  3337. 		return ret
    3338. 

  3338. 	
    3339. 

  3339. 	def dump_marked_toc(self, max_level=99):
    3340. 

  3340. 		"Dumps all toc itens as a valid t2t-marked list"
    3341. 

  3341. 		ret = []
    3342. 

  3342. 		toc_count = 1
    3343. 

  3343. 		for level, count_id, txt, label in self.toc:
    3344. 

  3344. 			if level > max_level: continue   # ignore
    3345. 

  3345. 			indent = '  '*level
    3346. 

  3346. 			id_txt = ('%s %s'%(count_id, txt)).lstrip()
    3347. 

  3347. 			label = label or self.anchor_prefix+`toc_count`
    3348. 

  3348. 			toc_count += 1
    3349. 

  3349. 			
    3350. 

  3350. 			# TOC will have crosslinks to anchors
    3351. 

  3351. 			if TAGS['anchor']:
    3352. 

  3352. 				if CONF['enum-title'] and level == 1:
    3353. 

  3353. 					# 1. [Foo #anchor] is more readable than [1. Foo #anchor] in level 1.
    3354. 

  3354. 					# This is a stoled idea from Windows .CHM help files.
    3355. 

  3355. 					tocitem = '%s+ [""%s"" #%s]' % (indent, txt, label)
    3356. 

  3356. 				else:
    3357. 

  3357. 					tocitem = '%s- [""%s"" #%s]' % (indent, id_txt, label)
    3358. 

  3358. 

  3359. 			# TOC will be plain text (no links)
    3360. 

  3360. 			else:
    3361. 

  3361. 				if TARGET in ['txt', 'man', 'art']:
    3362. 

  3362. 					# For these, the list is not necessary, just dump the text
    3363. 

  3363. 					tocitem = '%s""%s""' % (indent, id_txt)
    3364. 

  3364. 				else:
    3365. 

  3365. 					tocitem = '%s- ""%s""' % (indent, id_txt)
    3366. 

  3366. 			ret.append(tocitem)
    3367. 

  3367. 		return ret
    3368. 

  3368. 

  3369. 

  3370. ##############################################################################
    3371. 

  3371. 

  3372. #TODO check all this table mess
    3373. 

  3373. # It uses parse_row properties for table lines
    3374. 

  3374. # BLOCK.table() replaces the cells by the parsed content
    3375. 

  3375. class TableMaster:
    3376. 

  3376. 	def __init__(self, line=''):
    3377. 

  3377. 		self.rows      = []
    3378. 

  3378. 		self.border    = 0
    3379. 

  3379. 		self.align     = 'Left'
    3380. 

  3380. 		self.cellalign = []
    3381. 

  3381. 		self.colalign  = []
    3382. 

  3382. 		self.cellspan  = []
    3383. 

  3383. 		if line:
    3384. 

  3384. 			prop = self.parse_row(line)
    3385. 

  3385. 			self.border    = prop['border']
    3386. 

  3386. 			self.align     = prop['align']
    3387. 

  3387. 			self.cellalign = prop['cellalign']
    3388. 

  3388. 			self.cellspan  = prop['cellspan']
    3389. 

  3389. 			self.colalign  = self._get_col_align()
    3390. 

  3390. 

  3391. 	def _get_col_align(self):
    3392. 

  3392. 		colalign = []
    3393. 

  3393. 		for cell in range(0,len(self.cellalign)):
    3394. 

  3394. 			align = self.cellalign[cell]
    3395. 

  3395. 			span  = self.cellspan[cell]
    3396. 

  3396. 			colalign.extend([align] * span)
    3397. 

  3397. 		return colalign
    3398. 

  3398. 

  3399. 	def _get_open_tag(self):
    3400. 

  3400. 		topen     = TAGS['tableOpen']
    3401. 

  3401. 		tborder   = TAGS['_tableBorder']
    3402. 

  3402. 		talign    = TAGS['_tableAlign'+self.align]
    3403. 

  3403. 		calignsep = TAGS['tableColAlignSep']
    3404. 

  3404. 		calign    = ''
    3405. 

  3405. 		
    3406. 

  3406. 		# The first line defines if table has border or not
    3407. 

  3407. 		if not self.border: tborder = ''
    3408. 

  3408. 		# Set the columns alignment
    3409. 

  3409. 		if rules['tablecellaligntype'] == 'column':
    3410. 

  3410. 			calign = map(lambda x: TAGS['_tableColAlign%s'%x], self.colalign)
    3411. 

  3411. 			calign = calignsep.join(calign)
    3412. 

  3412. 		# Align full table, set border and Column align (if any)
    3413. 

  3413. 		topen = regex['_tableAlign'   ].sub(talign , topen)
    3414. 

  3414. 		topen = regex['_tableBorder'  ].sub(tborder, topen)
    3415. 

  3415. 		topen = regex['_tableColAlign'].sub(calign , topen)
    3416. 

  3416. 		# Tex table spec, border or not: {|l|c|r|} , {lcr}
    3417. 

  3417. 		if calignsep and not self.border:
    3418. 

  3418. 			# Remove cell align separator
    3419. 

  3419. 			topen = topen.replace(calignsep, '')
    3420. 

  3420. 		return topen
    3421. 

  3421. 	
    3422. 

  3422. 	def _get_cell_align(self, cells):
    3423. 

  3423. 		ret = []
    3424. 

  3424. 		for cell in cells:
    3425. 

  3425. 			align = 'Left'
    3426. 

  3426. 			if cell.strip():
    3427. 

  3427. 				if cell[0] == ' ' and cell[-1] == ' ':
    3428. 

  3428. 					align = 'Center'
    3429. 

  3429. 				elif cell[0] == ' ':
    3430. 

  3430. 					align = 'Right'
    3431. 

  3431. 			ret.append(align)
    3432. 

  3432. 		return ret
    3433. 

  3433. 	
    3434. 

  3434. 	def _get_cell_span(self, cells):
    3435. 

  3435. 		ret = []
    3436. 

  3436. 		for cell in cells:
    3437. 

  3437. 			span = 1
    3438. 

  3438. 			m = re.search('\a(\|+)$', cell)
    3439. 

  3439. 			if m: span = len(m.group(1))+1
    3440. 

  3440. 			ret.append(span)
    3441. 

  3441. 		return ret
    3442. 

  3442. 	
    3443. 

  3443. 	def _tag_cells(self, rowdata):
    3444. 

  3444. 		row = []
    3445. 

  3445. 		cells  = rowdata['cells']
    3446. 

  3446. 		open_   = TAGS['tableCellOpen']
    3447. 

  3447. 		close  = TAGS['tableCellClose']
    3448. 

  3448. 		sep    = TAGS['tableCellSep']
    3449. 

  3449. 		calign    = map(lambda x: TAGS['_tableCellAlign'+x], rowdata['cellalign'])
    3450. 

  3450. 		calignsep = TAGS['tableColAlignSep']
    3451. 

  3451. 		ncolumns = len(self.colalign)
    3452. 

  3452. 

  3453. 		# Populate the span and multicol open tags
    3454. 

  3454. 		cspan = []
    3455. 

  3455. 		multicol = []
    3456. 

  3456. 		colindex = 0
    3457. 

  3457. 		for cellindex in range(0,len(rowdata['cellspan'])):
    3458. 

  3458. 		
    3459. 

  3459. 			span = rowdata['cellspan'][cellindex]
    3460. 

  3460. 			align = rowdata['cellalign'][cellindex]
    3461. 

  3461. 

  3462. 			if span > 1:
    3463. 

  3463. 				cspan.append(regex['x'].sub(
    3464. 

  3464. 				str(span), TAGS['_tableCellColSpan']))
    3465. 

  3465. 

  3466. 				mcopen = regex['x'].sub(str(span), TAGS['_tableCellMulticolOpen'])
    3467. 

  3467. 				multicol.append(mcopen)
    3468. 

  3468. 			else:
    3469. 

  3469. 				cspan.append('')
    3470. 

  3470. 

  3471. 				if colindex < ncolumns and align != self.colalign[colindex]:
    3472. 

  3472. 					mcopen = regex['x'].sub('1', TAGS['_tableCellMulticolOpen'])
    3473. 

  3473. 					multicol.append(mcopen)
    3474. 

  3474. 				else:
    3475. 

  3475. 					multicol.append('')
    3476. 

  3476. 

  3477. 			if not self.border:
    3478. 

  3478. 				multicol[-1] = multicol[-1].replace(calignsep, '')
    3479. 

  3479. 

  3480. 			colindex += span
    3481. 

  3481. 		
    3482. 

  3482. 		# Maybe is it a title row?
    3483. 

  3483. 		if rowdata['title']:
    3484. 

  3484. 			open_ = TAGS['tableTitleCellOpen']  or open_
    3485. 

  3485. 			close = TAGS['tableTitleCellClose'] or close
    3486. 

  3486. 			sep   = TAGS['tableTitleCellSep']   or sep
    3487. 

  3487. 		
    3488. 

  3488. 		# Should we break the line on *each* table cell?
    3489. 

  3489. 		if rules['breaktablecell']: close = close+'\n'
    3490. 

  3490. 		
    3491. 

  3491. 		# Cells pre processing
    3492. 

  3492. 		if rules['tablecellstrip']:
    3493. 

  3493. 			cells = map(lambda x: x.strip(), cells)
    3494. 

  3494. 		if rowdata['title'] and rules['tabletitlerowinbold']:
    3495. 

  3495. 			cells = map(lambda x: enclose_me('fontBold',x), cells)
    3496. 

  3496. 	
    3497. 

  3497. 		# Add cell BEGIN/END tags
    3498. 

  3498. 		for cell in cells:
    3499. 

  3499. 			copen = open_
    3500. 

  3500. 			cclose = close
    3501. 

  3501. 			# Make sure we will pop from some filled lists
    3502. 

  3502. 			# Fixes empty line bug '| |'
    3503. 

  3503. 			this_align = this_span = this_mcopen = ''
    3504. 

  3504. 			if calign: this_align = calign.pop(0)
    3505. 

  3505. 			if cspan : this_span = cspan.pop(0)
    3506. 

  3506. 			if multicol: this_mcopen = multicol.pop(0)
    3507. 

  3507. 

  3508. 			# Insert cell align into open tag (if cell is alignable)
    3509. 

  3509. 			if rules['tablecellaligntype'] == 'cell':
    3510. 

  3510. 				copen = regex['_tableCellAlign'].sub(
    3511. 

  3511. 					this_align, copen)
    3512. 

  3512. 

  3513. 			# Insert cell span into open tag (if cell is spannable)
    3514. 

  3514. 			if rules['tablecellspannable']:
    3515. 

  3515. 				copen = regex['_tableCellColSpan'].sub(
    3516. 

  3516. 					this_span, copen)
    3517. 

  3517. 

  3518. 			# Use multicol tags instead (if multicol supported, and if
    3519. 

  3519. 			# cell has a span or is aligned differently to column)
    3520. 

  3520. 			if rules['tablecellmulticol']:
    3521. 

  3521. 				if this_mcopen:
    3522. 

  3522. 					copen = regex['_tableColAlign'].sub(this_align, this_mcopen)
    3523. 

  3523. 					cclose = TAGS['_tableCellMulticolClose']
    3524. 

  3524. 

  3525. 			row.append(copen + cell + cclose)
    3526. 

  3526. 		
    3527. 

  3527. 		# Maybe there are cell separators?
    3528. 

  3528. 		return sep.join(row)
    3529. 

  3529. 	
    3530. 

  3530. 	def add_row(self, cells):
    3531. 

  3531. 		self.rows.append(cells)
    3532. 

  3532. 	
    3533. 

  3533. 	def parse_row(self, line):
    3534. 

  3534. 		# Default table properties
    3535. 

  3535. 		ret = {
    3536. 

  3536. 			'border':0, 'title':0, 'align':'Left',
    3537. 

  3537. 			'cells':[], 'cellalign':[], 'cellspan':[]
    3538. 

  3538. 		}
    3539. 

  3539. 		# Detect table align (and remove spaces mark)
    3540. 

  3540. 		if line[0] == ' ': ret['align'] = 'Center'
    3541. 

  3541. 		line = line.lstrip()
    3542. 

  3542. 		# Detect title mark
    3543. 

  3543. 		if line[1] == '|': ret['title'] = 1
    3544. 

  3544. 		# Detect border mark and normalize the EOL
    3545. 

  3545. 		m = re.search(' (\|+) *$', line)
    3546. 

  3546. 		if m: line = line+' ' ; ret['border'] = 1
    3547. 

  3547. 		else: line = line+' | '
    3548. 

  3548. 		# Delete table mark
    3549. 

  3549. 		line = regex['table'].sub('', line)
    3550. 

  3550. 		# Detect colspan  | foo | bar baz |||
    3551. 

  3551. 		line = re.sub(' (\|+)\| ', '\a\\1 | ', line)
    3552. 

  3552. 		# Split cells (the last is fake)
    3553. 

  3553. 		ret['cells'] = line.split(' | ')[:-1]
    3554. 

  3554. 		# Find cells span
    3555. 

  3555. 		ret['cellspan'] = self._get_cell_span(ret['cells'])
    3556. 

  3556. 		# Remove span ID
    3557. 

  3557. 		ret['cells'] = map(lambda x:re.sub('\a\|+$','',x),ret['cells'])
    3558. 

  3558. 		# Find cells align
    3559. 

  3559. 		ret['cellalign'] = self._get_cell_align(ret['cells'])
    3560. 

  3560. 		# Hooray!
    3561. 

  3561. 		Debug('Table Prop: %s' % ret, 7)
    3562. 

  3562. 		return ret
    3563. 

  3563. 	
    3564. 

  3564. 	def dump(self):
    3565. 

  3565. 		open_ = self._get_open_tag()
    3566. 

  3566. 		rows  = self.rows
    3567. 

  3567. 		close = TAGS['tableClose']
    3568. 

  3568. 		
    3569. 

  3569. 		rowopen     = TAGS['tableRowOpen']
    3570. 

  3570. 		rowclose    = TAGS['tableRowClose']
    3571. 

  3571. 		rowsep      = TAGS['tableRowSep']
    3572. 

  3572. 		titrowopen  = TAGS['tableTitleRowOpen']  or rowopen
    3573. 

  3573. 		titrowclose = TAGS['tableTitleRowClose'] or rowclose
    3574. 

  3574. 		
    3575. 

  3575. 		if rules['breaktablelineopen']:
    3576. 

  3576. 			rowopen = rowopen + '\n'
    3577. 

  3577. 			titrowopen = titrowopen + '\n'
    3578. 

  3578. 		
    3579. 

  3579. 		# Tex gotchas
    3580. 

  3580. 		if TARGET == 'tex':
    3581. 

  3581. 			if not self.border:
    3582. 

  3582. 				rowopen = titrowopen = ''
    3583. 

  3583. 			else:
    3584. 

  3584. 				close = rowopen + close
    3585. 

  3585. 		
    3586. 

  3586. 		# Now we tag all the table cells on each row
    3587. 

  3587. 		#tagged_cells = map(lambda x: self._tag_cells(x), rows) #!py15
    3588. 

  3588. 		tagged_cells = []
    3589. 

  3589. 		for cell in rows: tagged_cells.append(self._tag_cells(cell))
    3590. 

  3590. 		
    3591. 

  3591. 		# Add row separator tags between lines
    3592. 

  3592. 		tagged_rows = []
    3593. 

  3593. 		if rowsep:
    3594. 

  3594. 			#!py15
    3595. 

  3595. 			#tagged_rows = map(lambda x:x+rowsep, tagged_cells)
    3596. 

  3596. 			for cell in tagged_cells:
    3597. 

  3597. 				tagged_rows.append(cell+rowsep)
    3598. 

  3598. 			# Remove last rowsep, because the table is over
    3599. 

  3599. 			tagged_rows[-1] = tagged_rows[-1].replace(rowsep, '')
    3600. 

  3600. 		# Add row BEGIN/END tags for each line
    3601. 

  3601. 		else:
    3602. 

  3602. 			for rowdata in rows:
    3603. 

  3603. 				if rowdata['title']:
    3604. 

  3604. 					o,c = titrowopen, titrowclose
    3605. 

  3605. 				else:
    3606. 

  3606. 					o,c = rowopen, rowclose
    3607. 

  3607. 				row = tagged_cells.pop(0)
    3608. 

  3608. 				tagged_rows.append(o + row + c)
    3609. 

  3609. 		
    3610. 

  3610. 		# Join the pieces together
    3611. 

  3611. 		fulltable = []
    3612. 

  3612. 		if open_: fulltable.append(open_)
    3613. 

  3613. 		fulltable.extend(tagged_rows)
    3614. 

  3614. 		if close: fulltable.append(close)
    3615. 

  3615. 

  3616. 		return fulltable
    3617. 

  3617. 

  3618. 

  3619. ##############################################################################
    3620. 

  3620. 

  3621. 

  3622. class BlockMaster:
    3623. 

  3623. 	"TIP: use blockin/out to add/del holders"
    3624. 

  3624. 	def __init__(self):
    3625. 

  3625. 		self.BLK = []
    3626. 

  3626. 		self.HLD = []
    3627. 

  3627. 		self.PRP = []
    3628. 

  3628. 		self.depth = 0
    3629. 

  3629. 		self.count = 0
    3630. 

  3630. 		self.last = ''
    3631. 

  3631. 		self.tableparser = None
    3632. 

  3632. 		self.contains = {
    3633. 

  3633. 			'para'    :['comment','raw','tagged'],
    3634. 

  3634. 			'verb'    :[],
    3635. 

  3635. 			'table'   :['comment'],
    3636. 

  3636. 			'raw'     :[],
    3637. 

  3637. 			'tagged'  :[],
    3638. 

  3638. 			'comment' :[],
    3639. 

  3639. 			'quote'   :['quote','comment','raw','tagged'],
    3640. 

  3640. 			'list'    :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3641. 

  3641. 			'numlist' :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3642. 

  3642. 			'deflist' :['list','numlist','deflist','para','verb','comment','raw','tagged'],
    3643. 

  3643. 			'bar'     :[],
    3644. 

  3644. 			'title'   :[],
    3645. 

  3645. 			'numtitle':[],
    3646. 

  3646. 		}
    3647. 

  3647. 		self.allblocks = self.contains.keys()
    3648. 

  3648. 

  3649. 		# If one is found inside another, ignore the marks
    3650. 

  3650. 		self.exclusive = ['comment','verb','raw','tagged']
    3651. 

  3651. 		
    3652. 

  3652. 		# May we include bars inside quotes?
    3653. 

  3653. 		if rules['barinsidequote']:
    3654. 

  3654. 			self.contains['quote'].append('bar')
    3655. 

  3655. 	
    3656. 

  3656. 	def block(self):
    3657. 

  3657. 		if not self.BLK: return ''
    3658. 

  3658. 		return self.BLK[-1]
    3659. 

  3659. 	
    3660. 

  3660. 	def isblock(self, name=''):
    3661. 

  3661. 		return self.block() == name
    3662. 

  3662. 	
    3663. 

  3663. 	def prop(self, key):
    3664. 

  3664. 		if not self.PRP: return ''
    3665. 

  3665. 		return self.PRP[-1].get(key) or ''
    3666. 

  3666. 	
    3667. 

  3667. 	def propset(self, key, val):
    3668. 

  3668. 		self.PRP[-1][key] = val
    3669. 

  3669. 		#Debug('BLOCK prop ++: %s->%s'%(key,repr(val)), 1)
    3670. 

  3670. 		#Debug('BLOCK props: %s'%(repr(self.PRP)), 1)
    3671. 

  3671. 	
    3672. 

  3672. 	def hold(self):
    3673. 

  3673. 		if not self.HLD: return []
    3674. 

  3674. 		return self.HLD[-1]
    3675. 

  3675. 	
    3676. 

  3676. 	def holdadd(self, line):
    3677. 

  3677. 		if self.block().endswith('list'): line = [line]
    3678. 

  3678. 		self.HLD[-1].append(line)
    3679. 

  3679. 		Debug('HOLD add: %s'%repr(line), 4)
    3680. 

  3680. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3681. 

  3681. 	
    3682. 

  3682. 	def holdaddsub(self, line):
    3683. 

  3683. 		self.HLD[-1][-1].append(line)
    3684. 

  3684. 		Debug('HOLD addsub: %s'%repr(line), 4)
    3685. 

  3685. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3686. 

  3686. 	
    3687. 

  3687. 	def holdextend(self, lines):
    3688. 

  3688. 		if self.block().endswith('list'): lines = [lines]
    3689. 

  3689. 		self.HLD[-1].extend(lines)
    3690. 

  3690. 		Debug('HOLD extend: %s'%repr(lines), 4)
    3691. 

  3691. 		Debug('FULL HOLD: %s'%self.HLD, 4)
    3692. 

  3692. 	
    3693. 

  3693. 	def blockin(self, block):
    3694. 

  3694. 		ret = []
    3695. 

  3695. 		if block not in self.allblocks:
    3696. 

  3696. 			Error("Invalid block '%s'"%block)
    3697. 

  3697. 

  3698. 		# First, let's close other possible open blocks
    3699. 

  3699. 		while self.block() and block not in self.contains[self.block()]:
    3700. 

  3700. 			ret.extend(self.blockout())
    3701. 

  3701. 

  3702. 		# Now we can gladly add this new one
    3703. 

  3703. 		self.BLK.append(block)
    3704. 

  3704. 		self.HLD.append([])
    3705. 

  3705. 		self.PRP.append({})
    3706. 

  3706. 		self.count += 1
    3707. 

  3707. 		if block == 'table': self.tableparser = TableMaster()
    3708. 

  3708. 		# Deeper and deeper
    3709. 

  3709. 		self.depth = len(self.BLK)
    3710. 

  3710. 		Debug('block ++ (%s): %s' % (block,self.BLK), 3)
    3711. 

  3711. 		return ret
    3712. 

  3712. 	
    3713. 

  3713. 	def blockout(self):
    3714. 

  3714. 		global AA_COUNT
    3715. 

  3715.                 
    3716. 

  3716. 		if not self.BLK: Error('No block to pop')
    3717. 

  3717. 		blockname = self.BLK.pop()
    3718. 

  3718. 		result = getattr(self, blockname)()
    3719. 

  3719. 		parsed = self.HLD.pop()
    3720. 

  3720. 		self.PRP.pop()
    3721. 

  3721. 		self.depth = len(self.BLK)
    3722. 

  3722. 		if blockname == 'table': del self.tableparser
    3723. 

  3723. 

  3724. 		# Inserting a nested block into mother
    3725. 

  3725. 		if self.block():
    3726. 

  3726. 			if blockname != 'comment': # ignore comment blocks
    3727. 

  3727. 				if self.block().endswith('list'):
    3728. 

  3728. 					self.HLD[-1][-1].append(result)
    3729. 

  3729. 				else:
    3730. 

  3730. 					self.HLD[-1].append(result)
    3731. 

  3731. 			# Reset now. Mother block will have it all
    3732. 

  3732. 			result = []
    3733. 

  3733. 

  3734. 		Debug('block -- (%s): %s' % (blockname,self.BLK), 3)
    3735. 

  3735. 		Debug('RELEASED (%s): %s' % (blockname,parsed), 3)
    3736. 

  3736. 

  3737. 		# Save this top level block name (produced output)
    3738. 

  3738. 		# The next block will use it
    3739. 

  3739. 		if result:
    3740. 

  3740. 			self.last = blockname
    3741. 

  3741. 			Debug('BLOCK: %s'%result, 6)
    3742. 

  3742. 		
    3743. 

  3743. 		# ASCII Art processing
    3744. 

  3744.                 if TARGET == 'art' and CONF['slides'] and not CONF['toc-only'] and not CONF.get('art-no-title'):
    3745. 

  3745.                         n = (CONF['height'] - 1) - (AA_COUNT % (CONF['height'] - 1) + 1)
    3746. 

  3746.                         if n < len(result) and not (TITLE.level == 1 and blockname in ["title", "numtitle"]):
    3747. 

  3747.                                 result = ([''] * n) + [aa_line(AA['bar1'], CONF['width'])] + aa_slide(AA_TITLE, CONF['width']) + [''] + result
    3748. 

  3748.                         if blockname in ["title", "numtitle"] and TITLE.level == 1:
    3749. 

  3749.                                 aa_title = aa_slide(AA_TITLE, CONF['width']) + ['']
    3750. 

  3750.                                 if AA_COUNT:
    3751. 

  3751. 					aa_title = ([''] * n) + [aa_line(AA['bar2'], CONF['width'])] + aa_title
    3752. 

  3752.                                 result = aa_title + result
    3753. 

  3753.                         AA_COUNT += len(result)
    3754. 

  3754. 

  3755. 		return result
    3756. 

  3756. 	
    3757. 

  3757. 	def _last_escapes(self, line):
    3758. 

  3758. 		return doFinalEscape(TARGET, line)
    3759. 

  3759. 	
    3760. 

  3760. 	def _get_escaped_hold(self):
    3761. 

  3761. 		ret = []
    3762. 

  3762. 		for line in self.hold():
    3763. 

  3763. 			linetype = type(line)
    3764. 

  3764. 			if linetype == type('') or linetype == type(u''):
    3765. 

  3765. 				ret.append(self._last_escapes(line))
    3766. 

  3766. 			elif linetype == type([]):
    3767. 

  3767. 				ret.extend(line)
    3768. 

  3768. 			else:
    3769. 

  3769. 				Error("BlockMaster: Unknown HOLD item type: %s" % linetype)
    3770. 

  3770. 		return ret
    3771. 

  3771. 	
    3772. 

  3772. 	def _remove_twoblanks(self, lastitem):
    3773. 

  3773. 		if len(lastitem) > 1 and lastitem[-2:] == ['','']:
    3774. 

  3774. 			return lastitem[:-2]
    3775. 

  3775. 		return lastitem
    3776. 

  3776. 	
    3777. 

  3777. 	def _should_add_blank_line(self, where, blockname):
    3778. 

  3778. 		"Validates the blanksaround* rules"
    3779. 

  3779. 

  3780. 		# Nestable blocks: only mother blocks (level 1) are spaced
    3781. 

  3781. 		if blockname.endswith('list') and self.depth > 1:
    3782. 

  3782. 			return False
    3783. 

  3783. 

  3784. 		# The blank line after the block is always added
    3785. 

  3785. 		if where == 'after' \
    3786. 

  3786. 			and rules['blanksaround'+blockname]:
    3787. 

  3787. 			return True
    3788. 

  3788. 

  3789. 		# # No blank before if it's the first block of the body
    3790. 

  3790. 		# elif where == 'before' \
    3791. 

  3791. 		# 	and BLOCK.count == 1:
    3792. 

  3792. 		# 	return False
    3793. 

  3793. 

  3794. 		# # No blank before if it's the first block of this level (nested)
    3795. 

  3795. 		# elif where == 'before' \
    3796. 

  3796. 		# 	and self.count == 1:
    3797. 

  3797. 		# 	return False
    3798. 

  3798. 

  3799. 		# The blank line before the block is only added if
    3800. 

  3800. 		# the previous block haven't added a blank line
    3801. 

  3801. 		# (to avoid consecutive blanks)
    3802. 

  3802. 		elif where == 'before' \
    3803. 

  3803. 			and rules['blanksaround'+blockname] \
    3804. 

  3804. 			and not rules.get('blanksaround'+self.last):
    3805. 

  3805. 			return True
    3806. 

  3806. 

  3807. 		# Nested quotes are handled here,
    3808. 

  3808. 		# because the mother quote isn't closed yet
    3809. 

  3809. 		elif where == 'before' \
    3810. 

  3810. 			and blockname == 'quote' \
    3811. 

  3811. 			and rules['blanksaround'+blockname] \
    3812. 

  3812. 			and self.depth > 1:
    3813. 

  3813. 			return True
    3814. 

  3814. 

  3815. 		return False
    3816. 

  3816. 

  3817. 	def comment(self):
    3818. 

  3818. 		return ''
    3819. 

  3819. 	
    3820. 

  3820. 	def raw(self):
    3821. 

  3821. 		lines = self.hold()
    3822. 

  3822. 		return map(lambda x: doEscape(TARGET, x), lines)
    3823. 

  3823. 

  3824. 	def tagged(self):
    3825. 

  3825. 		return self.hold()
    3826. 

  3826. 	
    3827. 

  3827. 	def para(self):
    3828. 

  3828. 		result = []
    3829. 

  3829. 		open_ = TAGS['paragraphOpen']
    3830. 

  3830. 		close = TAGS['paragraphClose']
    3831. 

  3831. 		lines = self._get_escaped_hold()
    3832. 

  3832. 

  3833. 		# Blank line before?
    3834. 

  3834. 		if self._should_add_blank_line('before', 'para'): result.append('')
    3835. 

  3835. 

  3836. 		# Open tag
    3837. 

  3837. 		if open_: result.append(open_)
    3838. 

  3838. 

  3839. 		# Pagemaker likes a paragraph as a single long line
    3840. 

  3840. 		if rules['onelinepara']:
    3841. 

  3841. 			result.append(' '.join(lines))
    3842. 

  3842. 		# Others are normal :)
    3843. 

  3843. 		else:
    3844. 

  3844. 			result.extend(lines)
    3845. 

  3845. 

  3846. 		# Close tag
    3847. 

  3847. 		if close: result.append(close)
    3848. 

  3848. 

  3849. 		# Blank line after?
    3850. 

  3850. 		if self._should_add_blank_line('after', 'para'): result.append('')
    3851. 

  3851. 	
    3852. 

  3852. 		# Very very very very very very very very very UGLY fix
    3853. 

  3853. 		# Needed because <center> can't appear inside <p>
    3854. 

  3854. 		try:
    3855. 

  3855. 			if len(lines) == 1 and \
    3856. 

  3856. 			   TARGET in ('html', 'xhtml') and \
    3857. 

  3857. 			   re.match('^\s*<center>.*</center>\s*$', lines[0]):
    3858. 

  3858. 				result = [lines[0]]
    3859. 

  3859. 		except: pass
    3860. 

  3860. 		
    3861. 

  3861. 		return result
    3862. 

  3862. 	
    3863. 

  3863. 	def verb(self):
    3864. 

  3864. 		"Verbatim lines are not masked, so there's no need to unmask"
    3865. 

  3865. 		result = []
    3866. 

  3866. 		open_ = TAGS['blockVerbOpen']
    3867. 

  3867. 		close = TAGS['blockVerbClose']
    3868. 

  3868. 

  3869. 		# Blank line before?
    3870. 

  3870. 		if self._should_add_blank_line('before', 'verb'): result.append('')
    3871. 

  3871. 

  3872. 		# Open tag
    3873. 

  3873. 		if open_: result.append(open_)
    3874. 

  3874. 

  3875. 		# Get contents
    3876. 

  3876. 		for line in self.hold():
    3877. 

  3877. 			if self.prop('mapped') == 'table':
    3878. 

  3878. 				line = MacroMaster().expand(line)
    3879. 

  3879. 			if not rules['verbblocknotescaped']:
    3880. 

  3880. 				line = doEscape(TARGET,line)
    3881. 

  3881. 			if rules['indentverbblock']:
    3882. 

  3882. 				line = '  '+line
    3883. 

  3883. 			if rules['verbblockfinalescape']:
    3884. 

  3884. 				line = doFinalEscape(TARGET, line)
    3885. 

  3885. 			result.append(line)
    3886. 

  3886. 

  3887. 		# Close tag
    3888. 

  3888. 		if close: result.append(close)
    3889. 

  3889. 

  3890. 		# Blank line after?
    3891. 

  3891. 		if self._should_add_blank_line('after', 'verb'): result.append('')
    3892. 

  3892. 

  3893. 		return result
    3894. 

  3894. 

  3895. 	def numtitle(self): return self.title('numtitle')
    3896. 

  3896. 	def title(self, name='title'):
    3897. 

  3897. 		result = []
    3898. 

  3898. 

  3899. 		# Blank line before?
    3900. 

  3900. 		if self._should_add_blank_line('before', name): result.append('')
    3901. 

  3901. 

  3902. 		# Get contents
    3903. 

  3903. 		result.extend(TITLE.get())
    3904. 

  3904. 

  3905. 		# Blank line after?
    3906. 

  3906. 		if self._should_add_blank_line('after', name): result.append('')
    3907. 

  3907. 

  3908. 		return result
    3909. 

  3909. 

  3910. 	def table(self):
    3911. 

  3911. 		result = []
    3912. 

  3912. 

  3913. 		# Blank line before?
    3914. 

  3914. 		if self._should_add_blank_line('before', 'table'): result.append('')
    3915. 

  3915. 

  3916. 		# Rewrite all table cells by the unmasked and escaped data
    3917. 

  3917. 		lines = self._get_escaped_hold()
    3918. 

  3918. 		for i in xrange(len(lines)):
    3919. 

  3919. 			cells = lines[i].split(SEPARATOR)
    3920. 

  3920. 			self.tableparser.rows[i]['cells'] = cells
    3921. 

  3921. 		result.extend(self.tableparser.dump())
    3922. 

  3922. 

  3923. 		# Blank line after?
    3924. 

  3924. 		if self._should_add_blank_line('after', 'table'): result.append('')
    3925. 

  3925. 

  3926. 		return result
    3927. 

  3927. 

  3928. 	def quote(self):
    3929. 

  3929. 		result = []
    3930. 

  3930. 		open_  = TAGS['blockQuoteOpen']            # block based
    3931. 

  3931. 		close  = TAGS['blockQuoteClose']
    3932. 

  3932. 		qline  = TAGS['blockQuoteLine']            # line based
    3933. 

  3933. 		indent = tagindent = '\t'*self.depth
    3934. 

  3934. 		
    3935. 

  3935. 		# Apply rules
    3936. 

  3936. 		if rules['tagnotindentable']: tagindent = ''
    3937. 

  3937. 		if not rules['keepquoteindent']: indent = ''
    3938. 

  3938. 		
    3939. 

  3939. 		# Blank line before?
    3940. 

  3940. 		if self._should_add_blank_line('before', 'quote'): result.append('')
    3941. 

  3941. 

  3942. 		# Open tag
    3943. 

  3943. 		if open_: result.append(tagindent+open_)
    3944. 

  3944. 		
    3945. 

  3945. 		# Get contents
    3946. 

  3946. 		for item in self.hold():
    3947. 

  3947. 			if type(item) == type([]):
    3948. 

  3948. 				result.extend(item)        # subquotes
    3949. 

  3949. 			else:
    3950. 

  3950. 				item = regex['quote'].sub('', item)  # del TABs
    3951. 

  3951. 				item = self._last_escapes(item)
    3952. 

  3952. 				item = qline*self.depth + item
    3953. 

  3953. 				result.append(indent+item) # quote line
    3954. 

  3954. 

  3955. 		# Close tag
    3956. 

  3956. 		if close: result.append(tagindent+close)
    3957. 

  3957. 

  3958. 		# Blank line after?
    3959. 

  3959. 		if self._should_add_blank_line('after', 'quote'): result.append('')
    3960. 

  3960. 		
    3961. 

  3961. 		return result
    3962. 

  3962. 	
    3963. 

  3963. 	def bar(self):
    3964. 

  3964. 		result = []
    3965. 

  3965. 		bar_tag = ''
    3966. 

  3966. 

  3967. 		# Blank line before?
    3968. 

  3968. 		if self._should_add_blank_line('before', 'bar'): result.append('')
    3969. 

  3969. 

  3970. 		# Get the original bar chars
    3971. 

  3971. 		bar_chars = self.hold()[0].strip()
    3972. 

  3972. 

  3973. 		# Set bar type
    3974. 

  3974. 		if bar_chars.startswith('='): bar_tag = TAGS['bar2']
    3975. 

  3975. 		else                        : bar_tag = TAGS['bar1']
    3976. 

  3976. 

  3977. 		# To avoid comment tag confusion like <!-- ------ --> (sgml)
    3978. 

  3978. 		if TAGS['comment'].count('--'):
    3979. 

  3979. 			bar_chars = bar_chars.replace('--', '__')
    3980. 

  3980. 

  3981. 		# Get the bar tag (may contain \a)
    3982. 

  3982. 		result.append(regex['x'].sub(bar_chars, bar_tag))
    3983. 

  3983. 

  3984. 		# Blank line after?
    3985. 

  3985. 		if self._should_add_blank_line('after', 'bar'): result.append('')
    3986. 

  3986. 

  3987. 		return result
    3988. 

  3988. 

  3989. 	def deflist(self): return self.list('deflist')
    3990. 

  3990. 	def numlist(self): return self.list('numlist')
    3991. 

  3991. 	def list(self, name='list'):
    3992. 

  3992. 		result    = []
    3993. 

  3993. 		items     = self.hold()
    3994. 

  3994. 		indent    = self.prop('indent')
    3995. 

  3995. 		tagindent = indent
    3996. 

  3996. 		listline  = TAGS.get(name+'ItemLine')
    3997. 

  3997. 		itemcount = 0
    3998. 

  3998. 

  3999. 		if name == 'deflist':
    4000. 

  4000. 			itemopen  = TAGS[name+'Item1Open']
    4001. 

  4001. 			itemclose = TAGS[name+'Item2Close']
    4002. 

  4002. 			itemsep   = TAGS[name+'Item1Close']+\
    4003. 

  4003. 			            TAGS[name+'Item2Open']
    4004. 

  4004. 		else:
    4005. 

  4005. 			itemopen  = TAGS[name+'ItemOpen']
    4006. 

  4006. 			itemclose = TAGS[name+'ItemClose']
    4007. 

  4007. 			itemsep   = ''
    4008. 

  4008. 		
    4009. 

  4009. 		# Apply rules
    4010. 

  4010. 		if rules['tagnotindentable']: tagindent = ''
    4011. 

  4011. 		if not rules['keeplistindent']: indent = tagindent = ''
    4012. 

  4012. 

  4013. 		# ItemLine: number of leading chars identifies list depth
    4014. 

  4014. 		if listline:
    4015. 

  4015. 			itemopen  = listline*self.depth + itemopen
    4016. 

  4016. 		
    4017. 

  4017. 		# Adds trailing space on opening tags
    4018. 

  4018. 		if (name == 'list'    and rules['spacedlistitemopen']) or \
    4019. 

  4019. 		   (name == 'numlist' and rules['spacednumlistitemopen']):
    4020. 

  4020. 			itemopen = itemopen + ' '
    4021. 

  4021. 			
    4022. 

  4022. 		# Remove two-blanks from list ending mark, to avoid <p>
    4023. 

  4023. 		items[-1] = self._remove_twoblanks(items[-1])
    4024. 

  4024. 

  4025. 		# Blank line before?
    4026. 

  4026. 		if self._should_add_blank_line('before', name): result.append('')
    4027. 

  4027. 

  4028. 		# Tag each list item (multiline items), store in listbody
    4029. 

  4029. 		itemopenorig = itemopen
    4030. 

  4030. 		listbody = []
    4031. 

  4031. 		widelist = 0
    4032. 

  4032. 		for item in items:
    4033. 

  4033. 			
    4034. 

  4034. 			# Add "manual" item count for noautonum targets
    4035. 

  4035. 			itemcount += 1
    4036. 

  4036. 			if name == 'numlist' and not rules['autonumberlist']:
    4037. 

  4037. 				n = str(itemcount)
    4038. 

  4038. 				itemopen = regex['x'].sub(n, itemopenorig)
    4039. 

  4039. 				del n
    4040. 

  4040. 

  4041. 			# Tag it
    4042. 

  4042. 			item[0] = self._last_escapes(item[0])
    4043. 

  4043. 			if name == 'deflist':
    4044. 

  4044. 				z,term,rest = item[0].split(SEPARATOR, 2)
    4045. 

  4045. 				item[0] = rest
    4046. 

  4046. 				if not item[0]: del item[0]      # to avoid <p>
    4047. 

  4047. 				listbody.append(tagindent+itemopen+term+itemsep)
    4048. 

  4048. 			else:
    4049. 

  4049. 				fullitem = tagindent+itemopen
    4050. 

  4050. 				listbody.append(item[0].replace(SEPARATOR, fullitem))
    4051. 

  4051. 				del item[0]
    4052. 

  4052. 			
    4053. 

  4053. 			# Process next lines for this item (if any)
    4054. 

  4054. 			for line in item:
    4055. 

  4055. 				if type(line) == type([]): # sublist inside
    4056. 

  4056. 					listbody.extend(line)
    4057. 

  4057. 				else:
    4058. 

  4058. 					line = self._last_escapes(line)
    4059. 

  4059. 					
    4060. 

  4060. 					# Blank lines turns to <p>
    4061. 

  4061. 					if not line and rules['parainsidelist']:
    4062. 

  4062. 						line = indent + TAGS['paragraphOpen'] + TAGS['paragraphClose']
    4063. 

  4063. 						line = line.rstrip()
    4064. 

  4064. 						widelist = 1
    4065. 

  4065. 						
    4066. 

  4066. 					# Some targets don't like identation here (wiki)
    4067. 

  4067. 					if not rules['keeplistindent'] or (name == 'deflist' and rules['deflisttextstrip']):
    4068. 

  4068. 						line = line.lstrip()
    4069. 

  4069. 

  4070. 					# Maybe we have a line prefix to add? (wiki)
    4071. 

  4071. 					if name == 'deflist' and TAGS['deflistItem2LinePrefix']:
    4072. 

  4072. 						line = TAGS['deflistItem2LinePrefix'] + line
    4073. 

  4073. 						
    4074. 

  4074. 					listbody.append(line)
    4075. 

  4075. 			
    4076. 

  4076. 			# Close item (if needed)
    4077. 

  4077. 			if itemclose: listbody.append(tagindent+itemclose)
    4078. 

  4078. 		
    4079. 

  4079. 		if not widelist and rules['compactlist']:
    4080. 

  4080. 			listopen = TAGS.get(name+'OpenCompact')
    4081. 

  4081. 			listclose = TAGS.get(name+'CloseCompact')
    4082. 

  4082. 		else:
    4083. 

  4083. 			listopen  = TAGS.get(name+'Open')
    4084. 

  4084. 			listclose = TAGS.get(name+'Close')
    4085. 

  4085. 

  4086. 		# Open list (not nestable lists are only opened at mother)
    4087. 

  4087. 		if listopen and not \
    4088. 

  4088. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    4089. 

  4089. 			result.append(tagindent+listopen)
    4090. 

  4090. 

  4091. 		result.extend(listbody)
    4092. 

  4092. 		
    4093. 

  4093. 		# Close list (not nestable lists are only closed at mother)
    4094. 

  4094. 		if listclose and not \
    4095. 

  4095. 		   (rules['listnotnested'] and self.depth != 1):
    4096. 

  4096. 			result.append(tagindent+listclose)
    4097. 

  4097. 

  4098. 		# Blank line after?
    4099. 

  4099. 		if self._should_add_blank_line('after', name): result.append('')
    4100. 

  4100. 

  4101. 		return result
    4102. 

  4102. 

  4103. 

  4104. ##############################################################################
    4105. 

  4105. 

  4106. 

  4107. class MacroMaster:
    4108. 

  4108. 	def __init__(self, config={}):
    4109. 

  4109. 		self.name     = ''
    4110. 

  4110. 		self.config   = config or CONF
    4111. 

  4111. 		self.infile   = self.config['sourcefile']
    4112. 

  4112. 		self.outfile  = self.config['outfile']
    4113. 

  4113. 		self.currdate = time.localtime(time.time())
    4114. 

  4114. 		self.rgx      = regex.get('macros') or getRegexes()['macros']
    4115. 

  4115. 		self.fileinfo = { 'infile': None, 'outfile': None }
    4116. 

  4116. 		self.dft_fmt  = MACROS
    4117. 

  4117. 	
    4118. 

  4118. 	def walk_file_format(self, fmt):
    4119. 

  4119. 		"Walks the %%{in/out}file format string, expanding the % flags"
    4120. 

  4120. 		i = 0; ret = ''                                 # counter/hold
    4121. 

  4121. 		while i < len(fmt):                             # char by char
    4122. 

  4122. 			c = fmt[i]; i += 1
    4123. 

  4123. 			if c == '%':                            # hot char!
    4124. 

  4124. 				if i == len(fmt):               # % at the end
    4125. 

  4125. 					ret = ret + c
    4126. 

  4126. 					break
    4127. 

  4127. 				c = fmt[i]; i += 1              # read next
    4128. 

  4128. 				ret = ret + self.expand_file_flag(c)
    4129. 

  4129. 			else:
    4130. 

  4130. 				ret = ret +c                    # common char
    4131. 

  4131. 		return ret
    4132. 

  4132. 	
    4133. 

  4133. 	def expand_file_flag(self, flag):
    4134. 

  4134. 		"%f: filename          %F: filename (w/o extension)"
    4135. 

  4135. 		"%d: dirname           %D: dirname (only parent dir)"
    4136. 

  4136. 		"%p: file path         %e: extension"
    4137. 

  4137. 		info = self.fileinfo[self.name]           # get dict
    4138. 

  4138. 		if   flag == '%': x = '%'                 # %% -> %
    4139. 

  4139. 		elif flag == 'f': x = info['name']
    4140. 

  4140. 		elif flag == 'F': x = re.sub('\.[^.]*$','',info['name'])
    4141. 

  4141. 		elif flag == 'd': x = info['dir']
    4142. 

  4142. 		elif flag == 'D': x = os.path.split(info['dir'])[-1]
    4143. 

  4143. 		elif flag == 'p': x = info['path']
    4144. 

  4144. 		elif flag == 'e': x = re.search('.(\.([^.]+))?$', info['name']).group(2) or ''
    4145. 

  4145. 		#TODO simpler way for %e ?
    4146. 

  4146. 		else            : x = '%'+flag            # false alarm
    4147. 

  4147. 		return x
    4148. 

  4148. 	
    4149. 

  4149. 	def set_file_info(self, macroname):
    4150. 

  4150. 		if self.fileinfo.get(macroname): return   # already done
    4151. 

  4151. 		file_ = getattr(self, self.name)           # self.infile
    4152. 

  4152. 		if file_ == STDOUT or file_ == MODULEOUT:
    4153. 

  4153. 			dir_ = ''
    4154. 

  4154. 			path = name = file_
    4155. 

  4155. 		else:
    4156. 

  4156. 			path = os.path.abspath(file_)
    4157. 

  4157. 			dir_ = os.path.dirname(path)
    4158. 

  4158. 			name = os.path.basename(path)
    4159. 

  4159. 		self.fileinfo[macroname] = {'path':path,'dir':dir_,'name':name}
    4160. 

  4160. 	
    4161. 

  4161. 	def expand(self, line=''):
    4162. 

  4162. 		"Expand all macros found on the line"
    4163. 

  4163. 		while self.rgx.search(line):
    4164. 

  4164. 			m = self.rgx.search(line)
    4165. 

  4165. 			name = self.name = m.group('name').lower()
    4166. 

  4166. 			fmt = m.group('fmt') or self.dft_fmt.get(name)
    4167. 

  4167. 			if name == 'date':
    4168. 

  4168. 				txt = time.strftime(fmt,self.currdate)
    4169. 

  4169. 			elif name == 'mtime':
    4170. 

  4170. 				if self.infile in (STDIN, MODULEIN):
    4171. 

  4171. 					fdate = self.currdate
    4172. 

  4172. 				else:
    4173. 

  4173. 					mtime = os.path.getmtime(self.infile)
    4174. 

  4174. 					fdate = time.localtime(mtime)
    4175. 

  4175. 				txt = time.strftime(fmt,fdate)
    4176. 

  4176. 			elif name == 'infile' or name == 'outfile':
    4177. 

  4177. 				self.set_file_info(name)
    4178. 

  4178. 				txt = self.walk_file_format(fmt)
    4179. 

  4179. 			else:
    4180. 

  4180. 				Error("Unknown macro name '%s'"%name)
    4181. 

  4181. 			line = self.rgx.sub(txt,line,1)
    4182. 

  4182. 		return line
    4183. 

  4183. 

  4184. 

  4185. ##############################################################################
    4186. 

  4186. 

  4187. 

  4188. def listTargets():
    4189. 

  4189. 	"""list all available targets"""
    4190. 

  4190. 	targets = TARGETS
    4191. 

  4191. 	targets.sort()
    4192. 

  4192. 	for target in targets:
    4193. 

  4193. 		print "%s\t%s" % (target, TARGET_NAMES.get(target))
    4194. 

  4194. 

  4195. def dumpConfig(source_raw, parsed_config):
    4196. 

  4196. 	onoff = {1:_('ON'), 0:_('OFF')}
    4197. 

  4197. 	data = [
    4198. 

  4198. 		(_('RC file')        , RC_RAW     ),
    4199. 

  4199. 		(_('source document'), source_raw ),
    4200. 

  4200. 		(_('command line')   , CMDLINE_RAW)
    4201. 

  4201. 	]
    4202. 

  4202. 	# First show all RAW data found
    4203. 

  4203. 	for label, cfg in data:
    4204. 

  4204. 		print _('RAW config for %s')%label
    4205. 

  4205. 		for target,key,val in cfg:
    4206. 

  4206. 			target = '(%s)'%target
    4207. 

  4207. 			key    = dotted_spaces("%-14s"%key)
    4208. 

  4208. 			val    = val or _('ON')
    4209. 

  4209. 			print '  %-8s %s: %s'%(target,key,val)
    4210. 

  4210. 		print
    4211. 

  4211. 	# Then the parsed results of all of them
    4212. 

  4212. 	print _('Full PARSED config')
    4213. 

  4213. 	keys = parsed_config.keys() ; keys.sort()  # sorted
    4214. 

  4214. 	for key in keys:
    4215. 

  4215. 		val = parsed_config[key]
    4216. 

  4216. 		# Filters are the last
    4217. 

  4217. 		if key == 'preproc' or key == 'postproc':
    4218. 

  4218. 			continue
    4219. 

  4219. 		# Flag beautifier
    4220. 

  4220. 		if key in FLAGS.keys() or key in ACTIONS.keys():
    4221. 

  4221. 			val = onoff.get(val) or val
    4222. 

  4222. 		# List beautifier
    4223. 

  4223. 		if type(val) == type([]):
    4224. 

  4224. 			if key == 'options': sep = ' '
    4225. 

  4225. 			else               : sep = ', '
    4226. 

  4226. 			val = sep.join(val)
    4227. 

  4227. 		print "%25s: %s"%(dotted_spaces("%-14s"%key),val)
    4228. 

  4228. 	print
    4229. 

  4229. 	print _('Active filters')
    4230. 

  4230. 	for filter_ in ['preproc', 'postproc']:
    4231. 

  4231. 		for rule in parsed_config.get(filter_) or []:
    4232. 

  4232. 			print "%25s: %s  ->  %s" % (
    4233. 

  4233. 				dotted_spaces("%-14s"%filter_), rule[0], rule[1])
    4234. 

  4234. 

  4235. 

  4236. def get_file_body(file_):
    4237. 

  4237. 	"Returns all the document BODY lines"
    4238. 

  4238. 	return process_source_file(file_, noconf=1)[1][2]
    4239. 

  4239. 

  4240. 

  4241. def finish_him(outlist, config):
    4242. 

  4242. 	"Writing output to screen or file"
    4243. 

  4243. 	outfile = config['outfile']
    4244. 

  4244. 	outlist = unmaskEscapeChar(outlist)
    4245. 

  4245. 	outlist = expandLineBreaks(outlist)
    4246. 

  4246. 	
    4247. 

  4247. 	# Apply PostProc filters
    4248. 

  4248. 	if config['postproc']:
    4249. 

  4249. 		filters = compile_filters(config['postproc'],
    4250. 

  4250. 			_('Invalid PostProc filter regex'))
    4251. 

  4251. 		postoutlist = []
    4252. 

  4252. 		errmsg = _('Invalid PostProc filter replacement')
    4253. 

  4253. 		for line in outlist:
    4254. 

  4254. 			for rgx,repl in filters:
    4255. 

  4255. 				try: line = rgx.sub(repl, line)
    4256. 

  4256. 				except: Error("%s: '%s'"%(errmsg, repl))
    4257. 

  4257. 			postoutlist.append(line)
    4258. 

  4258. 		outlist = postoutlist[:]
    4259. 

  4259. 	
    4260. 

  4260. 	if outfile == MODULEOUT:
    4261. 

  4261. 		return outlist
    4262. 

  4262. 	elif outfile == STDOUT:
    4263. 

  4263. 		if GUI:
    4264. 

  4264. 			return outlist, config
    4265. 

  4265. 		else:
    4266. 

  4266. 			for line in outlist: print line
    4267. 

  4267. 	else:
    4268. 

  4268. 		Savefile(outfile, addLineBreaks(outlist))
    4269. 

  4269. 		if not GUI and not QUIET:
    4270. 

  4270. 			print _('%s wrote %s')%(my_name,outfile)
    4271. 

  4271. 	
    4272. 

  4272. 	if config['split']:
    4273. 

  4273. 		if not QUIET: print "--- html..."
    4274. 

  4274. 		sgml2html = 'sgml2html -s %s -l %s %s' % (
    4275. 

  4275. 			config['split'], config['lang'] or lang, outfile)
    4276. 

  4276. 		if not QUIET: print "Running system command:", sgml2html
    4277. 

  4277. 		os.system(sgml2html)
    4278. 

  4278. 

  4279. 

  4280. def toc_inside_body(body, toc, config):
    4281. 

  4281. 	ret = []
    4282. 

  4282. 	if AUTOTOC: return body                     # nothing to expand
    4283. 

  4283. 	toc_mark = MaskMaster().tocmask
    4284. 

  4284. 	# Expand toc mark with TOC contents
    4285. 

  4285. 	for line in body:
    4286. 

  4286. 		if line.count(toc_mark):            # toc mark found
    4287. 

  4287. 			if config['toc']:
    4288. 

  4288. 				ret.extend(toc)     # include if --toc
    4289. 

  4289. 			else:
    4290. 

  4290. 				pass                # or remove %%toc line
    4291. 

  4291. 		else:
    4292. 

  4292. 			ret.append(line)            # common line
    4293. 

  4293. 	return ret
    4294. 

  4294. 

  4295. def toc_tagger(toc, config):
    4296. 

  4296. 	"Returns the tagged TOC, as a single tag or a tagged list"
    4297. 

  4297. 	ret = []
    4298. 

  4298. 	# Convert the TOC list (t2t-marked) to the target's list format
    4299. 

  4299. 	if config['toc-only'] or (config['toc'] and not TAGS['TOC']):
    4300. 

  4300. 		fakeconf = config.copy()
    4301. 

  4301. 		fakeconf['headers']    = 0
    4302. 

  4302. 		fakeconf['toc-only']   = 0
    4303. 

  4303. 		fakeconf['mask-email'] = 0
    4304. 

  4304. 		fakeconf['preproc']    = []
    4305. 

  4305. 		fakeconf['postproc']   = []
    4306. 

  4306. 		fakeconf['css-sugar']  = 0
    4307. 

  4307. 		fakeconf['art-no-title']  = 1  # needed for --toc and --slides together, avoids slide title before TOC
    4308. 

  4308. 		ret,foo = convert(toc, fakeconf)
    4309. 

  4309. 		set_global_config(config)   # restore config
    4310. 

  4310. 	# Our TOC list is not needed, the target already knows how to do a TOC
    4311. 

  4311. 	elif config['toc'] and TAGS['TOC']:
    4312. 

  4312. 		ret = [TAGS['TOC']]
    4313. 

  4313. 	return ret
    4314. 

  4314. 

  4315. def toc_formatter(toc, config):
    4316. 

  4316. 	"Formats TOC for automatic placement between headers and body"
    4317. 

  4317. 

  4318. 	if config['toc-only']: return toc              # no formatting needed
    4319. 

  4319. 	if not config['toc'] : return []               # TOC disabled
    4320. 

  4320. 	ret = toc
    4321. 

  4321. 

  4322. 	# Art: An automatic "Table of Contents" header is added to the TOC slide
    4323. 

  4323. 	if config['target'] == 'art' and config['slides']:
    4324. 

  4324. 		n = (config['height'] - 1) - (len(toc) + 6) % (config['height'] - 1)
    4325. 

  4325. 		toc = aa_slide(_("Table of Contents"), config['width']) + toc + ([''] * n)
    4326. 

  4326. 		toc.append(aa_line(AA['bar2'], config['width']))
    4327. 

  4327. 		return toc
    4328. 

  4328. 

  4329. 	# TOC open/close tags (if any)
    4330. 

  4330. 	if TAGS['tocOpen' ]: ret.insert(0, TAGS['tocOpen'])
    4331. 

  4331. 	if TAGS['tocClose']: ret.append(TAGS['tocClose'])
    4332. 

  4332. 

  4333. 	# Autotoc specific formatting
    4334. 

  4334. 	if AUTOTOC:
    4335. 

  4335. 		if rules['autotocwithbars']:           # TOC between bars
    4336. 

  4336. 			para = TAGS['paragraphOpen']+TAGS['paragraphClose']
    4337. 

  4337. 			bar  = regex['x'].sub('-' * DFT_TEXT_WIDTH, TAGS['bar1'])
    4338. 

  4338. 			tocbar = [para, bar, para]
    4339. 

  4339. 			if config['target'] == 'art' and config['headers']:
    4340. 

  4340. 				# exception: header already printed a bar
    4341. 

  4341. 				ret = [para] + ret + tocbar
    4342. 

  4342. 			else:
    4343. 

  4343. 				ret = tocbar + ret + tocbar
    4344. 

  4344. 		if rules['blankendautotoc']:           # blank line after TOC
    4345. 

  4345. 			ret.append('')
    4346. 

  4346. 		if rules['autotocnewpagebefore']:      # page break before TOC
    4347. 

  4347. 			ret.insert(0,TAGS['pageBreak'])
    4348. 

  4348. 		if rules['autotocnewpageafter']:       # page break after TOC
    4349. 

  4349. 			ret.append(TAGS['pageBreak'])
    4350. 

  4350. 	return ret
    4351. 

  4351. 

  4352. 

  4353. def doHeader(headers, config):
    4354. 

  4354. 	if not config['headers']: return []
    4355. 

  4355. 	if not headers: headers = ['','','']
    4356. 

  4356. 	target = config['target']
    4357. 

  4357. 	if not HEADER_TEMPLATE.has_key(target):
    4358. 

  4358. 		Error("doHeader: Unknown target '%s'"%target)
    4359. 

  4359. 	
    4360. 

  4360. 	if target in ('html','xhtml') and config.get('css-sugar'):
    4361. 

  4361. 		template = HEADER_TEMPLATE[target+'css'].split('\n')
    4362. 

  4362. 	else:
    4363. 

  4363. 		template = HEADER_TEMPLATE[target].split('\n')
    4364. 

  4364. 	
    4365. 

  4365. 	head_data = {'STYLE':[], 'ENCODING':''}
    4366. 

  4366. 	for key in head_data.keys():
    4367. 

  4367. 		val = config.get(key.lower())
    4368. 

  4368. 		# Remove .sty extension from each style filename (freaking tex)
    4369. 

  4369. 		# XXX Can't handle --style foo.sty,bar.sty
    4370. 

  4370. 		if target == 'tex' and key == 'STYLE':
    4371. 

  4371. 			val = map(lambda x:re.sub('(?i)\.sty$','',x), val)
    4372. 

  4372. 		if key == 'ENCODING':
    4373. 

  4373. 			val = get_encoding_string(val, target)
    4374. 

  4374. 		head_data[key] = val
    4375. 

  4375. 	# Parse header contents
    4376. 

  4376. 	for i in 0,1,2:
    4377. 

  4377. 		# Expand macros
    4378. 

  4378. 		contents = MacroMaster(config=config).expand(headers[i])
    4379. 

  4379. 		# Escapes - on tex, just do it if any \tag{} present
    4380. 

  4380. 		if target != 'tex' or \
    4381. 

  4381. 		  (target == 'tex' and re.search(r'\\\w+{', contents)):
    4382. 

  4382. 			contents = doEscape(target, contents)
    4383. 

  4383. 		if target == 'lout':
    4384. 

  4384. 			contents = doFinalEscape(target, contents)
    4385. 

  4385. 		
    4386. 

  4386. 		head_data['HEADER%d'%(i+1)] = contents
    4387. 

  4387. 

  4388. 	# css-inside removes STYLE line
    4389. 

  4389. 	#XXX In tex, this also removes the modules call (%!style:amsfonts)
    4390. 

  4390. 	if target in ('html','xhtml') and config.get('css-inside') and \
    4391. 

  4391. 	   config.get('style'):
    4392. 

  4392. 		head_data['STYLE'] = []
    4393. 

  4393. 

  4394. 	Debug("Header Data: %s"%head_data, 1)
    4395. 

  4395. 

  4396. 	# ASCII Art does not use a header template, aa_header() formats the header
    4397. 

  4397. 	if target == 'art':
    4398. 

  4398.                 n_h = len([v for v in head_data if v.startswith("HEADER") and head_data[v]])
    4399. 

  4399.                 if not n_h :
    4400. 

  4400.                         return []
    4401. 

  4401.                 if config['slides']:
    4402. 

  4402.                         x = config['height'] - 3 - (n_h * 3)
    4403. 

  4403.                         n = x / (n_h + 1)
    4404. 

  4404.                         end = x % (n_h + 1)
    4405. 

  4405.                         template = aa_header(head_data, config['width'], n, end)
    4406. 

  4406.                 else:
    4407. 

  4407.                         template = [''] + aa_header(head_data, config['width'], 2, 0)
    4408. 

  4408. 		# Header done, let's get out
    4409. 

  4409.                 return template
    4410. 

  4410. 

  4411. 	# Scan for empty dictionary keys
    4412. 

  4412. 	# If found, scan template lines for that key reference
    4413. 

  4413. 	# If found, remove the reference
    4414. 

  4414. 	# If there isn't any other key reference on the same line, remove it
    4415. 

  4415. 	#TODO loop by template line > key
    4416. 

  4416. 	for key in head_data.keys():
    4417. 

  4417. 		if head_data.get(key): continue
    4418. 

  4418. 		for line in template:
    4419. 

  4419. 			if line.count('%%(%s)s'%key):
    4420. 

  4420. 				sline = line.replace('%%(%s)s'%key, '')
    4421. 

  4421. 				if not re.search(r'%\([A-Z0-9]+\)s', sline):
    4422. 

  4422. 					template.remove(line)
    4423. 

  4423. 	# Style is a multiple tag.
    4424. 

  4424. 	# - If none or just one, use default template
    4425. 

  4425. 	# - If two or more, insert extra lines in a loop (and remove original)
    4426. 

  4426. 	styles = head_data['STYLE']
    4427. 

  4427. 	if len(styles) == 1:
    4428. 

  4428. 		head_data['STYLE'] = styles[0]
    4429. 

  4429. 	elif len(styles) > 1:
    4430. 

  4430. 		style_mark = '%(STYLE)s'
    4431. 

  4431. 		for i in xrange(len(template)):
    4432. 

  4432. 			if template[i].count(style_mark):
    4433. 

  4433. 				while styles:
    4434. 

  4434. 					template.insert(i+1, template[i].replace(style_mark, styles.pop()))
    4435. 

  4435. 				del template[i]
    4436. 

  4436. 				break
    4437. 

  4437. 	# Populate template with data (dict expansion)
    4438. 

  4438. 	template = '\n'.join(template) % head_data
    4439. 

  4439. 	
    4440. 

  4440. 	# Adding CSS contents into template (for --css-inside)
    4441. 

  4441. 	# This code sux. Dirty++
    4442. 

  4442. 	if target in ('html','xhtml') and config.get('css-inside') and \
    4443. 

  4443. 	   config.get('style'):
    4444. 

  4444. 		set_global_config(config) # usually on convert(), needed here
    4445. 

  4445. 		for i in xrange(len(config['style'])):
    4446. 

  4446. 			cssfile = config['style'][i]
    4447. 

  4447. 			if not os.path.isabs(cssfile):
    4448. 

  4448. 				infile = config.get('sourcefile')
    4449. 

  4449. 				cssfile = os.path.join(
    4450. 

  4450. 					os.path.dirname(infile), cssfile)
    4451. 

  4451. 			try:
    4452. 

  4452. 				contents = Readfile(cssfile, 1)
    4453. 

  4453. 				css = "\n%s\n%s\n%s\n%s\n" % (
    4454. 

  4454. 					doCommentLine("Included %s" % cssfile),
    4455. 

  4455. 					TAGS['cssOpen'],
    4456. 

  4456. 					'\n'.join(contents),
    4457. 

  4457. 					TAGS['cssClose'])
    4458. 

  4458. 				# Style now is content, needs escaping (tex)
    4459. 

  4459. 				#css = maskEscapeChar(css)
    4460. 

  4460. 			except:
    4461. 

  4461. 				errmsg = "CSS include failed for %s" % cssfile
    4462. 

  4462. 				css = "\n%s\n" % (doCommentLine(errmsg))
    4463. 

  4463. 			# Insert this CSS file contents on the template
    4464. 

  4464. 			template = re.sub('(?i)(</HEAD>)', css+r'\1', template)
    4465. 

  4465. 			# template = re.sub(r'(?i)(\\begin{document})',
    4466. 

  4466. 			#		css+'\n'+r'\1', template) # tex
    4467. 

  4467. 		
    4468. 

  4468. 		# The last blank line to keep everything separated
    4469. 

  4469. 		template = re.sub('(?i)(</HEAD>)', '\n'+r'\1', template)
    4470. 

  4470. 	
    4471. 

  4471. 	return template.split('\n')
    4472. 

  4472. 

  4473. def doCommentLine(txt):
    4474. 

  4474. 	# The -- string ends a (h|sg|xht)ml comment :(
    4475. 

  4475. 	txt = maskEscapeChar(txt)
    4476. 

  4476. 	if TAGS['comment'].count('--') and txt.count('--'):
    4477. 

  4477. 		txt = re.sub('-(?=-)', r'-\\', txt)
    4478. 

  4478. 	
    4479. 

  4479. 	if TAGS['comment']:
    4480. 

  4480. 		return regex['x'].sub(txt, TAGS['comment'])
    4481. 

  4481. 	return ''
    4482. 

  4482. 

  4483. def doFooter(config):
    4484. 

  4484. 	ret = []
    4485. 

  4485. 

  4486. 	# No footer. The --no-headers option hides header AND footer
    4487. 

  4487. 	if not config['headers']:
    4488. 

  4488. 		return []
    4489. 

  4489. 	
    4490. 

  4490. 	# Only add blank line before footer if last block doesn't added by itself
    4491. 

  4491. 	if not rules.get('blanksaround'+BLOCK.last):
    4492. 

  4492. 		ret.append('')
    4493. 

  4493. 	
    4494. 

  4494. 	# Add txt2tags info at footer, if target supports comments
    4495. 

  4495. 	if TAGS['comment']:
    4496. 

  4496. 

  4497. 		# Not using TARGET_NAMES because it's i18n'ed.
    4498. 

  4498. 		# It's best to always present this info in english.
    4499. 

  4499. 		target = config['target']
    4500. 

  4500. 		if config['target'] == 'tex':
    4501. 

  4501. 			target = 'LaTeX2e'
    4502. 

  4502. 		
    4503. 

  4503. 		t2t_version = '%s code generated by %s %s (%s)' % (target, my_name, my_version, my_url)
    4504. 

  4504. 		cmdline = 'cmdline: %s %s' % (my_name, ' '.join(config['realcmdline']))
    4505. 

  4505. 

  4506. 		ret.append(doCommentLine(t2t_version))
    4507. 

  4507. 		ret.append(doCommentLine(cmdline))
    4508. 

  4508. 

  4509. 	# Maybe we have a specific tag to close the document?
    4510. 

  4510. 	if TAGS['EOD']:
    4511. 

  4511. 		ret.append(TAGS['EOD'])
    4512. 

  4512. 

  4513. 	return ret
    4514. 

  4514. 

  4515. def doEscape(target,txt):
    4516. 

  4516. 	"Target-specific special escapes. Apply *before* insert any tag."
    4517. 

  4517. 	tmpmask = 'vvvvThisEscapingSuxvvvv'
    4518. 

  4518. 	if target in ('html','sgml','xhtml','dbk'):
    4519. 

  4519. 		txt = re.sub('&','&amp;',txt)
    4520. 

  4520. 		txt = re.sub('<','&lt;',txt)
    4521. 

  4521. 		txt = re.sub('>','&gt;',txt)
    4522. 

  4522. 		if target == 'sgml':
    4523. 

  4523. 			txt = re.sub('\xff','&yuml;',txt)  # "+y
    4524. 

  4524. 	elif target == 'pm6':
    4525. 

  4525. 		txt = re.sub('<','<\#60>',txt)
    4526. 

  4526. 	elif target == 'mgp':
    4527. 

  4527. 		txt = re.sub('^%',' %',txt)  # add leading blank to avoid parse
    4528. 

  4528. 	elif target == 'man':
    4529. 

  4529. 		txt = re.sub("^([.'])", '\\&\\1',txt)           # command ID
    4530. 

  4530. 		txt = txt.replace(ESCCHAR, ESCCHAR+'e')         # \e
    4531. 

  4531. 	elif target == 'lout':
    4532. 

  4532. 		# TIP: / moved to FinalEscape to avoid //italic//
    4533. 

  4533. 		# TIP: these are also converted by lout:  ...  ---  --
    4534. 

  4534. 		txt = txt.replace(ESCCHAR, tmpmask)             # \
    4535. 

  4535. 		txt = txt.replace('"', '"%s""'%ESCCHAR)         # "\""
    4536. 

  4536. 		txt = re.sub('([|&{}@#^~])', '"\\1"', txt)      # "@"
    4537. 

  4537. 		txt = txt.replace(tmpmask, '"%s"'%(ESCCHAR*2))  # "\\"
    4538. 

  4538. 	elif target == 'tex':
    4539. 

  4539. 		# Mark literal \ to be changed to $\backslash$ later
    4540. 

  4540. 		txt = txt.replace(ESCCHAR, tmpmask)
    4541. 

  4541. 		txt = re.sub('([#$&%{}])', ESCCHAR+r'\1'  , txt)  # \%
    4542. 

  4542. 		txt = re.sub('([~^])'    , ESCCHAR+r'\1{}', txt)  # \~{}
    4543. 

  4543. 		txt = re.sub('([<|>])'   ,         r'$\1$', txt)  # $>$
    4544. 

  4544. 		txt = txt.replace(tmpmask, maskEscapeChar(r'$\backslash$'))
    4545. 

  4545. 		# TIP the _ is escaped at the end
    4546. 

  4546. 	return txt
    4547. 

  4547. 

  4548. # TODO man: where - really needs to be escaped?
    4549. 

  4549. def doFinalEscape(target, txt):
    4550. 

  4550. 	"Last escapes of each line"
    4551. 

  4551. 	if   target == 'pm6' : txt = txt.replace(ESCCHAR+'<', r'<\#92><')
    4552. 

  4552. 	elif target == 'man' : txt = txt.replace('-', r'\-')
    4553. 

  4553. 	elif target == 'sgml': txt = txt.replace('[', '&lsqb;')
    4554. 

  4554. 	elif target == 'lout': txt = txt.replace('/', '"/"')
    4555. 

  4555. 	elif target == 'tex' :
    4556. 

  4556. 		txt = txt.replace('_', r'\_')
    4557. 

  4557. 		txt = txt.replace('vvvvTexUndervvvv', '_')  # shame!
    4558. 

  4558. 	return txt
    4559. 

  4559. 

  4560. def EscapeCharHandler(action, data):
    4561. 

  4561. 	"Mask/Unmask the Escape Char on the given string"
    4562. 

  4562. 	if not data.strip(): return data
    4563. 

  4563. 	if action not in ('mask','unmask'):
    4564. 

  4564. 		Error("EscapeCharHandler: Invalid action '%s'"%action)
    4565. 

  4565. 	if action == 'mask': return data.replace('\\', ESCCHAR)
    4566. 

  4566. 	else:                return data.replace(ESCCHAR, '\\')
    4567. 

  4567. 

  4568. def maskEscapeChar(data):
    4569. 

  4569. 	"Replace any Escape Char \ with a text mask (Input: str or list)"
    4570. 

  4570. 	if type(data) == type([]):
    4571. 

  4571. 		return map(lambda x: EscapeCharHandler('mask', x), data)
    4572. 

  4572. 	return EscapeCharHandler('mask',data)
    4573. 

  4573. 

  4574. def unmaskEscapeChar(data):
    4575. 

  4575. 	"Undo the Escape char \ masking (Input: str or list)"
    4576. 

  4576. 	if type(data) == type([]):
    4577. 

  4577. 		return map(lambda x: EscapeCharHandler('unmask', x), data)
    4578. 

  4578. 	return EscapeCharHandler('unmask',data)
    4579. 

  4579. 

  4580. def addLineBreaks(mylist):
    4581. 

  4581. 	"use LB to respect sys.platform"
    4582. 

  4582. 	ret = []
    4583. 

  4583. 	for line in mylist:
    4584. 

  4584. 		line = line.replace('\n', LB)        # embedded \n's
    4585. 

  4585. 		ret.append(line+LB)                  # add final line break
    4586. 

  4586. 	return ret
    4587. 

  4587. 

  4588. # Convert ['foo\nbar'] to ['foo', 'bar']
    4589. 

  4589. def expandLineBreaks(mylist):
    4590. 

  4590. 	ret = []
    4591. 

  4591. 	for line in mylist:
    4592. 

  4592. 		ret.extend(line.split('\n'))
    4593. 

  4593. 	return ret
    4594. 

  4594. 

  4595. def compile_filters(filters, errmsg='Filter'):
    4596. 

  4596. 	if filters:
    4597. 

  4597. 		for i in xrange(len(filters)):
    4598. 

  4598. 			patt,repl = filters[i]
    4599. 

  4599. 			try: rgx = re.compile(patt)
    4600. 

  4600. 			except: Error("%s: '%s'"%(errmsg, patt))
    4601. 

  4601. 			filters[i] = (rgx,repl)
    4602. 

  4602. 	return filters
    4603. 

  4603. 

  4604. def enclose_me(tagname, txt):
    4605. 

  4605. 	return TAGS.get(tagname+'Open') + txt + TAGS.get(tagname+'Close')
    4606. 

  4606. 

  4607. def beautify_me(name, line):
    4608. 

  4608. 	"where name is: bold, italic, underline or strike"
    4609. 

  4609. 

  4610. 	# Exception: Doesn't parse an horizontal bar as strike
    4611. 

  4611. 	if name == 'strike' and regex['bar'].search(line): return line
    4612. 

  4612. 	
    4613. 

  4613. 	name  = 'font%s' % name.capitalize()
    4614. 

  4614. 	open_ = TAGS['%sOpen'%name]
    4615. 

  4615. 	close = TAGS['%sClose'%name]
    4616. 

  4616. 	txt = r'%s\1%s'%(open_, close)
    4617. 

  4617. 	line = regex[name].sub(txt,line)
    4618. 

  4618. 	return line
    4619. 

  4619. 

  4620. def get_tagged_link(label, url):
    4621. 

  4621. 	ret = ''
    4622. 

  4622. 	target = CONF['target']
    4623. 

  4623. 	image_re = regex['img']
    4624. 

  4624. 	
    4625. 

  4625. 	# Set link type
    4626. 

  4626. 	if regex['email'].match(url):
    4627. 

  4627. 		linktype = 'email'
    4628. 

  4628. 	else:
    4629. 

  4629. 		linktype = 'url';
    4630. 

  4630. 	
    4631. 

  4631. 	# Escape specials from TEXT parts
    4632. 

  4632. 	label = doEscape(target,label)
    4633. 

  4633. 	
    4634. 

  4634. 	# Escape specials from link URL
    4635. 

  4635. 	if not rules['linkable'] or rules['escapeurl']:
    4636. 

  4636. 		url = doEscape(target, url)
    4637. 

  4637. 	
    4638. 

  4638. 	# Adding protocol to guessed link
    4639. 

  4639. 	guessurl = ''
    4640. 

  4640. 	if linktype == 'url' and \
    4641. 

  4641. 	   re.match('(?i)'+regex['_urlskel']['guess'], url):
    4642. 

  4642. 		if url[0] in 'Ww': guessurl = 'http://' +url
    4643. 

  4643. 		else             : guessurl =  'ftp://' +url
    4644. 

  4644. 		
    4645. 

  4645. 		# Not link aware targets -> protocol is useless
    4646. 

  4646. 		if not rules['linkable']: guessurl = ''
    4647. 

  4647. 	
    4648. 

  4648. 	# Simple link (not guessed)
    4649. 

  4649. 	if not label and not guessurl:
    4650. 

  4650. 		if CONF['mask-email'] and linktype == 'email':
    4651. 

  4651. 			# Do the email mask feature (no TAGs, just text)
    4652. 

  4652. 			url = url.replace('@', ' (a) ')
    4653. 

  4653. 			url = url.replace('.', ' ')
    4654. 

  4654. 			url = "<%s>" % url
    4655. 

  4655. 			if rules['linkable']: url = doEscape(target, url)
    4656. 

  4656. 			ret = url
    4657. 

  4657. 		else:
    4658. 

  4658. 			# Just add link data to tag
    4659. 

  4659. 			tag = TAGS[linktype]
    4660. 

  4660. 			ret = regex['x'].sub(url,tag)
    4661. 

  4661. 	
    4662. 

  4662. 	# Named link or guessed simple link
    4663. 

  4663. 	else:
    4664. 

  4664. 		# Adjusts for guessed link
    4665. 

  4665. 		if not label: label = url         # no   protocol
    4666. 

  4666. 		if guessurl : url   = guessurl    # with protocol
    4667. 

  4667. 		
    4668. 

  4668. 		# Image inside link!
    4669. 

  4669. 		if image_re.match(label):
    4670. 

  4670. 			if rules['imglinkable']:  # get image tag
    4671. 

  4671. 				label = parse_images(label)
    4672. 

  4672. 			else:                     #  img@link !supported
    4673. 

  4673. 				label = "(%s)"%image_re.match(label).group(1)
    4674. 

  4674. 		
    4675. 

  4675. 		# Putting data on the right appearance order
    4676. 

  4676. 		if rules['labelbeforelink'] or not rules['linkable']:
    4677. 

  4677. 			urlorder = [label, url]   # label before link
    4678. 

  4678. 		else:
    4679. 

  4679. 			urlorder = [url, label]   # link before label
    4680. 

  4680. 		
    4681. 

  4681. 		# Add link data to tag (replace \a's)
    4682. 

  4682. 		ret = TAGS["%sMark"%linktype]
    4683. 

  4683. 		for data in urlorder:
    4684. 

  4684. 			ret = regex['x'].sub(data,ret,1)
    4685. 

  4685. 	
    4686. 

  4686. 	return ret
    4687. 

  4687. 

  4688. 

  4689. def parse_deflist_term(line):
    4690. 

  4690. 	"Extract and parse definition list term contents"
    4691. 

  4691. 	img_re = regex['img']
    4692. 

  4692. 	term   = regex['deflist'].search(line).group(3)
    4693. 

  4693. 	
    4694. 

  4694. 	# Mask image inside term as (image.jpg), where not supported
    4695. 

  4695. 	if not rules['imgasdefterm'] and img_re.search(term):
    4696. 

  4696. 		while img_re.search(term):
    4697. 

  4697. 			imgfile = img_re.search(term).group(1)
    4698. 

  4698. 			term = img_re.sub('(%s)'%imgfile, term, 1)
    4699. 

  4699. 	
    4700. 

  4700. 	#TODO tex: escape ] on term. \], \rbrack{} and \verb!]! don't work :(
    4701. 

  4701. 	return term
    4702. 

  4702. 

  4703. 

  4704. def get_image_align(line):
    4705. 

  4705. 	"Return the image (first found) align for the given line"
    4706. 

  4706. 	
    4707. 

  4707. 	# First clear marks that can mess align detection
    4708. 

  4708. 	line = re.sub(SEPARATOR+'$', '', line)  # remove deflist sep
    4709. 

  4709. 	line = re.sub('^'+SEPARATOR, '', line)  # remove list sep
    4710. 

  4710. 	line = re.sub('^[\t]+'     , '', line)  # remove quote mark
    4711. 

  4711. 	
    4712. 

  4712. 	# Get image position on the line
    4713. 

  4713. 	m = regex['img'].search(line)
    4714. 

  4714. 	ini = m.start() ; head = 0
    4715. 

  4715. 	end = m.end()   ; tail = len(line)
    4716. 

  4716. 	
    4717. 

  4717. 	# The align detection algorithm
    4718. 

  4718. 	if   ini == head and end != tail: align = 'left'   # ^img + text$
    4719. 

  4719. 	elif ini != head and end == tail: align = 'right'  # ^text + img$
    4720. 

  4720. 	else                            : align = 'center' # default align
    4721. 

  4721. 	
    4722. 

  4722. 	# Some special cases
    4723. 

  4723. 	if BLOCK.isblock('table'): align = 'center'    # ignore when table
    4724. 

  4724. #	if TARGET == 'mgp' and align == 'center': align = 'center'
    4725. 

  4725. 	
    4726. 

  4726. 	return align
    4727. 

  4727. 

  4728. 

  4729. # Reference: http://www.iana.org/assignments/character-sets
    4730. 

  4730. # http://www.drclue.net/F1.cgi/HTML/META/META.html
    4731. 

  4731. def get_encoding_string(enc, target):
    4732. 

  4732. 	if not enc: return ''
    4733. 

  4733. 	# Target specific translation table
    4734. 

  4734. 	translate = {
    4735. 

  4735. 		'tex': {
    4736. 

  4736. 			# missing: ansinew , applemac , cp437 , cp437de , cp865
    4737. 

  4737. 			'utf-8'       : 'utf8',
    4738. 

  4738. 			'us-ascii'    : 'ascii',
    4739. 

  4739. 			'windows-1250': 'cp1250',
    4740. 

  4740. 			'windows-1252': 'cp1252',
    4741. 

  4741. 			'ibm850'      : 'cp850',
    4742. 

  4742. 			'ibm852'      : 'cp852',
    4743. 

  4743. 			'iso-8859-1'  : 'latin1',
    4744. 

  4744. 			'iso-8859-2'  : 'latin2',
    4745. 

  4745. 			'iso-8859-3'  : 'latin3',
    4746. 

  4746. 			'iso-8859-4'  : 'latin4',
    4747. 

  4747. 			'iso-8859-5'  : 'latin5',
    4748. 

  4748. 			'iso-8859-9'  : 'latin9',
    4749. 

  4749. 			'koi8-r'      : 'koi8-r'
    4750. 

  4750. 		}
    4751. 

  4751. 	}
    4752. 

  4752. 	# Normalization
    4753. 

  4753. 	enc = re.sub('(?i)(us[-_]?)?ascii|us|ibm367','us-ascii'  , enc)
    4754. 

  4754. 	enc = re.sub('(?i)(ibm|cp)?85([02])'        ,'ibm85\\2'  , enc)
    4755. 

  4755. 	enc = re.sub('(?i)(iso[_-]?)?8859[_-]?'     ,'iso-8859-' , enc)
    4756. 

  4756. 	enc = re.sub('iso-8859-($|[^1-9]).*'        ,'iso-8859-1', enc)
    4757. 

  4757. 	# Apply translation table
    4758. 

  4758. 	try: enc = translate[target][enc.lower()]
    4759. 

  4759. 	except: pass
    4760. 

  4760. 	return enc
    4761. 

  4761. 

  4762. 

  4763. ##############################################################################
    4764. 

  4764. ##MerryChristmas,IdontwanttofighttonightwithyouImissyourbodyandIneedyourlove##
    4765. 

  4765. ##############################################################################
    4766. 

  4766. 

  4767. 

  4768. def process_source_file(file_='', noconf=0, contents=[]):
    4769. 

  4769. 	"""
    4770. 

  4770. 	Find and Join all the configuration available for a source file.
    4771. 

  4771. 	No sanity checking is done on this step.
    4772. 

  4772. 	It also extracts the source document parts into separate holders.
    4773. 

  4773. 	
    4774. 

  4774. 	The config scan order is:
    4775. 

  4775. 		1. The user configuration file (i.e. $HOME/.txt2tagsrc)
    4776. 

  4776. 		2. The source document's CONF area
    4777. 

  4777. 		3. The command line options
    4778. 

  4778. 

  4779. 	The return data is a tuple of two items:
    4780. 

  4780. 		1. The parsed config dictionary
    4781. 

  4781. 		2. The document's parts, as a (head, conf, body) tuple
    4782. 

  4782. 	
    4783. 

  4783. 	All the conversion process will be based on the data and
    4784. 

  4784. 	configuration returned by this function.
    4785. 

  4785. 	The source files is read on this step only.
    4786. 

  4786. 	"""
    4787. 

  4787. 	if contents:
    4788. 

  4788. 		source = SourceDocument(contents=contents)
    4789. 

  4789. 	else:
    4790. 

  4790. 		source = SourceDocument(file_)
    4791. 

  4791. 	head, conf, body = source.split()
    4792. 

  4792. 	Message(_("Source document contents stored"),2)
    4793. 

  4793. 	if not noconf:
    4794. 

  4794. 		# Read document config
    4795. 

  4795. 		source_raw = source.get_raw_config()
    4796. 

  4796. 		# Join all the config directives found, then parse it
    4797. 

  4797. 		full_raw = RC_RAW + source_raw + CMDLINE_RAW
    4798. 

  4798. 		Message(_("Parsing and saving all config found (%03d items)") % (len(full_raw)), 1)
    4799. 

  4799. 		full_parsed = ConfigMaster(full_raw).parse()
    4800. 

  4800. 		# Add manually the filename to the conf dic
    4801. 

  4801. 		if contents:
    4802. 

  4802. 			full_parsed['sourcefile'] = MODULEIN
    4803. 

  4803. 			full_parsed['infile'] = MODULEIN
    4804. 

  4804. 			full_parsed['outfile'] = MODULEOUT
    4805. 

  4805. 		else:
    4806. 

  4806. 			full_parsed['sourcefile'] = file_
    4807. 

  4807. 		# Maybe should we dump the config found?
    4808. 

  4808. 		if full_parsed.get('dump-config'):
    4809. 

  4809. 			dumpConfig(source_raw, full_parsed)
    4810. 

  4810. 			Quit()
    4811. 

  4811. 		# The user just want to know a single config value (hidden feature)
    4812. 

  4812. 		#TODO pick a better name than --show-config-value
    4813. 

  4813. 		elif full_parsed.get('show-config-value'):
    4814. 

  4814. 			config_value = full_parsed.get(full_parsed['show-config-value'])
    4815. 

  4815. 			if config_value:
    4816. 

  4816. 				if type(config_value) == type([]):
    4817. 

  4817. 					print '\n'.join(config_value)
    4818. 

  4818. 				else:
    4819. 

  4819. 					print config_value
    4820. 

  4820. 			Quit()
    4821. 

  4821. 		# Okay, all done
    4822. 

  4822. 		Debug("FULL config for this file: %s"%full_parsed, 1)
    4823. 

  4823. 	else:
    4824. 

  4824. 		full_parsed = {}
    4825. 

  4825. 	return full_parsed, (head,conf,body)
    4826. 

  4826. 

  4827. def get_infiles_config(infiles):
    4828. 

  4828. 	"""
    4829. 

  4829. 	Find and Join into a single list, all configuration available
    4830. 

  4830. 	for each input file. This function is supposed to be the very
    4831. 

  4831. 	first one to be called, before any processing.
    4832. 

  4832. 	"""
    4833. 

  4833. 	return map(process_source_file, infiles)
    4834. 

  4834. 

  4835. def convert_this_files(configs):
    4836. 

  4836. 	global CONF
    4837. 

  4837. 	for myconf,doc in configs:                 # multifile support
    4838. 

  4838. 		target_head = []
    4839. 

  4839. 		target_toc  = []
    4840. 

  4840. 		target_body = []
    4841. 

  4841. 		target_foot = []
    4842. 

  4842. 		source_head, source_conf, source_body = doc
    4843. 

  4843. 		myconf = ConfigMaster().sanity(myconf)
    4844. 

  4844. 		# Compose the target file Headers
    4845. 

  4845. 		#TODO escape line before?
    4846. 

  4846. 		#TODO see exceptions by tex and mgp
    4847. 

  4847. 		Message(_("Composing target Headers"),1)
    4848. 

  4848. 		target_head = doHeader(source_head, myconf)
    4849. 

  4849. 		# Parse the full marked body into tagged target
    4850. 

  4850. 		first_body_line = (len(source_head) or 1)+ len(source_conf) + 1
    4851. 

  4851. 		Message(_("Composing target Body"),1)
    4852. 

  4852. 		target_body, marked_toc = convert(source_body, myconf, firstlinenr=first_body_line)
    4853. 

  4853. 		# If dump-source, we're done
    4854. 

  4854. 		if myconf['dump-source']:
    4855. 

  4855. 			for line in source_head+source_conf+target_body:
    4856. 

  4856. 				print line
    4857. 

  4857. 			return
    4858. 

  4858. 

  4859. 		# Close the last slide
    4860. 

  4860. 		if myconf['slides'] and not myconf['toc-only'] and myconf['target'] == 'art':
    4861. 

  4861. 			n = (myconf['height'] - 1) - (AA_COUNT % (myconf['height'] - 1) + 1)
    4862. 

  4862. 			target_body = target_body + ([''] * n) + [aa_line(AA['bar2'], myconf['width'])]
    4863. 

  4863. 

  4864. 		# Compose the target file Footer
    4865. 

  4865. 		Message(_("Composing target Footer"),1)
    4866. 

  4866. 		target_foot = doFooter(myconf)
    4867. 

  4867. 

  4868. 		# Make TOC (if needed)
    4869. 

  4869. 		Message(_("Composing target TOC"),1)
    4870. 

  4870. 		tagged_toc  = toc_tagger(marked_toc, myconf)
    4871. 

  4871. 		target_toc  = toc_formatter(tagged_toc, myconf)
    4872. 

  4872. 		target_body = toc_inside_body(target_body, target_toc, myconf)
    4873. 

  4873. 		if not AUTOTOC and not myconf['toc-only']: target_toc = []
    4874. 

  4874. 		# Finally, we have our document
    4875. 

  4875. 		outlist = target_head + target_toc + target_body + target_foot
    4876. 

  4876. 		# If on GUI, abort before finish_him
    4877. 

  4877. 		# If module, return finish_him as list
    4878. 

  4878. 		# Else, write results to file or STDOUT
    4879. 

  4879. 		if GUI:
    4880. 

  4880. 			return outlist, myconf
    4881. 

  4881. 		elif myconf.get('outfile') == MODULEOUT:
    4882. 

  4882. 			return finish_him(outlist, myconf), myconf
    4883. 

  4883. 		else:
    4884. 

  4884. 			Message(_("Saving results to the output file"),1)
    4885. 

  4885. 			finish_him(outlist, myconf)
    4886. 

  4886. 

  4887. 

  4888. def parse_images(line):
    4889. 

  4889. 	"Tag all images found"
    4890. 

  4890. 	while regex['img'].search(line) and TAGS['img'] != '[\a]':
    4891. 

  4891. 		txt = regex['img'].search(line).group(1)
    4892. 

  4892. 		tag = TAGS['img']
    4893. 

  4893. 		
    4894. 

  4894. 		# If target supports image alignment, here we go
    4895. 

  4895. 		if rules['imgalignable']:
    4896. 

  4896. 			
    4897. 

  4897. 			align = get_image_align(line)         # right
    4898. 

  4898. 			align_name = align.capitalize()       # Right
    4899. 

  4899. 			
    4900. 

  4900. 			# The align is a full tag, or part of the image tag (~A~)
    4901. 

  4901. 			if TAGS['imgAlign'+align_name]:
    4902. 

  4902. 				tag = TAGS['imgAlign'+align_name]
    4903. 

  4903. 			else:
    4904. 

  4904. 				align_tag = TAGS['_imgAlign'+align_name]
    4905. 

  4905. 				tag = regex['_imgAlign'].sub(align_tag, tag, 1)
    4906. 

  4906. 				
    4907. 

  4907. 			# Dirty fix to allow centered solo images
    4908. 

  4908. 			if align == 'center' and TARGET in ('html','xhtml'):
    4909. 

  4909. 				rest = regex['img'].sub('',line,1)
    4910. 

  4910. 				if re.match('^\s+$', rest):
    4911. 

  4911. 					tag = "<center>%s</center>" %tag
    4912. 

  4912. 		
    4913. 

  4913. 		if TARGET == 'tex':
    4914. 

  4914. 			tag = re.sub(r'\\b',r'\\\\b',tag)
    4915. 

  4915. 			txt = txt.replace('_', 'vvvvTexUndervvvv')
    4916. 

  4916. 		
    4917. 

  4917. 		# Ugly hack to avoid infinite loop when target's image tag contains []
    4918. 

  4918. 		tag = tag.replace('[', 'vvvvEscapeSquareBracketvvvv')
    4919. 

  4919. 		
    4920. 

  4920. 		line = regex['img'].sub(tag,line,1)
    4921. 

  4921. 		line = regex['x'].sub(txt,line,1)
    4922. 

  4922. 	return line.replace('vvvvEscapeSquareBracketvvvv','[')
    4923. 

  4923. 

  4924. 

  4925. def add_inline_tags(line):
    4926. 

  4926. 	# Beautifiers
    4927. 

  4927. 	for beauti in ('bold', 'italic', 'underline', 'strike'):
    4928. 

  4928. 		if regex['font%s'%beauti.capitalize()].search(line):
    4929. 

  4929. 			line = beautify_me(beauti, line)
    4930. 

  4930. 	
    4931. 

  4931. 	line = parse_images(line)
    4932. 

  4932. 	return line
    4933. 

  4933. 

  4934. 

  4935. def get_include_contents(file_, path=''):
    4936. 

  4936. 	"Parses %!include: value and extract file contents"
    4937. 

  4937. 	ids = {'`':'verb', '"':'raw', "'":'tagged' }
    4938. 

  4938. 	id_ = 't2t'
    4939. 

  4939. 	# Set include type and remove identifier marks
    4940. 

  4940. 	mark = file_[0]
    4941. 

  4941. 	if mark in ids.keys():
    4942. 

  4942. 		if file_[:2] == file_[-2:] == mark*2:
    4943. 

  4943. 			id_ = ids[mark]      # set type
    4944. 

  4944. 			file_ = file_[2:-2]  # remove marks
    4945. 

  4945. 	# Handle remote dir execution
    4946. 

  4946. 	filepath = os.path.join(path, file_)
    4947. 

  4947. 	# Read included file contents
    4948. 

  4948. 	lines = Readfile(filepath, remove_linebreaks=1)
    4949. 

  4949. 	# Default txt2tags marked text, just BODY matters
    4950. 

  4950. 	if id_ == 't2t':
    4951. 

  4951. 		lines = get_file_body(filepath)
    4952. 

  4952. 		#TODO fix images relative path if file has a path, ie.: chapter1/index.t2t (wait until tree parsing)
    4953. 

  4953. 		#TODO for the images path fix, also respect outfile path, if different from infile (wait until tree parsing)
    4954. 

  4954. 		lines.insert(0, '%%INCLUDED(%s) starts here: %s'%(id_,file_))
    4955. 

  4955. 		# This appears when included hit EOF with verbatim area open
    4956. 

  4956. 		#lines.append('%%INCLUDED(%s) ends here: %s'%(id_,file_))
    4957. 

  4957. 	return id_, lines
    4958. 

  4958. 

  4959. 

  4960. def set_global_config(config):
    4961. 

  4961. 	global CONF, TAGS, regex, rules, TARGET
    4962. 

  4962. 	CONF   = config
    4963. 

  4963. 	rules  = getRules(CONF)
    4964. 

  4964. 	TAGS   = getTags(CONF)
    4965. 

  4965. 	regex  = getRegexes()
    4966. 

  4966. 	TARGET = config['target']  # save for buggy functions that need global
    4967. 

  4967. 

  4968. 

  4969. def convert(bodylines, config, firstlinenr=1):
    4970. 

  4970. 	global BLOCK, TITLE
    4971. 

  4971. 	
    4972. 

  4972. 	set_global_config(config)
    4973. 

  4973. 	
    4974. 

  4974. 	target = config['target']
    4975. 

  4975. 	BLOCK = BlockMaster()
    4976. 

  4976. 	MASK  =  MaskMaster()
    4977. 

  4977. 	TITLE = TitleMaster()
    4978. 

  4978. 	
    4979. 

  4979. 	ret = []
    4980. 

  4980. 	dump_source = []
    4981. 

  4981. 	f_lastwasblank = 0
    4982. 

  4982. 	
    4983. 

  4983. 	# Compiling all PreProc regexes
    4984. 

  4984. 	pre_filter = compile_filters(
    4985. 

  4985. 		CONF['preproc'], _('Invalid PreProc filter regex'))
    4986. 

  4986. 	
    4987. 

  4987. 	# Let's mark it up!
    4988. 

  4988. 	linenr = firstlinenr-1
    4989. 

  4989. 	lineref = 0
    4990. 

  4990. 	while lineref < len(bodylines):
    4991. 

  4991. 		# Defaults
    4992. 

  4992. 		MASK.reset()
    4993. 

  4993. 		results_box = ''
    4994. 

  4994. 		
    4995. 

  4995. 		untouchedline = bodylines[lineref]
    4996. 

  4996. 		dump_source.append(untouchedline)
    4997. 

  4997. 		
    4998. 

  4998. 		line = re.sub('[\n\r]+$','',untouchedline)   # del line break
    4999. 

  4999. 		
    5000. 

  5000. 		# Apply PreProc filters
    5001. 

  5001. 		if pre_filter:
    5002. 

  5002. 			errmsg = _('Invalid PreProc filter replacement')
    5003. 

  5003. 			for rgx,repl in pre_filter:
    5004. 

  5004. 				try: line = rgx.sub(repl, line)
    5005. 

  5005. 				except: Error("%s: '%s'"%(errmsg, repl))
    5006. 

  5006. 		
    5007. 

  5007. 		line = maskEscapeChar(line)                  # protect \ char
    5008. 

  5008. 		linenr  += 1
    5009. 

  5009. 		lineref += 1
    5010. 

  5010. 		
    5011. 

  5011. 		Debug(repr(line), 2, linenr)  # heavy debug: show each line
    5012. 

  5012. 		
    5013. 

  5013. 		#------------------[ Comment Block ]------------------------
    5014. 

  5014. 		
    5015. 

  5015. 		# We're already on a comment block
    5016. 

  5016. 		if BLOCK.block() == 'comment':
    5017. 

  5017. 		
    5018. 

  5018. 			# Closing comment
    5019. 

  5019. 			if regex['blockCommentClose'].search(line):
    5020. 

  5020. 				ret.extend(BLOCK.blockout() or [])
    5021. 

  5021. 				continue
    5022. 

  5022. 			
    5023. 

  5023. 			# Normal comment-inside line. Ignore it.
    5024. 

  5024. 			continue
    5025. 

  5025. 		
    5026. 

  5026. 		# Detecting comment block init
    5027. 

  5027. 		if regex['blockCommentOpen'].search(line) \
    5028. 

  5028. 		   and BLOCK.block() not in BLOCK.exclusive:
    5029. 

  5029. 			ret.extend(BLOCK.blockin('comment'))
    5030. 

  5030. 			continue
    5031. 

  5031. 

  5032. 		#-------------------------[ Tagged Text ]----------------------
    5033. 

  5033. 

  5034. 		# We're already on a tagged block
    5035. 

  5035. 		if BLOCK.block() == 'tagged':
    5036. 

  5036. 		
    5037. 

  5037. 			# Closing tagged
    5038. 

  5038. 			if regex['blockTaggedClose'].search(line):
    5039. 

  5039. 				ret.extend(BLOCK.blockout())
    5040. 

  5040. 				continue
    5041. 

  5041. 			
    5042. 

  5042. 			# Normal tagged-inside line
    5043. 

  5043. 			BLOCK.holdadd(line)
    5044. 

  5044. 			continue
    5045. 

  5045. 		
    5046. 

  5046. 		# Detecting tagged block init
    5047. 

  5047. 		if regex['blockTaggedOpen'].search(line) \
    5048. 

  5048. 		   and BLOCK.block() not in BLOCK.exclusive:
    5049. 

  5049. 			ret.extend(BLOCK.blockin('tagged'))
    5050. 

  5050. 			continue
    5051. 

  5051. 		
    5052. 

  5052. 		# One line tagged text
    5053. 

  5053. 		if regex['1lineTagged'].search(line) \
    5054. 

  5054. 		   and BLOCK.block() not in BLOCK.exclusive:
    5055. 

  5055. 			ret.extend(BLOCK.blockin('tagged'))
    5056. 

  5056. 			line = regex['1lineTagged'].sub('',line)
    5057. 

  5057. 			BLOCK.holdadd(line)
    5058. 

  5058. 			ret.extend(BLOCK.blockout())
    5059. 

  5059. 			continue
    5060. 

  5060. 		
    5061. 

  5061. 		#-------------------------[ Raw Text ]----------------------
    5062. 

  5062. 		
    5063. 

  5063. 		# We're already on a raw block
    5064. 

  5064. 		if BLOCK.block() == 'raw':
    5065. 

  5065. 		
    5066. 

  5066. 			# Closing raw
    5067. 

  5067. 			if regex['blockRawClose'].search(line):
    5068. 

  5068. 				ret.extend(BLOCK.blockout())
    5069. 

  5069. 				continue
    5070. 

  5070. 			
    5071. 

  5071. 			# Normal raw-inside line
    5072. 

  5072. 			BLOCK.holdadd(line)
    5073. 

  5073. 			continue
    5074. 

  5074. 		
    5075. 

  5075. 		# Detecting raw block init
    5076. 

  5076. 		if regex['blockRawOpen'].search(line) \
    5077. 

  5077. 		   and BLOCK.block() not in BLOCK.exclusive:
    5078. 

  5078. 			ret.extend(BLOCK.blockin('raw'))
    5079. 

  5079. 			continue
    5080. 

  5080. 		
    5081. 

  5081. 		# One line raw text
    5082. 

  5082. 		if regex['1lineRaw'].search(line) \
    5083. 

  5083. 		   and BLOCK.block() not in BLOCK.exclusive:
    5084. 

  5084. 			ret.extend(BLOCK.blockin('raw'))
    5085. 

  5085. 			line = regex['1lineRaw'].sub('',line)
    5086. 

  5086. 			BLOCK.holdadd(line)
    5087. 

  5087. 			ret.extend(BLOCK.blockout())
    5088. 

  5088. 			continue
    5089. 

  5089. 		
    5090. 

  5090. 		#------------------------[ Verbatim  ]----------------------
    5091. 

  5091. 		
    5092. 

  5092. 		#TIP We'll never support beautifiers inside verbatim
    5093. 

  5093. 		
    5094. 

  5094. 		# Closing table mapped to verb
    5095. 

  5095. 		if BLOCK.block() == 'verb' \
    5096. 

  5096. 		   and BLOCK.prop('mapped') == 'table' \
    5097. 

  5097. 		   and not regex['table'].search(line):
    5098. 

  5098. 			ret.extend(BLOCK.blockout())
    5099. 

  5099. 		
    5100. 

  5100. 		# We're already on a verb block
    5101. 

  5101. 		if BLOCK.block() == 'verb':
    5102. 

  5102. 			
    5103. 

  5103. 			# Closing verb
    5104. 

  5104. 			if regex['blockVerbClose'].search(line):
    5105. 

  5105. 				ret.extend(BLOCK.blockout())
    5106. 

  5106. 				continue
    5107. 

  5107. 			
    5108. 

  5108. 			# Normal verb-inside line
    5109. 

  5109. 			BLOCK.holdadd(line)
    5110. 

  5110. 			continue
    5111. 

  5111. 		
    5112. 

  5112. 		# Detecting verb block init
    5113. 

  5113. 		if regex['blockVerbOpen'].search(line) \
    5114. 

  5114. 		   and BLOCK.block() not in BLOCK.exclusive:
    5115. 

  5115. 			ret.extend(BLOCK.blockin('verb'))
    5116. 

  5116. 			f_lastwasblank = 0
    5117. 

  5117. 			continue
    5118. 

  5118. 		
    5119. 

  5119. 		# One line verb-formatted text
    5120. 

  5120. 		if regex['1lineVerb'].search(line) \
    5121. 

  5121. 		   and BLOCK.block() not in BLOCK.exclusive:
    5122. 

  5122. 			ret.extend(BLOCK.blockin('verb'))
    5123. 

  5123. 			line = regex['1lineVerb'].sub('',line)
    5124. 

  5124. 			BLOCK.holdadd(line)
    5125. 

  5125. 			ret.extend(BLOCK.blockout())
    5126. 

  5126. 			f_lastwasblank = 0
    5127. 

  5127. 			continue
    5128. 

  5128. 		
    5129. 

  5129. 		# Tables are mapped to verb when target is not table-aware
    5130. 

  5130. 		if not rules['tableable'] and regex['table'].search(line):
    5131. 

  5131. 			if not BLOCK.isblock('verb'):
    5132. 

  5132. 				ret.extend(BLOCK.blockin('verb'))
    5133. 

  5133. 				BLOCK.propset('mapped', 'table')
    5134. 

  5134. 				BLOCK.holdadd(line)
    5135. 

  5135. 				continue
    5136. 

  5136. 		
    5137. 

  5137. 		#---------------------[ blank lines ]-----------------------
    5138. 

  5138. 		
    5139. 

  5139. 		if regex['blankline'].search(line):
    5140. 

  5140. 			
    5141. 

  5141. 			# Close open paragraph
    5142. 

  5142. 			if BLOCK.isblock('para'):
    5143. 

  5143. 				ret.extend(BLOCK.blockout())
    5144. 

  5144. 				f_lastwasblank = 1
    5145. 

  5145. 				continue
    5146. 

  5146. 			
    5147. 

  5147. 			# Close all open tables
    5148. 

  5148. 			if BLOCK.isblock('table'):
    5149. 

  5149. 				ret.extend(BLOCK.blockout())
    5150. 

  5150. 				f_lastwasblank = 1
    5151. 

  5151. 				continue
    5152. 

  5152. 			
    5153. 

  5153. 			# Close all open quotes
    5154. 

  5154. 			while BLOCK.isblock('quote'):
    5155. 

  5155. 				ret.extend(BLOCK.blockout())
    5156. 

  5156. 			
    5157. 

  5157. 			# Closing all open lists
    5158. 

  5158. 			if f_lastwasblank:          # 2nd consecutive blank
    5159. 

  5159. 				if BLOCK.block().endswith('list'):
    5160. 

  5160. 					BLOCK.holdaddsub('')   # helps parser
    5161. 

  5161. 				while BLOCK.depth:  # closes list (if any)
    5162. 

  5162. 					ret.extend(BLOCK.blockout())
    5163. 

  5163. 				continue            # ignore consecutive blanks
    5164. 

  5164. 			
    5165. 

  5165. 			# Paragraph (if any) is wanted inside lists also
    5166. 

  5166. 			if BLOCK.block().endswith('list'):
    5167. 

  5167. 				BLOCK.holdaddsub('')
    5168. 

  5168. 			
    5169. 

  5169. 			f_lastwasblank = 1
    5170. 

  5170. 			continue
    5171. 

  5171. 		
    5172. 

  5172. 		
    5173. 

  5173. 		#---------------------[ special ]---------------------------
    5174. 

  5174. 		
    5175. 

  5175. 		if regex['special'].search(line):
    5176. 

  5176. 			
    5177. 

  5177. 			targ, key, val = ConfigLines().parse_line(line, None, target)
    5178. 

  5178. 			
    5179. 

  5179. 			if key:
    5180. 

  5180. 				Debug("Found config '%s', value '%s'" % (key, val), 1, linenr)
    5181. 

  5181. 			else:
    5182. 

  5182. 				Debug('Bogus Special Line', 1, linenr)
    5183. 

  5183. 				
    5184. 

  5184. 			# %!include command
    5185. 

  5185. 			if key == 'include':
    5186. 

  5186. 						
    5187. 

  5187. 				incpath = os.path.dirname(CONF['sourcefile'])
    5188. 

  5188. 				incfile = val
    5189. 

  5189. 				err = _('A file cannot include itself (loop!)')
    5190. 

  5190. 				if CONF['sourcefile'] == incfile:
    5191. 

  5191. 					Error("%s: %s"%(err,incfile))
    5192. 

  5192. 				inctype, inclines = get_include_contents(incfile, incpath)
    5193. 

  5193. 				
    5194. 

  5194. 				# Verb, raw and tagged are easy
    5195. 

  5195. 				if inctype != 't2t':
    5196. 

  5196. 					ret.extend(BLOCK.blockin(inctype))
    5197. 

  5197. 					BLOCK.holdextend(inclines)
    5198. 

  5198. 					ret.extend(BLOCK.blockout())
    5199. 

  5199. 				else:
    5200. 

  5200. 					# Insert include lines into body
    5201. 

  5201. 					#TODO include maxdepth limit
    5202. 

  5202. 					bodylines = bodylines[:lineref] + inclines + bodylines[lineref:]
    5203. 

  5203. 					#TODO fix path if include@include
    5204. 

  5204. 					# Remove %!include call
    5205. 

  5205. 					if CONF['dump-source']:
    5206. 

  5206. 						dump_source.pop()
    5207. 

  5207. 				
    5208. 

  5208. 				# This line is done, go to next
    5209. 

  5209. 				continue
    5210. 

  5210. 				
    5211. 

  5211. 			# %!csv command
    5212. 

  5212. 			elif key == 'csv':
    5213. 

  5213. 

  5214. 				if not csv:
    5215. 

  5215. 					Error("Python module 'csv' not found, but needed for %!csv")
    5216. 

  5216. 

  5217. 				table = []
    5218. 

  5218. 				filename = val
    5219. 

  5219. 				reader = csv.reader(Readfile(filename))
    5220. 

  5220. 				
    5221. 

  5221. 				# Convert each CSV line to a txt2tags' table line
    5222. 

  5222. 				# foo,bar,baz -> | foo | bar | baz |
    5223. 

  5223. 				try:
    5224. 

  5224. 					for row in reader:
    5225. 

  5225. 						table.append('| %s |' % ' | '.join(row))
    5226. 

  5226. 				except csv.Error, e:
    5227. 

  5227. 					Error('CSV: file %s: %s' % (filename, e))
    5228. 

  5228. 

  5229. 				# Parse and convert the new table
    5230. 

  5230. 				# Note: cell contents is raw, no t2t marks are parsed
    5231. 

  5231. 				if rules['tableable']:
    5232. 

  5232. 					ret.extend(BLOCK.blockin('table'))
    5233. 

  5233. 					if table:
    5234. 

  5234. 						BLOCK.tableparser.__init__(table[0])
    5235. 

  5235. 						for row in table:
    5236. 

  5236. 							tablerow = TableMaster().parse_row(row)
    5237. 

  5237. 							BLOCK.tableparser.add_row(tablerow)
    5238. 

  5238. 							
    5239. 

  5239. 							# Very ugly, but necessary for escapes
    5240. 

  5240. 							line = SEPARATOR.join(tablerow['cells'])
    5241. 

  5241. 							BLOCK.holdadd(doEscape(target, line))
    5242. 

  5242. 						ret.extend(BLOCK.blockout())
    5243. 

  5243. 

  5244. 				# Tables are mapped to verb when target is not table-aware
    5245. 

  5245. 				else:
    5246. 

  5246. 					if target == 'art' and table:
    5247. 

  5247. 						table = aa_table(table)
    5248. 

  5248. 					ret.extend(BLOCK.blockin('verb'))
    5249. 

  5249. 					BLOCK.propset('mapped', 'table')
    5250. 

  5250. 					for row in table:
    5251. 

  5251. 						BLOCK.holdadd(row)
    5252. 

  5252. 					ret.extend(BLOCK.blockout())
    5253. 

  5253. 					
    5254. 

  5254. 				# This line is done, go to next
    5255. 

  5255. 				continue
    5256. 

  5256. 					
    5257. 

  5257. 		#---------------------[ dump-source ]-----------------------
    5258. 

  5258. 		
    5259. 

  5259. 		# We don't need to go any further
    5260. 

  5260. 		if CONF['dump-source']:
    5261. 

  5261. 			continue
    5262. 

  5262. 		
    5263. 

  5263. 		#---------------------[ Comments ]--------------------------
    5264. 

  5264. 		
    5265. 

  5265. 		# Just skip them (if not macro)
    5266. 

  5266. 		if regex['comment'].search(line) and not \
    5267. 

  5267. 		   regex['macros'].match(line) and not \
    5268. 

  5268. 		   regex['toc'].match(line):
    5269. 

  5269. 			continue
    5270. 

  5270. 		
    5271. 

  5271. 		#---------------------[ Triggers ]--------------------------
    5272. 

  5272. 		
    5273. 

  5273. 		# Valid line, reset blank status
    5274. 

  5274. 		f_lastwasblank = 0
    5275. 

  5275. 		
    5276. 

  5276. 		# Any NOT quote line closes all open quotes
    5277. 

  5277. 		if BLOCK.isblock('quote') and not regex['quote'].search(line):
    5278. 

  5278. 			while BLOCK.isblock('quote'):
    5279. 

  5279. 				ret.extend(BLOCK.blockout())
    5280. 

  5280. 		
    5281. 

  5281. 		# Any NOT table line closes an open table
    5282. 

  5282. 		if BLOCK.isblock('table') and not regex['table'].search(line):
    5283. 

  5283. 			ret.extend(BLOCK.blockout())
    5284. 

  5284. 		
    5285. 

  5285. 		
    5286. 

  5286. 		#---------------------[ Horizontal Bar ]--------------------
    5287. 

  5287. 

  5288. 		if regex['bar'].search(line):
    5289. 

  5289. 

  5290. 			# Bars inside quotes are handled on the Quote processing
    5291. 

  5291. 			# Otherwise we parse the bars right here
    5292. 

  5292. 			#
    5293. 

  5293. 			if not (BLOCK.isblock('quote') or regex['quote'].search(line)) \
    5294. 

  5294. 				or (BLOCK.isblock('quote') and not rules['barinsidequote']):
    5295. 

  5295. 

  5296. 				# Close all the opened blocks
    5297. 

  5297. 				ret.extend(BLOCK.blockin('bar'))
    5298. 

  5298. 

  5299. 				# Extract the bar chars (- or =)
    5300. 

  5300. 				m = regex['bar'].search(line)
    5301. 

  5301. 				bar_chars = m.group(2)
    5302. 

  5302. 

  5303. 				# Process and dump the tagged bar
    5304. 

  5304. 				BLOCK.holdadd(bar_chars)
    5305. 

  5305. 				ret.extend(BLOCK.blockout())
    5306. 

  5306. 				Debug("BAR: %s"%line, 6)
    5307. 

  5307. 

  5308. 				# We're done, nothing more to process
    5309. 

  5309. 				continue
    5310. 

  5310. 

  5311. 

  5312. 		#---------------------[ Title ]-----------------------------
    5313. 

  5313. 		
    5314. 

  5314. 		if (regex['title'].search(line) or regex['numtitle'].search(line)) \
    5315. 

  5315. 			and not BLOCK.block().endswith('list'):
    5316. 

  5316. 

  5317. 			if regex['title'].search(line):
    5318. 

  5318. 				name = 'title'
    5319. 

  5319. 			else:
    5320. 

  5320. 				name = 'numtitle'
    5321. 

  5321. 			
    5322. 

  5322. 			# Close all the opened blocks
    5323. 

  5323. 			ret.extend(BLOCK.blockin(name))
    5324. 

  5324. 			
    5325. 

  5325. 			# Process title
    5326. 

  5326. 			TITLE.add(line)
    5327. 

  5327. 			ret.extend(BLOCK.blockout())
    5328. 

  5328. 			
    5329. 

  5329. 			# We're done, nothing more to process
    5330. 

  5330. 			continue
    5331. 

  5331. 		
    5332. 

  5332. 		#---------------------[ %%toc ]-----------------------
    5333. 

  5333. 		
    5334. 

  5334. 		# %%toc line closes paragraph
    5335. 

  5335. 		if BLOCK.block() == 'para' and regex['toc'].search(line):
    5336. 

  5336. 			ret.extend(BLOCK.blockout())
    5337. 

  5337. 		
    5338. 

  5338. 		#---------------------[ apply masks ]-----------------------
    5339. 

  5339. 		
    5340. 

  5340. 		line = MASK.mask(line)
    5341. 

  5341. 		
    5342. 

  5342. 		#XXX from here, only block-inside lines will pass
    5343. 

  5343. 		
    5344. 

  5344. 		#---------------------[ Quote ]-----------------------------
    5345. 

  5345. 		
    5346. 

  5346. 		if regex['quote'].search(line):
    5347. 

  5347. 			
    5348. 

  5348. 			# Store number of leading TABS
    5349. 

  5349. 			quotedepth = len(regex['quote'].search(line).group(0))
    5350. 

  5350. 			
    5351. 

  5351. 			# SGML doesn't support nested quotes
    5352. 

  5352. 			if rules['quotenotnested']: quotedepth = 1
    5353. 

  5353. 			
    5354. 

  5354. 			# Don't cross depth limit
    5355. 

  5355. 			maxdepth = rules['quotemaxdepth']
    5356. 

  5356. 			if maxdepth and quotedepth > maxdepth:
    5357. 

  5357. 				quotedepth = maxdepth
    5358. 

  5358. 			
    5359. 

  5359. 			# New quote
    5360. 

  5360. 			if not BLOCK.isblock('quote'):
    5361. 

  5361. 				ret.extend(BLOCK.blockin('quote'))
    5362. 

  5362. 			
    5363. 

  5363. 			# New subquotes
    5364. 

  5364. 			while BLOCK.depth < quotedepth:
    5365. 

  5365. 				BLOCK.blockin('quote')
    5366. 

  5366. 			
    5367. 

  5367. 			# Closing quotes
    5368. 

  5368. 			while quotedepth < BLOCK.depth:
    5369. 

  5369. 				ret.extend(BLOCK.blockout())
    5370. 

  5370. 			
    5371. 

  5371. 			# Bar inside quote
    5372. 

  5372. 			if regex['bar'].search(line) and rules['barinsidequote']:
    5373. 

  5373. 				tempBlock = BlockMaster()
    5374. 

  5374. 				tagged_bar = []
    5375. 

  5375. 				tagged_bar.extend(tempBlock.blockin('bar'))
    5376. 

  5376. 				tempBlock.holdadd(line)
    5377. 

  5377. 				tagged_bar.extend(tempBlock.blockout())
    5378. 

  5378. 				BLOCK.holdextend(tagged_bar)
    5379. 

  5379. 				continue
    5380. 

  5380. 

  5381. 		#---------------------[ Lists ]-----------------------------
    5382. 

  5382. 		
    5383. 

  5383. 		# An empty item also closes the current list
    5384. 

  5384. 		if BLOCK.block().endswith('list'):
    5385. 

  5385. 			m = regex['listclose'].match(line)
    5386. 

  5386. 			if m:
    5387. 

  5387. 				listindent = m.group(1)
    5388. 

  5388. 				listtype = m.group(2)
    5389. 

  5389. 				currlisttype = BLOCK.prop('type')
    5390. 

  5390. 				currlistindent = BLOCK.prop('indent')
    5391. 

  5391. 				if listindent == currlistindent and \
    5392. 

  5392. 				   listtype == currlisttype:
    5393. 

  5393. 					ret.extend(BLOCK.blockout())
    5394. 

  5394. 					continue
    5395. 

  5395. 		
    5396. 

  5396. 		if   regex['list'].search(line) or \
    5397. 

  5397. 		  regex['numlist'].search(line) or \
    5398. 

  5398. 		  regex['deflist'].search(line):
    5399. 

  5399. 			
    5400. 

  5400. 			listindent = BLOCK.prop('indent')
    5401. 

  5401. 			listids = ''.join(LISTNAMES.keys())
    5402. 

  5402. 			m = re.match('^( *)([%s]) '%listids, line)
    5403. 

  5403. 			listitemindent = m.group(1)
    5404. 

  5404. 			listtype = m.group(2)
    5405. 

  5405. 			listname = LISTNAMES[listtype]
    5406. 

  5406. 			results_box = BLOCK.holdadd
    5407. 

  5407. 			
    5408. 

  5408. 			# Del list ID (and separate term from definition)
    5409. 

  5409. 			if listname == 'deflist':
    5410. 

  5410. 				term = parse_deflist_term(line)
    5411. 

  5411. 				line = regex['deflist'].sub(
    5412. 

  5412. 					SEPARATOR+term+SEPARATOR,line)
    5413. 

  5413. 			else:
    5414. 

  5414. 				line = regex[listname].sub(SEPARATOR,line)
    5415. 

  5415. 			
    5416. 

  5416. 			# Don't cross depth limit
    5417. 

  5417. 			maxdepth = rules['listmaxdepth']
    5418. 

  5418. 			if maxdepth and BLOCK.depth == maxdepth:
    5419. 

  5419. 				if len(listitemindent) > len(listindent):
    5420. 

  5420. 					listitemindent = listindent
    5421. 

  5421. 			
    5422. 

  5422. 			# List bumping (same indent, diff mark)
    5423. 

  5423. 			# Close the currently open list to clear the mess
    5424. 

  5424. 			if BLOCK.block().endswith('list') \
    5425. 

  5425. 			   and listname != BLOCK.block() \
    5426. 

  5426. 			   and len(listitemindent) == len(listindent):
    5427. 

  5427. 				ret.extend(BLOCK.blockout())
    5428. 

  5428. 				listindent = BLOCK.prop('indent')
    5429. 

  5429. 			
    5430. 

  5430. 			# Open mother list or sublist
    5431. 

  5431. 			if not BLOCK.block().endswith('list') or \
    5432. 

  5432. 			   len(listitemindent) > len(listindent):
    5433. 

  5433. 				ret.extend(BLOCK.blockin(listname))
    5434. 

  5434. 				BLOCK.propset('indent',listitemindent)
    5435. 

  5435. 				BLOCK.propset('type',listtype)
    5436. 

  5436. 			
    5437. 

  5437. 			# Closing sublists
    5438. 

  5438. 			while len(listitemindent) < len(BLOCK.prop('indent')):
    5439. 

  5439. 				ret.extend(BLOCK.blockout())
    5440. 

  5440. 			
    5441. 

  5441. 			# O-oh, sublist before list ("\n\n  - foo\n- foo")
    5442. 

  5442. 			# Fix: close sublist (as mother), open another list
    5443. 

  5443. 			if not BLOCK.block().endswith('list'):
    5444. 

  5444. 				ret.extend(BLOCK.blockin(listname))
    5445. 

  5445. 				BLOCK.propset('indent',listitemindent)
    5446. 

  5446. 				BLOCK.propset('type',listtype)
    5447. 

  5447. 		
    5448. 

  5448. 		#---------------------[ Table ]-----------------------------
    5449. 

  5449. 		
    5450. 

  5450. 		#TODO escape undesired format inside table
    5451. 

  5451. 		#TODO add pm6 target
    5452. 

  5452. 		if regex['table'].search(line):
    5453. 

  5453. 			
    5454. 

  5454. 			if not BLOCK.isblock('table'):   # first table line!
    5455. 

  5455. 				ret.extend(BLOCK.blockin('table'))
    5456. 

  5456. 				BLOCK.tableparser.__init__(line)
    5457. 

  5457. 			
    5458. 

  5458. 			tablerow = TableMaster().parse_row(line)
    5459. 

  5459. 			BLOCK.tableparser.add_row(tablerow)     # save config
    5460. 

  5460. 			
    5461. 

  5461. 			# Maintain line to unmask and inlines
    5462. 

  5462. 			# XXX Bug: | **bo | ld** | turns **bo\x01ld** and gets converted :(
    5463. 

  5463. 			# TODO isolate unmask+inlines parsing to use here
    5464. 

  5464. 			line = SEPARATOR.join(tablerow['cells'])
    5465. 

  5465. 		
    5466. 

  5466. 		#---------------------[ Paragraph ]-------------------------
    5467. 

  5467. 		
    5468. 

  5468. 		if not BLOCK.block() and \
    5469. 

  5469. 		   not line.count(MASK.tocmask): # new para!
    5470. 

  5470. 			ret.extend(BLOCK.blockin('para'))
    5471. 

  5471. 		
    5472. 

  5472. 		
    5473. 

  5473. 		############################################################
    5474. 

  5474. 		############################################################
    5475. 

  5475. 		############################################################
    5476. 

  5476. 		
    5477. 

  5477. 		
    5478. 

  5478. 		#---------------------[ Final Parses ]----------------------
    5479. 

  5479. 		
    5480. 

  5480. 		# The target-specific special char escapes for body lines
    5481. 

  5481. 		line = doEscape(target,line)
    5482. 

  5482. 		
    5483. 

  5483. 		line = add_inline_tags(line)
    5484. 

  5484. 		line = MASK.undo(line)
    5485. 

  5485. 		
    5486. 

  5486. 		
    5487. 

  5487. 		#---------------------[ Hold or Return? ]-------------------
    5488. 

  5488. 		
    5489. 

  5489. 		### Now we must choose where to put the parsed line
    5490. 

  5490. 		#
    5491. 

  5491. 		if not results_box:
    5492. 

  5492. 			# List item extra lines
    5493. 

  5493. 			if BLOCK.block().endswith('list'):
    5494. 

  5494. 				results_box = BLOCK.holdaddsub
    5495. 

  5495. 			# Other blocks
    5496. 

  5496. 			elif BLOCK.block():
    5497. 

  5497. 				results_box = BLOCK.holdadd
    5498. 

  5498. 			# No blocks
    5499. 

  5499. 			else:
    5500. 

  5500. 				line = doFinalEscape(target, line)
    5501. 

  5501. 				results_box = ret.append
    5502. 

  5502. 		
    5503. 

  5503. 		results_box(line)
    5504. 

  5504. 	
    5505. 

  5505. 	# EOF: close any open para/verb/lists/table/quotes
    5506. 

  5506. 	Debug('EOF',7)
    5507. 

  5507. 	while BLOCK.block():
    5508. 

  5508. 		ret.extend(BLOCK.blockout())
    5509. 

  5509. 	
    5510. 

  5510. 	# Maybe close some opened title area?
    5511. 

  5511. 	if rules['titleblocks']:
    5512. 

  5512. 		ret.extend(TITLE.close_all())
    5513. 

  5513. 	
    5514. 

  5514. 	# Maybe a major tag to enclose body? (like DIV for CSS)
    5515. 

  5515. 	if TAGS['bodyOpen' ]: ret.insert(0, TAGS['bodyOpen'])
    5516. 

  5516. 	if TAGS['bodyClose']: ret.append(TAGS['bodyClose'])
    5517. 

  5517. 	
    5518. 

  5518. 	if CONF['toc-only']: ret = []
    5519. 

  5519. 	marked_toc = TITLE.dump_marked_toc(CONF['toc-level'])
    5520. 

  5520. 	
    5521. 

  5521. 	# If dump-source, all parsing is ignored
    5522. 

  5522. 	if CONF['dump-source']: ret = dump_source[:]
    5523. 

  5523. 	
    5524. 

  5524. 	return ret, marked_toc
    5525. 

  5525. 

  5526. 

  5527. 

  5528. ##############################################################################
    5529. 

  5529. ################################### GUI ######################################
    5530. 

  5530. ##############################################################################
    5531. 

  5531. #
    5532. 

  5532. # Tk help: http://python.org/topics/tkinter/
    5533. 

  5533. #    Tuto: http://ibiblio.org/obp/py4fun/gui/tkPhone.html
    5534. 

  5534. #          /usr/lib/python*/lib-tk/Tkinter.py
    5535. 

  5535. #
    5536. 

  5536. # grid table : row=0, column=0, columnspan=2, rowspan=2
    5537. 

  5537. # grid align : sticky='n,s,e,w' (North, South, East, West)
    5538. 

  5538. # pack place : side='top,bottom,right,left'
    5539. 

  5539. # pack fill  : fill='x,y,both,none', expand=1
    5540. 

  5540. # pack align : anchor='n,s,e,w' (North, South, East, West)
    5541. 

  5541. # padding    : padx=10, pady=10, ipadx=10, ipady=10 (internal)
    5542. 

  5542. # checkbox   : offvalue is return if the _user_ deselected the box
    5543. 

  5543. # label align: justify=left,right,center
    5544. 

  5544. 

  5545. def load_GUI_resources():
    5546. 

  5546. 	"Load all extra modules and methods used by GUI"
    5547. 

  5547. 	global askopenfilename, showinfo, showwarning, showerror, Tkinter
    5548. 

  5548. 	from tkFileDialog import askopenfilename
    5549. 

  5549. 	from tkMessageBox import showinfo,showwarning,showerror
    5550. 

  5550. 	import Tkinter
    5551. 

  5551. 

  5552. class Gui:
    5553. 

  5553. 	"Graphical Tk Interface"
    5554. 

  5554. 	def __init__(self, conf={}):
    5555. 

  5555. 		self.root = Tkinter.Tk()    # mother window, come to butthead
    5556. 

  5556. 		self.root.title(my_name)    # window title bar text
    5557. 

  5557. 		self.window = self.root     # variable "focus" for inclusion
    5558. 

  5558. 		self.row = 0                # row count for grid()
    5559. 

  5559. 		
    5560. 

  5560. 		self.action_length = 150    # left column length (pixel)
    5561. 

  5561. 		self.frame_margin  = 10     # frame margin size  (pixel)
    5562. 

  5562. 		self.frame_border  = 6      # frame border size  (pixel)
    5563. 

  5563. 		
    5564. 

  5564. 		# The default Gui colors, can be changed by %!guicolors
    5565. 

  5565. 		self.dft_gui_colors = ['#6c6','white','#cf9','#030']
    5566. 

  5566. 		self.gui_colors = []
    5567. 

  5567. 		self.bg1 = self.fg1 = self.bg2 = self.fg2 = ''
    5568. 

  5568. 		
    5569. 

  5569. 		# On Tk, vars need to be set/get using setvar()/get()
    5570. 

  5570. 		self.infile  = self.setvar('')
    5571. 

  5571. 		self.target  = self.setvar('')
    5572. 

  5572. 		self.target_name = self.setvar('')
    5573. 

  5573. 		
    5574. 

  5574. 		# The checks appearance order
    5575. 

  5575. 		self.checks = [
    5576. 

  5576. 			'headers', 'enum-title', 'toc', 'mask-email', 'toc-only', 'stdout'
    5577. 

  5577. 		]
    5578. 

  5578. 		
    5579. 

  5579. 		# Creating variables for all checks
    5580. 

  5580. 		for check in self.checks:
    5581. 

  5581. 			setattr(self, 'f_'+check, self.setvar(''))
    5582. 

  5582. 		
    5583. 

  5583. 		# Load RC config
    5584. 

  5584. 		self.conf = {}
    5585. 

  5585. 		if conf: self.load_config(conf)
    5586. 

  5586. 	
    5587. 

  5587. 	def load_config(self, conf):
    5588. 

  5588. 		self.conf = conf
    5589. 

  5589. 		self.gui_colors = conf.get('guicolors') or self.dft_gui_colors
    5590. 

  5590. 		self.bg1, self.fg1, self.bg2, self.fg2 = self.gui_colors
    5591. 

  5591. 		self.root.config(bd=15,bg=self.bg1)
    5592. 

  5592. 	
    5593. 

  5593. 	### Config as dic for python 1.5 compat (**opts don't work :( )
    5594. 

  5594. 	def entry(self, **opts): return Tkinter.Entry(self.window, opts)
    5595. 

  5595. 	def label(self, txt='', bg=None, **opts):
    5596. 

  5596. 		opts.update({'text':txt,'bg':bg or self.bg1})
    5597. 

  5597. 		return Tkinter.Label(self.window, opts)
    5598. 

  5598. 	def button(self,name,cmd,**opts):
    5599. 

  5599. 		opts.update({'text':name,'command':cmd})
    5600. 

  5600. 		return Tkinter.Button(self.window, opts)
    5601. 

  5601. 	def check(self,name,checked=0,**opts):
    5602. 

  5602. 		bg, fg = self.bg2, self.fg2
    5603. 

  5603. 		opts.update({
    5604. 

  5604. 			'text':name,
    5605. 

  5605. 			'onvalue':1,
    5606. 

  5606. 			'offvalue':0,
    5607. 

  5607. 			'activeforeground':fg,
    5608. 

  5608. 			'activebackground':bg,
    5609. 

  5609. 			'highlightbackground':bg,
    5610. 

  5610. 			'fg':fg,
    5611. 

  5611. 			'bg':bg,
    5612. 

  5612. 			'anchor':'w'
    5613. 

  5613. 		})
    5614. 

  5614. 		chk = Tkinter.Checkbutton(self.window, opts)
    5615. 

  5615. 		if checked: chk.select()
    5616. 

  5616. 		chk.grid(columnspan=2, sticky='w', padx=0)
    5617. 

  5617. 	def menu(self,sel,items):
    5618. 

  5618. 		return apply(Tkinter.OptionMenu,(self.window,sel)+tuple(items))
    5619. 

  5619. 	
    5620. 

  5620. 	# Handy auxiliary functions
    5621. 

  5621. 	def action(self, txt):
    5622. 

  5622. 		self.label(
    5623. 

  5623. 			txt,
    5624. 

  5624. 			fg=self.fg1,
    5625. 

  5625. 			bg=self.bg1,
    5626. 

  5626. 			wraplength=self.action_length).grid(column=0,row=self.row)
    5627. 

  5627. 	def frame_open(self):
    5628. 

  5628. 		self.window = Tkinter.Frame(
    5629. 

  5629. 			self.root,
    5630. 

  5630. 			bg=self.bg2,
    5631. 

  5631. 			borderwidth=self.frame_border)
    5632. 

  5632. 	def frame_close(self):
    5633. 

  5633. 		self.window.grid(
    5634. 

  5634. 			column=1,
    5635. 

  5635. 			row=self.row,
    5636. 

  5636. 			sticky='w',
    5637. 

  5637. 			padx=self.frame_margin)
    5638. 

  5638. 		self.window = self.root
    5639. 

  5639. 		self.label('').grid()
    5640. 

  5640. 		self.row += 2   # update row count
    5641. 

  5641. 	def target_name2key(self):
    5642. 

  5642. 		name = self.target_name.get()
    5643. 

  5643. 		target = filter(lambda x: TARGET_NAMES[x] == name, TARGETS)
    5644. 

  5644. 		try   : key = target[0]
    5645. 

  5645. 		except: key = ''
    5646. 

  5646. 		self.target = self.setvar(key)
    5647. 

  5647. 	def target_key2name(self):
    5648. 

  5648. 		key = self.target.get()
    5649. 

  5649. 		name = TARGET_NAMES.get(key) or key
    5650. 

  5650. 		self.target_name = self.setvar(name)
    5651. 

  5651. 	
    5652. 

  5652. 	def exit(self): self.root.destroy()
    5653. 

  5653. 	def setvar(self, val): z = Tkinter.StringVar() ; z.set(val) ; return z
    5654. 

  5654. 	
    5655. 

  5655. 	def askfile(self):
    5656. 

  5656. 		ftypes= [(_('txt2tags files'), ('*.t2t','*.txt')), (_('All files'),'*')]
    5657. 

  5657. 		newfile = askopenfilename(filetypes=ftypes)
    5658. 

  5658. 		if newfile:
    5659. 

  5659. 			self.infile.set(newfile)
    5660. 

  5660. 			newconf = process_source_file(newfile)[0]
    5661. 

  5661. 			newconf = ConfigMaster().sanity(newconf, gui=1)
    5662. 

  5662. 			# Restate all checkboxes after file selection
    5663. 

  5663. 			#TODO how to make a refresh without killing it?
    5664. 

  5664. 			self.root.destroy()
    5665. 

  5665. 			self.__init__(newconf)
    5666. 

  5666. 			self.mainwindow()
    5667. 

  5667. 	
    5668. 

  5668. 	def scrollwindow(self, txt='no text!', title=''):
    5669. 

  5669. 		# Create components
    5670. 

  5670. 		win    = Tkinter.Toplevel() ; win.title(title)
    5671. 

  5671. 		frame  = Tkinter.Frame(win)
    5672. 

  5672. 		scroll = Tkinter.Scrollbar(frame)
    5673. 

  5673. 		text   = Tkinter.Text(frame,yscrollcommand=scroll.set)
    5674. 

  5674. 		button = Tkinter.Button(win)
    5675. 

  5675. 		# Config
    5676. 

  5676. 		text.insert(Tkinter.END, '\n'.join(txt))
    5677. 

  5677. 		scroll.config(command=text.yview)
    5678. 

  5678. 		button.config(text=_('Close'), command=win.destroy)
    5679. 

  5679. 		button.focus_set()
    5680. 

  5680. 		# Packing
    5681. 

  5681. 		text.pack(side='left', fill='both', expand=1)
    5682. 

  5682. 		scroll.pack(side='right', fill='y')
    5683. 

  5683. 		frame.pack(fill='both', expand=1)
    5684. 

  5684. 		button.pack(ipadx=30)
    5685. 

  5685. 	
    5686. 

  5686. 	def runprogram(self):
    5687. 

  5687. 		global CMDLINE_RAW
    5688. 

  5688. 		# Prepare
    5689. 

  5689. 		self.target_name2key()
    5690. 

  5690. 		infile, target = self.infile.get(), self.target.get()
    5691. 

  5691. 		# Sanity
    5692. 

  5692. 		if not target:
    5693. 

  5693. 			showwarning(my_name,_("You must select a target type!"))
    5694. 

  5694. 			return
    5695. 

  5695. 		if not infile:
    5696. 

  5696. 			showwarning(my_name,_("You must provide the source file location!"))
    5697. 

  5697. 			return
    5698. 

  5698. 		# Compose cmdline
    5699. 

  5699. 		guiflags = []
    5700. 

  5700. 		real_cmdline_conf = ConfigMaster(CMDLINE_RAW).parse()
    5701. 

  5701. 		if real_cmdline_conf.has_key('infile'):
    5702. 

  5702. 			del real_cmdline_conf['infile']
    5703. 

  5703. 		if real_cmdline_conf.has_key('target'):
    5704. 

  5704. 			del real_cmdline_conf['target']
    5705. 

  5705. 		real_cmdline = CommandLine().compose_cmdline(real_cmdline_conf)
    5706. 

  5706. 		default_outfile = ConfigMaster().get_outfile_name(
    5707. 

  5707. 			{'sourcefile':infile, 'outfile':'', 'target':target})
    5708. 

  5708. 		for opt in self.checks:
    5709. 

  5709. 			val = int(getattr(self, 'f_%s'%opt).get() or "0")
    5710. 

  5710. 			if opt == 'stdout': opt = 'outfile'
    5711. 

  5711. 			on_config  = self.conf.get(opt) or 0
    5712. 

  5712. 			on_cmdline = real_cmdline_conf.get(opt) or 0
    5713. 

  5713. 			if opt == 'outfile':
    5714. 

  5714. 				if on_config  == STDOUT: on_config = 1
    5715. 

  5715. 				else: on_config = 0
    5716. 

  5716. 				if on_cmdline == STDOUT: on_cmdline = 1
    5717. 

  5717. 				else: on_cmdline = 0
    5718. 

  5718. 			if val != on_config or (
    5719. 

  5719. 			  val == on_config == on_cmdline and
    5720. 

  5720. 			  real_cmdline_conf.has_key(opt)):
    5721. 

  5721. 				if val:
    5722. 

  5722. 					# Was not set, but user selected on GUI
    5723. 

  5723. 					Debug("user turned  ON: %s"%opt)
    5724. 

  5724. 					if opt == 'outfile': opt = '-o-'
    5725. 

  5725. 					else: opt = '--%s'%opt
    5726. 

  5726. 				else:
    5727. 

  5727. 					# Was set, but user deselected on GUI
    5728. 

  5728. 					Debug("user turned OFF: %s"%opt)
    5729. 

  5729. 					if opt == 'outfile':
    5730. 

  5730. 						opt = "-o%s"%default_outfile
    5731. 

  5731. 					else: opt = '--no-%s'%opt
    5732. 

  5732. 				guiflags.append(opt)
    5733. 

  5733. 		cmdline = [my_name, '-t', target] + real_cmdline + guiflags + [infile]
    5734. 

  5734. 		Debug('Gui/Tk cmdline: %s' % cmdline, 5)
    5735. 

  5735. 		# Run!
    5736. 

  5736. 		cmdline_raw_orig = CMDLINE_RAW
    5737. 

  5737. 		try:
    5738. 

  5738. 			# Fake the GUI cmdline as the real one, and parse file
    5739. 

  5739. 			CMDLINE_RAW = CommandLine().get_raw_config(cmdline[1:])
    5740. 

  5740. 			data = process_source_file(infile)
    5741. 

  5741. 			# On GUI, convert_* returns the data, not finish_him()
    5742. 

  5742. 			outlist, config = convert_this_files([data])
    5743. 

  5743. 			# On GUI and STDOUT, finish_him() returns the data
    5744. 

  5744. 			result = finish_him(outlist, config)
    5745. 

  5745. 			# Show outlist in s a nice new window
    5746. 

  5746. 			if result:
    5747. 

  5747. 				outlist, config = result
    5748. 

  5748. 				title = _('%s: %s converted to %s') % (
    5749. 

  5749. 					my_name,
    5750. 

  5750. 					os.path.basename(infile),
    5751. 

  5751. 					config['target'].upper())
    5752. 

  5752. 				self.scrollwindow(outlist, title)
    5753. 

  5753. 			# Show the "file saved" message
    5754. 

  5754. 			else:
    5755. 

  5755. 				msg = "%s\n\n  %s\n%s\n\n  %s\n%s"%(
    5756. 

  5756. 					_('Conversion done!'),
    5757. 

  5757. 					_('FROM:'), infile,
    5758. 

  5758. 					_('TO:'), config['outfile'])
    5759. 

  5759. 				showinfo(my_name, msg)
    5760. 

  5760. 		except error:         # common error (windowed), not quit
    5761. 

  5761. 			pass
    5762. 

  5762. 		except:               # fatal error (windowed and printed)
    5763. 

  5763. 			errormsg = getUnknownErrorMessage()
    5764. 

  5764. 			print errormsg
    5765. 

  5765. 			showerror(_('%s FATAL ERROR!')%my_name,errormsg)
    5766. 

  5766. 			self.exit()
    5767. 

  5767. 		CMDLINE_RAW = cmdline_raw_orig
    5768. 

  5768. 	
    5769. 

  5769. 	def mainwindow(self):
    5770. 

  5770. 		self.infile.set(self.conf.get('sourcefile') or '')
    5771. 

  5771. 		self.target.set(self.conf.get('target') or _('-- select one --'))
    5772. 

  5772. 		outfile = self.conf.get('outfile')
    5773. 

  5773. 		if outfile == STDOUT:                  # map -o-
    5774. 

  5774. 			self.conf['stdout'] = 1
    5775. 

  5775. 		if self.conf.get('headers') == None:
    5776. 

  5776. 			self.conf['headers'] = 1       # map default
    5777. 

  5777. 		
    5778. 

  5778. 		action1 = _("Enter the source file location:")
    5779. 

  5779. 		action2 = _("Choose the target document type:")
    5780. 

  5780. 		action3 = _("Some options you may check:")
    5781. 

  5781. 		action4 = _("Some extra options:")
    5782. 

  5782. 		checks_txt = {
    5783. 

  5783. 			'headers'   : _("Include headers on output"),
    5784. 

  5784. 			'enum-title': _("Number titles (1, 1.1, 1.1.1, etc)"),
    5785. 

  5785. 			'toc'       : _("Do TOC also (Table of Contents)"),
    5786. 

  5786. 			'mask-email': _("Hide e-mails from SPAM robots"),
    5787. 

  5787. 		
    5788. 

  5788. 			'toc-only'  : _("Just do TOC, nothing more"),
    5789. 

  5789. 			'stdout'    : _("Dump to screen (Don't save target file)")
    5790. 

  5790. 		}
    5791. 

  5791. 		targets_menu = map(lambda x: TARGET_NAMES[x], TARGETS)
    5792. 

  5792. 		
    5793. 

  5793. 		# Header
    5794. 

  5794. 		self.label("%s %s"%(my_name.upper(), my_version),
    5795. 

  5795. 			bg=self.bg2, fg=self.fg2).grid(columnspan=2, ipadx=10)
    5796. 

  5796. 		self.label(_("ONE source, MULTI targets")+'\n%s\n'%my_url,
    5797. 

  5797. 			bg=self.bg1, fg=self.fg1).grid(columnspan=2)
    5798. 

  5798. 		self.row = 2
    5799. 

  5799. 		# Choose input file
    5800. 

  5800. 		self.action(action1) ; self.frame_open()
    5801. 

  5801. 		e_infile = self.entry(textvariable=self.infile,width=25)
    5802. 

  5802. 		e_infile.grid(row=self.row, column=0, sticky='e')
    5803. 

  5803. 		if not self.infile.get(): e_infile.focus_set()
    5804. 

  5804. 		self.button(_("Browse"), self.askfile).grid(
    5805. 

  5805. 			row=self.row, column=1, sticky='w', padx=10)
    5806. 

  5806. 		# Show outfile name, style and encoding (if any)
    5807. 

  5807. 		txt = ''
    5808. 

  5808. 		if outfile:
    5809. 

  5809. 			txt = outfile
    5810. 

  5810. 			if outfile == STDOUT: txt = _('<screen>')
    5811. 

  5811. 			l_output = self.label(_('Output: ')+txt, fg=self.fg2, bg=self.bg2)
    5812. 

  5812. 			l_output.grid(columnspan=2, sticky='w')
    5813. 

  5813. 		for setting in ['style','encoding']:
    5814. 

  5814. 			if self.conf.get(setting):
    5815. 

  5815. 				name = setting.capitalize()
    5816. 

  5816. 				val  = self.conf[setting]
    5817. 

  5817. 				self.label('%s: %s'%(name, val),
    5818. 

  5818. 					fg=self.fg2, bg=self.bg2).grid(
    5819. 

  5819. 					columnspan=2, sticky='w')
    5820. 

  5820. 		# Choose target
    5821. 

  5821. 		self.frame_close() ; self.action(action2)
    5822. 

  5822. 		self.frame_open()
    5823. 

  5823. 		self.target_key2name()
    5824. 

  5824. 		self.menu(self.target_name, targets_menu).grid(
    5825. 

  5825. 			columnspan=2, sticky='w')
    5826. 

  5826. 		# Options checkboxes label
    5827. 

  5827. 		self.frame_close() ; self.action(action3)
    5828. 

  5828. 		self.frame_open()
    5829. 

  5829. 		# Compose options check boxes, example:
    5830. 

  5830. 		# self.check(checks_txt['toc'],1,variable=self.f_toc)
    5831. 

  5831. 		for check in self.checks:
    5832. 

  5832. 			# Extra options label
    5833. 

  5833. 			if check == 'toc-only':
    5834. 

  5834. 				self.frame_close() ; self.action(action4)
    5835. 

  5835. 				self.frame_open()
    5836. 

  5836. 			txt = checks_txt[check]
    5837. 

  5837. 			var = getattr(self, 'f_'+check)
    5838. 

  5838. 			checked = self.conf.get(check)
    5839. 

  5839. 			self.check(txt,checked,variable=var)
    5840. 

  5840. 		self.frame_close()
    5841. 

  5841. 		# Spacer and buttons
    5842. 

  5842. 		self.label('').grid() ; self.row += 1
    5843. 

  5843. 		b_quit = self.button(_("Quit"), self.exit)
    5844. 

  5844. 		b_quit.grid(row=self.row, column=0, sticky='w', padx=30)
    5845. 

  5845. 		b_conv = self.button(_("Convert!"), self.runprogram)
    5846. 

  5846. 		b_conv.grid(row=self.row, column=1, sticky='e', padx=30)
    5847. 

  5847. 		if self.target.get() and self.infile.get():
    5848. 

  5848. 			b_conv.focus_set()
    5849. 

  5849. 		
    5850. 

  5850. 		# As documentation told me
    5851. 

  5851. 		if sys.platform.startswith('win'):
    5852. 

  5852. 			self.root.iconify()
    5853. 

  5853. 			self.root.update()
    5854. 

  5854. 			self.root.deiconify()
    5855. 

  5855. 		
    5856. 

  5856. 		self.root.mainloop()
    5857. 

  5857. 

  5858. 

  5859. ##############################################################################
    5860. 

  5860. ##############################################################################
    5861. 

  5861. 

  5862. def exec_command_line(user_cmdline=[]):
    5863. 

  5863. 	global CMDLINE_RAW, RC_RAW, DEBUG, VERBOSE, QUIET, GUI, Error
    5864. 

  5864. 	
    5865. 

  5865. 	# Extract command line data
    5866. 

  5866. 	cmdline_data = user_cmdline or sys.argv[1:]
    5867. 

  5867. 	CMDLINE_RAW = CommandLine().get_raw_config(cmdline_data, relative=1)
    5868. 

  5868. 	cmdline_parsed = ConfigMaster(CMDLINE_RAW).parse()
    5869. 

  5869. 	DEBUG   = cmdline_parsed.get('debug'  ) or 0
    5870. 

  5870. 	VERBOSE = cmdline_parsed.get('verbose') or 0
    5871. 

  5871. 	QUIET   = cmdline_parsed.get('quiet'  ) or 0
    5872. 

  5872. 	GUI     = cmdline_parsed.get('gui'    ) or 0
    5873. 

  5873. 	infiles = cmdline_parsed.get('infile' ) or []
    5874. 

  5874. 	
    5875. 

  5875. 	Message(_("Txt2tags %s processing begins")%my_version,1)
    5876. 

  5876. 	
    5877. 

  5877. 	# The easy ones
    5878. 

  5878. 	if cmdline_parsed.get('help'   ): Quit(USAGE)
    5879. 

  5879. 	if cmdline_parsed.get('version'): Quit(VERSIONSTR)
    5880. 

  5880. 	if cmdline_parsed.get('targets'):
    5881. 

  5881. 		listTargets()
    5882. 

  5882. 		Quit()
    5883. 

  5883. 

  5884. 	# Multifile haters
    5885. 

  5885. 	if len(infiles) > 1:
    5886. 

  5886. 		errmsg=_("Option --%s can't be used with multiple input files")
    5887. 

  5887. 		for option in NO_MULTI_INPUT:
    5888. 

  5888. 			if cmdline_parsed.get(option):
    5889. 

  5889. 				Error(errmsg%option)
    5890. 

  5890. 	
    5891. 

  5891. 	Debug("system platform: %s"%sys.platform)
    5892. 

  5892. 	Debug("python version: %s"%(sys.version.split('(')[0]))
    5893. 

  5893. 	Debug("line break char: %s"%repr(LB))
    5894. 

  5894. 	Debug("command line: %s"%sys.argv)
    5895. 

  5895. 	Debug("command line raw config: %s"%CMDLINE_RAW,1)
    5896. 

  5896. 	
    5897. 

  5897. 	# Extract RC file config
    5898. 

  5898. 	if cmdline_parsed.get('rc') == 0:
    5899. 

  5899. 		Message(_("Ignoring user configuration file"),1)
    5900. 

  5900. 	else:
    5901. 

  5901. 		rc_file = get_rc_path()
    5902. 

  5902. 		if os.path.isfile(rc_file):
    5903. 

  5903. 			Message(_("Loading user configuration file"),1)
    5904. 

  5904. 			RC_RAW = ConfigLines(file_=rc_file).get_raw_config()
    5905. 

  5905. 		
    5906. 

  5906. 		Debug("rc file: %s"%rc_file)
    5907. 

  5907. 		Debug("rc file raw config: %s"%RC_RAW,1)
    5908. 

  5908. 	
    5909. 

  5909. 	# Get all infiles config (if any)
    5910. 

  5910. 	infiles_config = get_infiles_config(infiles)
    5911. 

  5911. 	
    5912. 

  5912. 	# Is GUI available?
    5913. 

  5913. 	# Try to load and start GUI interface for --gui
    5914. 

  5914. 	if GUI:
    5915. 

  5915. 		try:
    5916. 

  5916. 			load_GUI_resources()
    5917. 

  5917. 			Debug("GUI resources OK (Tk module is installed)")
    5918. 

  5918. 			winbox = Gui()
    5919. 

  5919. 			Debug("GUI display OK")
    5920. 

  5920. 			GUI = 1
    5921. 

  5921. 		except:
    5922. 

  5922. 			Debug("GUI Error: no Tk module or no DISPLAY")
    5923. 

  5923. 			GUI = 0
    5924. 

  5924. 	
    5925. 

  5925. 	# User forced --gui, but it's not available
    5926. 

  5926. 	if cmdline_parsed.get('gui') and not GUI:
    5927. 

  5927. 		print getTraceback(); print
    5928. 

  5928. 		Error(
    5929. 

  5929. 			"Sorry, I can't run my Graphical Interface - GUI\n"
    5930. 

  5930. 			"- Check if Python Tcl/Tk module is installed (Tkinter)\n"
    5931. 

  5931. 			"- Make sure you are in a graphical environment (like X)")
    5932. 

  5932. 	
    5933. 

  5933. 	# Okay, we will use GUI
    5934. 

  5934. 	if GUI:
    5935. 

  5935. 		Message(_("We are on GUI interface"),1)
    5936. 

  5936. 		
    5937. 

  5937. 		# Redefine Error function to raise exception instead sys.exit()
    5938. 

  5938. 		def Error(msg):
    5939. 

  5939. 			showerror(_('txt2tags ERROR!'), msg)
    5940. 

  5940. 			raise error
    5941. 

  5941. 		
    5942. 

  5942. 		# If no input file, get RC+cmdline config, else full config
    5943. 

  5943. 		if not infiles:
    5944. 

  5944. 			gui_conf = ConfigMaster(RC_RAW+CMDLINE_RAW).parse()
    5945. 

  5945. 		else:
    5946. 

  5946. 			try   : gui_conf = infiles_config[0][0]
    5947. 

  5947. 			except: gui_conf = {}
    5948. 

  5948. 		
    5949. 

  5949. 		# Sanity is needed to set outfile and other things
    5950. 

  5950. 		gui_conf = ConfigMaster().sanity(gui_conf, gui=1)
    5951. 

  5951. 		Debug("GUI config: %s"%gui_conf,5)
    5952. 

  5952. 		
    5953. 

  5953. 		# Insert config and populate the nice window!
    5954. 

  5954. 		winbox.load_config(gui_conf)
    5955. 

  5955. 		winbox.mainwindow()
    5956. 

  5956. 	
    5957. 

  5957. 	# Console mode rocks forever!
    5958. 

  5958. 	else:
    5959. 

  5959. 		Message(_("We are on Command Line interface"),1)
    5960. 

  5960. 		
    5961. 

  5961. 		# Called with no arguments, show error
    5962. 

  5962. 		# TODO#1: this checking should be only in ConfigMaster.sanity()
    5963. 

  5963. 		if not infiles:
    5964. 

  5964. 			Error(_('Missing input file (try --help)') + '\n\n' +
    5965. 

  5965. 			_('Please inform an input file (.t2t) at the end of the command.') + '\n' +
    5966. 

  5966. 			_('Example:') + ' %s -t html %s' % (my_name, _('file.t2t')))
    5967. 

  5967. 		
    5968. 

  5968. 		convert_this_files(infiles_config)
    5969. 

  5969. 	
    5970. 

  5970. 	Message(_("Txt2tags finished successfully"),1)
    5971. 

  5971. 

  5972. if __name__ == '__main__':
    5973. 

  5973. 	try:
    5974. 

  5974. 		exec_command_line()
    5975. 

  5975. 	except error, msg:
    5976. 

  5976. 		sys.stderr.write("%s\n"%msg)
    5977. 

  5977. 		sys.stderr.flush()
    5978. 

  5978. 		sys.exit(1)
    5979. 

  5979. 	except SystemExit:
    5980. 

  5980. 		pass
    5981. 

  5981. 	except:
    5982. 

  5982. 		sys.stderr.write(getUnknownErrorMessage())
    5983. 

  5983. 		sys.stderr.flush()
    5984. 

  5984. 		sys.exit(1)
    5985. 

  5985. 	Quit()
    5986. 

  5986. 

  5987. # The End.
    5988. 

  5988.