PageRenderTime 77ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/old/txt2tags-2.0.py

http://txt2tags.googlecode.com/
Python | 4024 lines | 3605 code | 161 blank | 258 comment | 163 complexity | b2aedac450024e883a7707b81b88866f MD5 | raw file
Possible License(s): GPL-2.0, GPL-3.0, WTFPL 
    

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

  2. # txt2tags - generic text conversion tool
    3. 

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

  4. #
    5. 

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

  6. #
    7. 

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

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

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

  10. #
    11. 

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

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

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

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

  15. #
    16. 

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

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

  18. #
    19. 

  19. 

  20. 

  21.     ##################################################################
    22. 

  22.     #                                                                #
    23. 

  23.     #                         - IMPORTANT -                          #
    24. 

  24.     #                                                                #
    25. 

  25.     #  Due the major syntax changes, the new 2.x series BREAKS       #
    26. 

  26.     #  backwards compatibility.                                      #
    27. 

  27.     #                                                                #
    28. 

  28.     #  Use the 't2tconv' script to upgrade your existing .t2t files  #
    29. 

  29.     #  to conform the new v2.0 syntax.                               #
    30. 

  30.     #                                                                #
    31. 

  31.     #  Do a visual inspection on the new converted file.             #
    32. 

  32.     #  Specially Pre & Post proc filters can break. Check them!      #
    33. 

  33.     #                                                                #
    34. 

  34.     ##################################################################
    35. 

  35. 

  36. 

  37. ########################################################################
    38. 

  38. #
    39. 

  39. #   BORING CODE EXPLANATION AHEAD
    40. 

  40. #
    41. 

  41. # Just read if you wish to understand how the txt2tags code works
    42. 

  42. #
    43. 

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

  44. #
    45. 

  45. # Version 2.0 was a complete rewrite for the program 'core'.
    46. 

  46. #
    47. 

  47. # Now the code that [1] parses the marked text is separated from the
    48. 

  48. # code that [2] insert the target tags.
    49. 

  49. #
    50. 

  50. #   [1] made by: def convert()
    51. 

  51. #   [2] made by: class BlockMaster
    52. 

  52. #
    53. 

  53. # The structures of the marked text are identifyed and its contents are
    54. 

  54. # extracted into a data holder (Python lists and dictionaries).
    55. 

  55. #
    56. 

  56. # When parsing the source file, the blocks (para, lists, quote, table)
    57. 

  57. # are opened with BlockMaster, right when found. Then its contents,
    58. 

  58. # which spans on several lines, are feeded into a special holder on the
    59. 

  59. # BlockMaster instance. Just when the block is closed, the target tags
    60. 

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

  61. # have a better control on blocks. Much better than the previous line by
    62. 

  62. # line approach.
    63. 

  63. #
    64. 

  64. # In other words, whenever inside a block, the parser *holds* the tag
    65. 

  65. # insertion process, waiting until the full block is readed. That was
    66. 

  66. # needed primary to close paragraphs for the new XHTML target, but
    67. 

  67. # proved to be a very good adding, improving many other processings.
    68. 

  68. #
    69. 

  69. # -------------------------------------------------------------------
    70. 

  70. #
    71. 

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

  72. # rewritten. There are new classes, all self documented: CommandLine,
    73. 

  73. # SourceDocument, ConfigMaster and ConfigLines. In short, a new RAW
    74. 

  74. # Config format was created, and all kind of configuration is first
    75. 

  75. # converted to this format, and then a generic method parses it.
    76. 

  76. #
    77. 

  77. # The init processing was changed also, and now the functions which
    78. 

  78. # gets informations about the input files are: get_infiles_config(),
    79. 

  79. #  process_source_file() and convert_this_files()
    80. 

  80. #
    81. 

  81. # Other parts are untouched, and remains the same as in v1.7, as the
    82. 

  82. # marks regexes, target Headers and target Tags&Rules.
    83. 

  83. #
    84. 

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

  85. 

  86. # Now I think the code is nice, easier to read and understand
    87. 

  87. 

  88. #XXX Python coding warning
    89. 

  89. # Avoid common mistakes:
    90. 

  90. # - do NOT use newlist=list instead newlist=list[:]
    91. 

  91. # - do NOT use newdic=dic   instead newdic=dic.copy()
    92. 

  92. # - do NOT use dic[key]     instead dic.get(key)
    93. 

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

  94. 

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

  96. # Can't fix that because the image is expanded together with the
    97. 

  97. # link, at the linkbank filling moment. Only the image is passed
    98. 

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

  99. 

  100. #XXX Paragraph separation not valid inside Quote
    101. 

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

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

  103. # diferent background color. Still don't know how to fix it.
    104. 

    105. 

  105. #XXX TODO (maybe)
    106. 

  106. # New mark or macro which expands to and anchor full title.
    107. 

  107. # It is necessary to parse the full document in this order:
    108. 

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

  109. #  DONE  2nd scan: BODY: expand includes & apply %!preproc
    110. 

  110. #        3rd scan: BODY: read titles and compose TOC info
    111. 

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

  112. # Steps 2 and 3 can be made together, with no tag adding.
    113. 

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

    115. 

  115. 

  116. ##############################################################################
    117. 

  117. 

  118. # User config (1=ON, 0=OFF)
    119. 

  119. 

  120. USE_I18N    = 1   # use gettext for i18ned messages?        (default is 1)
    121. 

  121. COLOR_DEBUG = 1   # show debug messages in colors?          (default is 1)
    122. 

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

  123. 

  124. ##############################################################################
    125. 

  125. 

  126. 

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

  128. import re, string, os, sys, getopt
    129. 

  129. from time import strftime,time,localtime
    130. 

  130. 

  131. # program information
    132. 

  132. my_url = 'http://txt2tags.sf.net'
    133. 

  133. my_name = 'txt2tags'
    134. 

  134. my_email = 'verde@aurelio.net'
    135. 

  135. my_version = '2.0'                          #-betaN
    136. 

  136. 

  137. # i18n - just use if available
    138. 

  138. if USE_I18N:
    139. 

  139. 	try:
    140. 

  140. 		import gettext
    141. 

  141. 		# if your locale dir is different, change it here
    142. 

  142. 		cat = gettext.Catalog('txt2tags',localedir='/usr/share/locale/')
    143. 

  143. 		_ = cat.gettext
    144. 

  144. 	except:
    145. 

  145. 		_ = lambda x:x
    146. 

  146. else:
    147. 

  147. 	_ = lambda x:x
    148. 

  148. 

  149. # FLAGS   : the convertion related flags  , may be used in %!options
    150. 

  150. # OPTIONS : the convertion related options, may be used in %!options
    151. 

  151. # ACTIONS : the other behaviour modifiers, valid on command line only
    152. 

  152. # SETTINGS: global miscelaneous settings, valid on RC file only
    153. 

  153. # CONFIG_KEYWORDS: the valid %!key:val keywords
    154. 

  154. #
    155. 

  155. # FLAGS and OPTIONS are configs that affect the converted document.
    156. 

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

  157. # ACTIONS are needed because when doing multiple input files, strange
    158. 

  158. # behaviour would be found, as use command line interface for the
    159. 

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

  160. # --version and --help inside %!options are also odd
    161. 

  161. #
    162. 

  162. TARGETS  = ['html', 'xhtml', 'sgml', 'tex', 'man', 'mgp', 'moin', 'pm6', 'txt']
    163. 

  163. FLAGS    = {'headers'    :1 , 'enum-title' :0 , 'mask-email' :0 ,
    164. 

  164.             'toc-only'   :0 , 'toc'        :0 , 'rc'         :1 ,
    165. 

  165.             'css-suggar' :0 }
    166. 

  166. OPTIONS  = {'target'     :'', 'toc-level'  :3 , 'style'      :'',
    167. 

  167.             'infile'     :'', 'outfile'    :'', 'encoding'   :'',
    168. 

  168.             'split'      :0 , 'lang'       :''}
    169. 

  169. ACTIONS  = {'help'       :0 , 'version'    :0 , 'gui'        :0 ,
    170. 

  170.             'verbose'    :0 , 'debug'      :0 , 'dump-config':0 }
    171. 

  171. SETTINGS = {}         # for future use
    172. 

  172. CONFIG_KEYWORDS = [
    173. 

  173.             'target', 'encoding', 'style', 'options', 'preproc','postproc',
    174. 

  174.             'guicolors']
    175. 

  175. TARGET_NAMES = {
    176. 

  176.   'html' : _('HTML page'),
    177. 

  177.   'xhtml': _('XHTML page'),
    178. 

  178.   'sgml' : _('SGML document'),
    179. 

  179.   'tex'  : _('LaTeX document'),
    180. 

  180.   'man'  : _('UNIX Manual page'),
    181. 

  181.   'mgp'  : _('Magic Point presentation'),
    182. 

  182.   'moin' : _('MoinMoin page'),
    183. 

  183.   'pm6'  : _('PageMaker 6.0 document'),
    184. 

  184.   'txt'  : _('Plain Text'),
    185. 

  185. }
    186. 

  186. 

  187. DEBUG = 0     # do not edit here, please use --debug
    188. 

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

  189. GUI = 0
    190. 

  190. RC_RAW = []
    191. 

  191. CMDLINE_RAW = []
    192. 

  192. CONF = {}
    193. 

  193. BLOCK = None
    194. 

  194. regex = {}
    195. 

  195. TAGS = {}
    196. 

  196. rules = {}
    197. 

  197. 

  198. currdate = strftime('%Y%m%d',localtime(time()))    # ISO current date
    199. 

  199. lang = 'english'
    200. 

  200. TARGET = ''
    201. 

  201. 

  202. STDIN = STDOUT = '-'
    203. 

  203. ESCCHAR   = '\x00'
    204. 

  204. SEPARATOR = '\x01'
    205. 

  205. LISTNAMES = {'-':'list', '+':'numlist', ':':'deflist'}
    206. 

  206. LINEBREAK = {'default':'\n', 'win':'\r\n', 'mac':'\r'}
    207. 

  207. RCFILE    = {'default':'.txt2tagsrc', 'win':'_t2trc'}
    208. 

  208. 

  209. #my_version = my_version + '-dev' + currdate[4:]  # devel!
    210. 

  210. 

  211. # plataform specific settings
    212. 

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

  213. RC =    RCFILE.get(sys.platform[:3]) or    RCFILE['default']
    214. 

  214. 

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

  216. 

  217. USAGE = string.join([
    218. 

  218. '',
    219. 

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

  220. '',
    221. 

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

  222. '                      %s' % re.sub(r"[]'[]",'',repr(TARGETS)),
    223. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  236. _("      --gui           invoke Graphical Tk Interface"),
    237. 

  237. _("  -v, --verbose       print informative messages during convertion"),
    238. 

  238. _("  -h, --help          print this help information and exit"),
    239. 

  239. _("  -V, --version       print program version and exit"),
    240. 

  240. _("      --dump-config   print all the config found and exit"),
    241. 

  241. '',
    242. 

  242. _("Turn OFF options:"),
    243. 

  243. "     --no-outfile, --no-infile, --no-style, --no-encoding, --no-headers",
    244. 

  244. "     --no-toc, --no-toc-only, --no-mask-email, --no-enum-title, --no-rc",
    245. 

  245. "     --no-css-suggar",
    246. 

  246. '',
    247. 

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

  248. '',
    249. 

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

  250. _("Use --outfile to force an output file name."),
    251. 

  251. _("If  input file is '-', reads from STDIN."),
    252. 

  252. _("If output file is '-', dumps output to STDOUT."),
    253. 

  253. ''
    254. 

  254. ], '\n')
    255. 

  255. 

  256. 

  257. ##############################################################################
    258. 

  258. 

  259. 

  260. # here is all the target's templates
    261. 

  261. # you may edit them to fit your needs
    262. 

  262. #  - the %(HEADERn)s strings represent the Header lines
    263. 

  263. #  - the %(STYLE)s string is changed by --style contents
    264. 

  264. #  - the %(ENCODING)s string is changed by --encoding contents
    265. 

  265. #  - if any of the above is empty, the full line is removed
    266. 

  266. #  - use %% to represent a literal %
    267. 

  267. #
    268. 

  268. HEADER_TEMPLATE = {
    269. 

  269.   'txt': """\
    270. 

  270. %(HEADER1)s
    271. 

  271. %(HEADER2)s
    272. 

  272. %(HEADER3)s
    273. 

  273. """,
    274. 

    275. 

  275.   'sgml': """\
    276. 

  276. <!doctype linuxdoc system>
    277. 

  277. <article>
    278. 

  278. <title>%(HEADER1)s
    279. 

  279. <author>%(HEADER2)s
    280. 

  280. <date>%(HEADER3)s
    281. 

  281. """,
    282. 

    283. 

  283.   'html': """\
    284. 

  284. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    285. 

  285. <HTML>
    286. 

  286. <HEAD>
    287. 

  287. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    288. 

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

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

  290. <TITLE>%(HEADER1)s</TITLE>
    291. 

  291. </HEAD><BODY BGCOLOR="white" TEXT="black">
    292. 

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

  293. <FONT SIZE="4">
    294. 

  294. <I>%(HEADER2)s</I><BR>
    295. 

  295. %(HEADER3)s
    296. 

  296. </FONT></CENTER>
    297. 

  297. """,
    298. 

    299. 

  299.   'htmlcss': """\
    300. 

  300. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    301. 

  301. <HTML>
    302. 

  302. <HEAD>
    303. 

  303. <META NAME="generator" CONTENT="http://txt2tags.sf.net">
    304. 

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

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

  306. <TITLE>%(HEADER1)s</TITLE>
    307. 

  307. </HEAD>
    308. 

  308. <BODY>
    309. 

  309. 

  310. <DIV CLASS="header" ID="header">
    311. 

  311. <H1>%(HEADER1)s</H1>
    312. 

  312. <H2>%(HEADER2)s</H2>
    313. 

  313. <H3>%(HEADER3)s</H3>
    314. 

  314. </DIV>
    315. 

  315. """,
    316. 

    317. 

  317.   'xhtml': """\
    318. 

  318. <?xml version="1.0"?>
    319. 

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

  320.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    321. 

  321. <html xmlns="http://www.w3.org/1999/xhtml">
    322. 

  322. <head>
    323. 

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

  324. <meta name="generator" content="http://txt2tags.sf.net" />
    325. 

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

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

  327. </head>
    328. 

  328. <body bgcolor="white" text="black">
    329. 

  329. <div align="center">
    330. 

  330. <h1>%(HEADER1)s</h1>
    331. 

  331. <h2>%(HEADER2)s</h2>
    332. 

  332. <h3>%(HEADER3)s</h3>
    333. 

  333. </div>
    334. 

  334. """,
    335. 

    336. 

  336.   'xhtmlcss': """\
    337. 

  337. <?xml version="1.0"?>
    338. 

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

  339.  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    340. 

  340. <html xmlns="http://www.w3.org/1999/xhtml">
    341. 

  341. <head>
    342. 

  342. <title>%(HEADER1)s</title>
    343. 

  343. <meta name="generator" content="http://txt2tags.sf.net" />
    344. 

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

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

  346. </head>
    347. 

  347. <body>
    348. 

  348. 

  349. <div class="header" id="header">
    350. 

  350. <h1>%(HEADER1)s</h1>
    351. 

  351. <h2>%(HEADER2)s</h2>
    352. 

  352. <h3>%(HEADER3)s</h3>
    353. 

  353. </div>
    354. 

  354. """,
    355. 

    356. 

  356.   'man': """\
    357. 

  357. .TH "%(HEADER1)s" 1 "%(HEADER3)s" "%(HEADER2)s"
    358. 

  358. """,
    359. 

    360. 

  360. # TODO style to <HR>
    361. 

  361.   'pm6': """\
    362. 

  362. <PMTags1.0 win><C-COLORTABLE ("Preto" 1 0 0 0)
    363. 

  363. ><@Normal=
    364. 

  364.   <FONT "Times New Roman"><CCOLOR "Preto"><SIZE 11>
    365. 

  365.   <HORIZONTAL 100><LETTERSPACE 0><CTRACK 127><CSSIZE 70><C+SIZE 58.3>
    366. 

  366.   <C-POSITION 33.3><C+POSITION 33.3><P><CBASELINE 0><CNOBREAK 0><CLEADING -0.05>
    367. 

  367.   <GGRID 0><GLEFT 7.2><GRIGHT 0><GFIRST 0><G+BEFORE 7.2><G+AFTER 0>
    368. 

  368.   <GALIGNMENT "justify"><GMETHOD "proportional"><G& "ENGLISH">
    369. 

  369.   <GPAIRS 12><G%% 120><GKNEXT 0><GKWIDOW 0><GKORPHAN 0><GTABS $>
    370. 

  370.   <GHYPHENATION 2 34 0><GWORDSPACE 75 100 150><GSPACE -5 0 25>
    371. 

  371. ><@Bullet=<@-PARENT "Normal"><FONT "Abadi MT Condensed Light">
    372. 

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

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

  374.   <GLEFT 0><G+BEFORE 0><GALIGNMENT "left"><GWORDSPACE 100 100 100><GSPACE 0 0 0>
    375. 

  375. ><@Title1=<@-PARENT "Normal"><FONT "Arial"><SIZE 14><B>
    376. 

  376.   <GCONTENTS><GLEFT 0><G+BEFORE 0><GALIGNMENT "left">
    377. 

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

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

  379. ><@Title4=<@-PARENT "Title3">
    380. 

  380. ><@Title5=<@-PARENT "Title3">
    381. 

  381. ><@Quote=<@-PARENT "Normal"><SIZE 10><I>>
    382. 

  382. 

  383. %(HEADER1)s
    384. 

  384. %(HEADER2)s
    385. 

  385. %(HEADER3)s
    386. 

  386. """,
    387. 

    388. 

  388.   'mgp': """\
    389. 

  389. #!/usr/X11R6/bin/mgp -t 90
    390. 

  390. %%deffont "normal"    xfont  "utopia-medium-r", charset "iso8859-1"
    391. 

  391. %%deffont "normal-i"  xfont  "utopia-medium-i", charset "iso8859-1"
    392. 

  392. %%deffont "normal-b"  xfont  "utopia-bold-r"  , charset "iso8859-1"
    393. 

  393. %%deffont "normal-bi" xfont  "utopia-bold-i"  , charset "iso8859-1"
    394. 

  394. %%deffont "mono"      xfont "courier-medium-r", charset "iso8859-1"
    395. 

  395. %%default 1 size 5
    396. 

  396. %%default 2 size 8, fore "yellow", font "normal-b", center
    397. 

  397. %%default 3 size 5, fore "white",  font "normal", left, prefix "  "
    398. 

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

  399. %%tab 2 prefix "            ", icon arc "orange" 40, leftfill
    400. 

  400. %%tab 3 prefix "                   ", icon arc "brown" 40, leftfill
    401. 

  401. %%tab 4 prefix "                          ", icon arc "darkmagenta" 40, leftfill
    402. 

  402. %%tab 5 prefix "                                ", icon arc "magenta" 40, leftfill
    403. 

  403. %%%%------------------------- end of headers -----------------------------
    404. 

  404. %%page
    405. 

  405. 

  406. 

  407. 

  408. 

  409. 

  410. %%size 10, center, fore "yellow"
    411. 

  411. %(HEADER1)s
    412. 

  412. 

  413. %%font "normal-i", size 6, fore "white", center
    414. 

  414. %(HEADER2)s
    415. 

  415. 

  416. %%font "mono", size 7, center
    417. 

  417. %(HEADER3)s
    418. 

  418. """,
    419. 

    420. 

  420. # TODO please, improve me!
    421. 

  421.   'moin': """\
    422. 

  422. '''%(HEADER1)s'''
    423. 

  423. 

  424. ''%(HEADER2)s''
    425. 

  425. 

  426. %(HEADER3)s
    427. 

  427. """,
    428. 

    429. 

  429.   'tex': \
    430. 

  430. r"""\documentclass[11pt,a4paper]{article}
    431. 

  431. \usepackage{amsfonts,graphicx,url}
    432. 

  432. \usepackage[%(ENCODING)s]{inputenc}  %% char encoding
    433. 

  433. \usepackage{%(STYLE)s}  %% user defined package
    434. 

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

  435. \frenchspacing      %% no aditional spaces after periods
    436. 

  436. \setlength{\parskip}{8pt}\parindent=0pt  %% no paragraph indentation
    437. 

  437. %% uncomment next line for fancy PDF output on Adobe Acrobat Reader
    438. 

  438. %%\usepackage[pdfstartview=FitV,colorlinks=true,bookmarks=true]{hyperref}
    439. 

  439. 

  440. \title{%(HEADER1)s}
    441. 

  441. \author{%(HEADER2)s}
    442. 

  442. \begin{document}
    443. 

  443. \date{%(HEADER3)s}
    444. 

  444. \maketitle
    445. 

  445. \clearpage
    446. 

  446. """
    447. 

  447. }
    448. 

  448. 

  449. 

  450. ##############################################################################
    451. 

  451. 

  452. 

  453. def getTags(target):
    454. 

  454. 	"Returns all the known tags for the specified target"
    455. 

  455. 	
    456. 

  456. 	keys = [
    457. 

  457. 	'paragraphOpen','paragraphClose',
    458. 

  458. 	'title1','title2','title3','title4','title5',
    459. 

  459. 	'numtitle1','numtitle2','numtitle3','numtitle4','numtitle5',
    460. 

  460. 	'blockVerbOpen','blockVerbClose',
    461. 

  461. 	'blockQuoteOpen','blockQuoteClose','blockQuoteLine',
    462. 

  462. 	'fontMonoOpen','fontMonoClose',
    463. 

  463. 	'fontBoldOpen','fontBoldClose',
    464. 

  464. 	'fontItalicOpen','fontItalicClose',
    465. 

  465. 	'fontUnderlineOpen','fontUnderlineClose',
    466. 

  466. 	'listOpen','listClose',
    467. 

  467. 	'listItemOpen','listItemClose','listItemLine',
    468. 

  468. 	'numlistOpen','numlistClose',
    469. 

  469. 	'numlistItemOpen','numlistItemClose','numlistItemLine',
    470. 

  470. 	'deflistOpen','deflistClose',
    471. 

  471. 	'deflistItem1Open','deflistItem1Close',
    472. 

  472. 	'deflistItem2Open','deflistItem2Close',
    473. 

  473. 	'bar1','bar2',
    474. 

  474. 	'url','urlMark','email','emailMark',
    475. 

  475. 	'img',
    476. 

  476. 	'tableOpen','tableClose',
    477. 

  477. 	'tableRowOpen','tableRowClose','tableRowSep',
    478. 

  478. 	'tableCellOpen','tableCellClose','tableCellSep',
    479. 

  479. 	'tableTitleCellOpen','tableTitleCellClose','tableTitleCellSep',
    480. 

  480. 	'tableTitleRowOpen','tableTitleRowClose',
    481. 

  481. 	'tableBorder', 'tableAlignLeft', 'tableAlignCenter',
    482. 

  482. 	'tableCellAlignLeft','tableCellAlignRight','tableCellAlignCenter',
    483. 

  483. 	'tableColAlignLeft','tableColAlignRight','tableColAlignCenter',
    484. 

  484. 	'tableColAlignSep',
    485. 

  485. 	'anchor','comment',
    486. 

  486. 	'TOC','tocOpen','tocClose','tocOpenCss','tocCloseCss',
    487. 

  487. 	'bodyOpenCss','bodyCloseCss',
    488. 

  488. 	'EOD'
    489. 

  489. 	]
    490. 

  490. 	
    491. 

  491. 	alltags = {
    492. 

  492. 	
    493. 

  493. 	'txt': {
    494. 

  494. 	   'title1'              : '  \a'      ,
    495. 

  495. 	   'title2'              : '\t\a'      ,
    496. 

  496. 	   'title3'              : '\t\t\a'    ,
    497. 

  497. 	   'title4'              : '\t\t\t\a'  ,
    498. 

  498. 	   'title5'              : '\t\t\t\t\a',
    499. 

  499. 	   'blockQuoteLine'      : '\t'        ,
    500. 

  500. 	   'listItemOpen'        : '- '        ,
    501. 

  501. 	   'numlistItemOpen'     : '\a. '      ,
    502. 

  502. 	   'bar1'                : '\a'        ,
    503. 

  503. 	   'bar2'                : '\a'        ,
    504. 

  504. 	   'url'                 : '\a'        ,
    505. 

  505. 	   'urlMark'             : '\a (\a)'   ,
    506. 

  506. 	   'email'               : '\a'        ,
    507. 

  507. 	   'emailMark'           : '\a (\a)'   ,
    508. 

  508. 	   'img'                 : '[\a]'      ,
    509. 

  509. 	},
    510. 

  510. 	
    511. 

  511. 	'html': {
    512. 

  512. 	   'paragraphOpen'       : '<P>'            ,
    513. 

  513. 	   'paragraphClose'      : '</P>'           ,
    514. 

  514. 	   'title1'              : '~A~<H1>\a</H1>' ,
    515. 

  515. 	   'title2'              : '~A~<H2>\a</H2>' ,
    516. 

  516. 	   'title3'              : '~A~<H3>\a</H3>' ,
    517. 

  517. 	   'title4'              : '~A~<H4>\a</H4>' ,
    518. 

  518. 	   'title5'              : '~A~<H5>\a</H5>' ,
    519. 

  519. 	   'blockVerbOpen'       : '<PRE>'          ,
    520. 

  520. 	   'blockVerbClose'      : '</PRE>'         ,
    521. 

  521. 	   'blockQuoteOpen'      : '<BLOCKQUOTE>'   ,
    522. 

  522. 	   'blockQuoteClose'     : '</BLOCKQUOTE>'  ,
    523. 

  523. 	   'fontMonoOpen'        : '<CODE>'         ,
    524. 

  524. 	   'fontMonoClose'       : '</CODE>'        ,
    525. 

  525. 	   'fontBoldOpen'        : '<B>'            ,
    526. 

  526. 	   'fontBoldClose'       : '</B>'           ,
    527. 

  527. 	   'fontItalicOpen'      : '<I>'            ,
    528. 

  528. 	   'fontItalicClose'     : '</I>'           ,
    529. 

  529. 	   'fontUnderlineOpen'   : '<U>'            ,
    530. 

  530. 	   'fontUnderlineClose'  : '</U>'           ,
    531. 

  531. 	   'listOpen'            : '<UL>'           ,
    532. 

  532. 	   'listClose'           : '</UL>'          ,
    533. 

  533. 	   'listItemOpen'        : '<LI>'           ,
    534. 

  534. 	   'numlistOpen'         : '<OL>'           ,
    535. 

  535. 	   'numlistClose'        : '</OL>'          ,
    536. 

  536. 	   'numlistItemOpen'     : '<LI>'           ,
    537. 

  537. 	   'deflistOpen'         : '<DL>'           ,
    538. 

  538. 	   'deflistClose'        : '</DL>'          ,
    539. 

  539. 	   'deflistItem1Open'    : '<DT>'           ,
    540. 

  540. 	   'deflistItem1Close'   : '</DT>'          ,
    541. 

  541. 	   'deflistItem2Open'    : '<DD>'           ,
    542. 

  542. 	   'bar1'                : '<HR NOSHADE SIZE=1>'        ,
    543. 

  543. 	   'bar2'                : '<HR NOSHADE SIZE=5>'        ,
    544. 

  544. 	   'url'                 : '<A HREF="\a">\a</A>'        ,
    545. 

  545. 	   'urlMark'             : '<A HREF="\a">\a</A>'        ,
    546. 

  546. 	   'email'               : '<A HREF="mailto:\a">\a</A>' ,
    547. 

  547. 	   'emailMark'           : '<A HREF="mailto:\a">\a</A>' ,
    548. 

  548. 	   'img'                :'<IMG ALIGN="~A~" SRC="\a" BORDER="0" ALT="">',
    549. 

  549. 	   'tableOpen'           : '<TABLE~A~ CELLPADDING="4"~B~>',
    550. 

  550. 	   'tableClose'          : '</TABLE>'       ,
    551. 

  551. 	   'tableRowOpen'        : '<TR>'           ,
    552. 

  552. 	   'tableRowClose'       : '</TR>'          ,
    553. 

  553. 	   'tableCellOpen'       : '<TD\a>'         ,
    554. 

  554. 	   'tableCellClose'      : '</TD>'          ,
    555. 

  555. 	   'tableTitleCellOpen'  : '<TH>'           ,
    556. 

  556. 	   'tableTitleCellClose' : '</TH>'          ,
    557. 

  557. 	   'tableBorder'         : ' BORDER="1"'    ,
    558. 

  558. 	   'tableAlignCenter'    : ' ALIGN="center"',
    559. 

  559. 	   'tableCellAlignRight' : ' ALIGN="right"' ,
    560. 

  560. 	   'tableCellAlignCenter': ' ALIGN="center"',
    561. 

  561. 	   'anchor'              : '<A NAME="\a"></A>\n',
    562. 

  562. 	   'tocOpenCss'          : '<DIV CLASS="toc" ID="toc">',
    563. 

  563. 	   'tocCloseCss'         : '</DIV>',
    564. 

  564. 	   'bodyOpenCss'         : '<DIV CLASS="body" ID="body">',
    565. 

  565. 	   'bodyCloseCss'        : '</DIV>',
    566. 

  566. 	   'comment'             : '<!-- \a -->'    ,
    567. 

  567. 	   'EOD'                 : '</BODY></HTML>'
    568. 

  568. 	},
    569. 

  569. 	
    570. 

  570. 	#TIP xhtml inherits all HTML definitions (lowercased)
    571. 

  571. 	#TIP http://www.w3.org/TR/xhtml1/#guidelines
    572. 

  572. 	#TIP http://www.htmlref.com/samples/Chapt17/17_08.htm
    573. 

  573. 	'xhtml': {
    574. 

  574. 	   'listItemClose'       : '</li>'          ,
    575. 

  575. 	   'numlistItemClose'    : '</li>'          ,
    576. 

  576. 	   'deflistItem2Close'   : '</dd>'          ,
    577. 

  577. 	   'bar1'                : '<hr class="light" />',
    578. 

  578. 	   'bar2'                : '<hr class="heavy" />',
    579. 

  579. 	   'anchor'              : '<a id="\a" name="\a"></a>\n',
    580. 

  580. 	   'img'               :'<img align="~A~" src="\a" border="0" alt=""/>',
    581. 

  581. 	},
    582. 

  582. 	
    583. 

  583. 	'sgml': {
    584. 

  584. 	   'paragraphOpen'       : '<p>'                ,
    585. 

  585. 	   'title1'              : '<sect>\a~A~<p>'     ,
    586. 

  586. 	   'title2'              : '<sect1>\a~A~<p>'    ,
    587. 

  587. 	   'title3'              : '<sect2>\a~A~<p>'    ,
    588. 

  588. 	   'title4'              : '<sect3>\a~A~<p>'    ,
    589. 

  589. 	   'title5'              : '<sect4>\a~A~<p>'    ,
    590. 

  590. 	   'blockVerbOpen'       : '<tscreen><verb>'    ,
    591. 

  591. 	   'blockVerbClose'      : '</verb></tscreen>'  ,
    592. 

  592. 	   'blockQuoteOpen'      : '<quote>'            ,
    593. 

  593. 	   'blockQuoteClose'     : '</quote>'           ,
    594. 

  594. 	   'fontMonoOpen'        : '<tt>'               ,
    595. 

  595. 	   'fontMonoClose'       : '</tt>'              ,
    596. 

  596. 	   'fontBoldOpen'        : '<bf>'               ,
    597. 

  597. 	   'fontBoldClose'       : '</bf>'              ,
    598. 

  598. 	   'fontItalicOpen'      : '<em>'               ,
    599. 

  599. 	   'fontItalicClose'     : '</em>'              ,
    600. 

  600. 	   'fontUnderlineOpen'   : '<bf><em>'           ,
    601. 

  601. 	   'fontUnderlineClose'  : '</em></bf>'         ,
    602. 

  602. 	   'listOpen'            : '<itemize>'          ,
    603. 

  603. 	   'listClose'           : '</itemize>'         ,
    604. 

  604. 	   'listItemOpen'        : '<item>'             ,
    605. 

  605. 	   'numlistOpen'         : '<enum>'             ,
    606. 

  606. 	   'numlistClose'        : '</enum>'            ,
    607. 

  607. 	   'numlistItemOpen'     : '<item>'             ,
    608. 

  608. 	   'deflistOpen'         : '<descrip>'          ,
    609. 

  609. 	   'deflistClose'        : '</descrip>'         ,
    610. 

  610. 	   'deflistItem1Open'    : '<tag>'              ,
    611. 

  611. 	   'deflistItem1Close'   : '</tag>'             ,
    612. 

  612. 	   'bar1'                : '<!-- \a -->'        ,
    613. 

  613. 	   'bar2'                : '<!-- \a -->'        ,
    614. 

  614. 	   'url'                 : '<htmlurl url="\a" name="\a">'        ,
    615. 

  615. 	   'urlMark'             : '<htmlurl url="\a" name="\a">'        ,
    616. 

  616. 	   'email'               : '<htmlurl url="mailto:\a" name="\a">' ,
    617. 

  617. 	   'emailMark'           : '<htmlurl url="mailto:\a" name="\a">' ,
    618. 

  618. 	   'img'                 : '<figure><ph vspace=""><img src="\a">'+\
    619. 

  619. 	                           '</figure>'                           ,
    620. 

  620. 	   'tableOpen'           : '<table><tabular ca="~C~">'           ,
    621. 

  621. 	   'tableClose'          : '</tabular></table>' ,
    622. 

  622. 	   'tableRowSep'         : '<rowsep>'           ,
    623. 

  623. 	   'tableCellSep'        : '<colsep>'           ,
    624. 

  624. 	   'tableColAlignLeft'   : 'l'                  ,
    625. 

  625. 	   'tableColAlignRight'  : 'r'                  ,
    626. 

  626. 	   'tableColAlignCenter' : 'c'                  ,
    627. 

  627. 	   'comment'             : '<!-- \a -->'        ,
    628. 

  628. 	   'anchor'              : '<label id="\a">'    ,
    629. 

  629. 	   'TOC'                 : '<toc>'              ,
    630. 

  630. 	   'EOD'                 : '</article>'
    631. 

  631. 	},
    632. 

  632. 	
    633. 

  633. 	'tex': {
    634. 

  634. 	   'title1'              : '\n\section*{\a}',
    635. 

  635. 	   'title2'              : '\\subsection*{\a}'       ,
    636. 

  636. 	   'title3'              : '\\subsubsection*{\a}'    ,
    637. 

  637. 	   # title 4/5: DIRTY: para+BF+\\+\n
    638. 

  638. 	   'title4'              : '\\paragraph{}\\textbf{\a}\\\\\n',
    639. 

  639. 	   'title5'              : '\\paragraph{}\\textbf{\a}\\\\\n',
    640. 

  640. 	   'numtitle1'           : '\n\section{\a}',
    641. 

  641. 	   'numtitle2'           : '\\subsection{\a}'       ,
    642. 

  642. 	   'numtitle3'           : '\\subsubsection{\a}'    ,
    643. 

  643. 	   'blockVerbOpen'       : '\\begin{verbatim}'   ,
    644. 

  644. 	   'blockVerbClose'      : '\\end{verbatim}'     ,
    645. 

  645. 	   'blockQuoteOpen'      : '\\begin{quotation}'  ,
    646. 

  646. 	   'blockQuoteClose'     : '\\end{quotation}'    ,
    647. 

  647. 	   'fontMonoOpen'        : '\\texttt{'           ,
    648. 

  648. 	   'fontMonoClose'       : '}'                   ,
    649. 

  649. 	   'fontBoldOpen'        : '\\textbf{'           ,
    650. 

  650. 	   'fontBoldClose'       : '}'                   ,
    651. 

  651. 	   'fontItalicOpen'      : '\\textit{'           ,
    652. 

  652. 	   'fontItalicClose'     : '}'                   ,
    653. 

  653. 	   'fontUnderlineOpen'   : '\\underline{'        ,
    654. 

  654. 	   'fontUnderlineClose'  : '}'                   ,
    655. 

  655. 	   'listOpen'            : '\\begin{itemize}'    ,
    656. 

  656. 	   'listClose'           : '\\end{itemize}'      ,
    657. 

  657. 	   'listItemOpen'        : '\\item '             ,
    658. 

  658. 	   'numlistOpen'         : '\\begin{enumerate}'  ,
    659. 

  659. 	   'numlistClose'        : '\\end{enumerate}'    ,
    660. 

  660. 	   'numlistItemOpen'     : '\\item '             ,
    661. 

  661. 	   'deflistOpen'         : '\\begin{description}',
    662. 

  662. 	   'deflistClose'        : '\\end{description}'  ,
    663. 

  663. 	   'deflistItem1Open'    : '\\item['             ,
    664. 

  664. 	   'deflistItem1Close'   : ']'                   ,
    665. 

  665. 	   'bar1'                : '\n\\hrulefill{}\n'   ,
    666. 

  666. 	   'bar2'                : '\n\\rule{\linewidth}{1mm}\n',
    667. 

  667. 	   'url'                 : '\\url{\a}'                  ,
    668. 

  668. 	   'urlMark'             : '\\textit{\a} (\\url{\a})'   ,
    669. 

  669. 	   'email'               : '\\url{\a}'                  ,
    670. 

  670. 	   'emailMark'           : '\\textit{\a} (\\url{\a})'   ,
    671. 

  671. 	   'img'                 : '\\includegraphics{\a}',
    672. 

  672. 	   'tableOpen'           : '\\begin{center}\\begin{tabular}{|~C~|}',
    673. 

  673. 	   'tableClose'          : '\\end{tabular}\\end{center}',
    674. 

  674. 	   'tableRowOpen'        : '\\hline ' ,
    675. 

  675. 	   'tableRowClose'       : ' \\\\'    ,
    676. 

  676. 	   'tableCellSep'        : ' & '      ,
    677. 

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

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

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

  680. 	   'tableColAlignSep'    : '|'        ,
    681. 

  681. 	   'comment'             : '% \a'     ,
    682. 

  682. 	   'TOC'                 : '\\tableofcontents\\clearpage',
    683. 

  683. 	   'EOD'                 : '\\end{document}'
    684. 

  684. 	},
    685. 

  685. 	
    686. 

  686. 	'moin': {
    687. 

  687. 	   'title1'              : '= \a ='        ,
    688. 

  688. 	   'title2'              : '== \a =='      ,
    689. 

  689. 	   'title3'              : '=== \a ==='    ,
    690. 

  690. 	   'title4'              : '==== \a ===='  ,
    691. 

  691. 	   'title5'              : '===== \a =====',
    692. 

  692. 	   'blockVerbOpen'       : '{{{'           ,
    693. 

  693. 	   'blockVerbClose'      : '}}}'           ,
    694. 

  694. 	   'blockQuoteLine'      : '  '            ,
    695. 

  695. 	   'fontMonoOpen'        : '{{{'           ,
    696. 

  696. 	   'fontMonoClose'       : '}}}'           ,
    697. 

  697. 	   'fontBoldOpen'        : "'''"           ,
    698. 

  698. 	   'fontBoldClose'       : "'''"           ,
    699. 

  699. 	   'fontItalicOpen'      : "''"            ,
    700. 

  700. 	   'fontItalicClose'     : "''"            ,
    701. 

  701. 	   'fontUnderlineOpen'   : "__"            ,
    702. 

  702. 	   'fontUnderlineClose'  : "__"            ,
    703. 

  703. 	   'listItemOpen'        : ' * '           ,
    704. 

  704. 	   'numlistItemOpen'     : ' \a. '         ,
    705. 

  705. 	   'bar1'                : '----'          ,
    706. 

  706. 	   'bar2'                : '----'          ,
    707. 

  707. 	   'url'                 : '[\a]'          ,
    708. 

  708. 	   'urlMark'             : '[\a \a]'       ,
    709. 

  709. 	   'email'               : '[\a]'          ,
    710. 

  710. 	   'emailMark'           : '[\a \a]'       ,
    711. 

  711. 	   'img'                 : '[\a]'          ,
    712. 

  712. 	   'tableRowOpen'        : '||'            ,
    713. 

  713. 	   'tableCellOpen'       : '\a'            ,
    714. 

  714. 	   'tableCellClose'      : '||'            ,
    715. 

  715. 	   'tableTitleCellClose' : '||'            ,
    716. 

  716. 	   'tableCellAlignRight' : '<)>'           ,
    717. 

  717. 	   'tableCellAlignCenter': '<:>'           ,
    718. 

  718. 	   'comment'             : '## \a'         ,
    719. 

  719. 	   'TOC'                 : '[[TableOfContents]]'
    720. 

  720. 	},
    721. 

  721. 	
    722. 

  722. 	'mgp': {
    723. 

  723. 	   'paragraphOpen'       : '%font "normal", size 5'     ,
    724. 

  724. 	   'title1'              : '%page\n\n\a\n'              ,
    725. 

  725. 	   'title2'              : '%page\n\n\a\n'              ,
    726. 

  726. 	   'title3'              : '%page\n\n\a\n'              ,
    727. 

  727. 	   'title4'              : '%page\n\n\a\n'              ,
    728. 

  728. 	   'title5'              : '%page\n\n\a\n'              ,
    729. 

  729. 	   'blockVerbOpen'       : '%font "mono"'               ,
    730. 

  730. 	   'blockVerbClose'      : '%font "normal"'             ,
    731. 

  731. 	   'blockQuoteOpen'      : '%prefix "       "'          ,
    732. 

  732. 	   'blockQuoteClose'     : '%prefix "  "'               ,
    733. 

  733. 	   'fontMonoOpen'        : '\n%cont, font "mono"\n'     ,
    734. 

  734. 	   'fontMonoClose'       : '\n%cont, font "normal"\n'   ,
    735. 

  735. 	   'fontBoldOpen'        : '\n%cont, font "normal-b"\n' ,
    736. 

  736. 	   'fontBoldClose'       : '\n%cont, font "normal"\n'   ,
    737. 

  737. 	   'fontItalicOpen'      : '\n%cont, font "normal-i"\n' ,
    738. 

  738. 	   'fontItalicClose'     : '\n%cont, font "normal"\n'   ,
    739. 

  739. 	   'fontUnderlineOpen'   : '\n%cont, fore "cyan"\n'     ,
    740. 

  740. 	   'fontUnderlineClose'  : '\n%cont, fore "white"\n'    ,
    741. 

  741. 	   'listItemLine'        : '\t'                         ,
    742. 

  742. 	   'numlistItemLine'     : '\t'                         ,
    743. 

  743. 	   'deflistItem1Open'    : '\t\n%cont, font "normal-b"\n',
    744. 

  744. 	   'deflistItem1Close'   : '\n%cont, font "normal"\n'   ,
    745. 

  745. 	   'bar1'                : '%bar "white" 5'             ,
    746. 

  746. 	   'bar2'                : '%pause'                     ,
    747. 

  747. 	   'url'                 : '\n%cont, fore "cyan"\n\a'   +\
    748. 

  748. 	                           '\n%cont, fore "white"\n'    ,
    749. 

  749. 	   'urlMark'             : '\a \n%cont, fore "cyan"\n\a'+\
    750. 

  750. 	                           '\n%cont, fore "white"\n'    ,
    751. 

  751. 	   'email'               : '\n%cont, fore "cyan"\n\a'   +\
    752. 

  752. 	                           '\n%cont, fore "white"\n'    ,
    753. 

  753. 	   'emailMark'           : '\a \n%cont, fore "cyan"\n\a'+\
    754. 

  754. 	                           '\n%cont, fore "white"\n'    ,
    755. 

  755. 	   'img'                 : '\n%~A~\n%newimage "\a"\n%left\n',
    756. 

  756. 	   'comment'             : '%% \a'                      ,
    757. 

  757. 	   'tocOpen'             : '%page\n\n\n'                ,
    758. 

  758. 	   'EOD'                 : '%%EOD'
    759. 

  759. 	},
    760. 

  760. 	
    761. 

  761. 	# man groff_man ; man 7 groff
    762. 

  762. 	'man': {
    763. 

  763. 	   'paragraphOpen'       : '.P'     ,
    764. 

  764. 	   'title1'              : '.SH \a' ,
    765. 

  765. 	   'title2'              : '.SS \a' ,
    766. 

  766. 	   'title3'              : '.SS \a' ,
    767. 

  767. 	   'title4'              : '.SS \a' ,
    768. 

  768. 	   'title5'              : '.SS \a' ,
    769. 

  769. 	   'blockVerbOpen'       : '.nf'    ,
    770. 

  770. 	   'blockVerbClose'      : '.fi\n'  ,
    771. 

  771. 	   'blockQuoteOpen'      : '.RS'    ,
    772. 

  772. 	   'blockQuoteClose'     : '.RE'    ,
    773. 

  773. 	   'fontBoldOpen'        : '\\fB'   ,
    774. 

  774. 	   'fontBoldClose'       : '\\fR'   ,
    775. 

  775. 	   'fontItalicOpen'      : '\\fI'   ,
    776. 

  776. 	   'fontItalicClose'     : '\\fR'   ,
    777. 

  777. 	   'listOpen'            : '.RS'    ,
    778. 

  778. 	   'listItemOpen'        : '.IP \(bu 3\n',
    779. 

  779. 	   'listClose'           : '.RE'    ,
    780. 

  780. 	   'numlistOpen'         : '.RS'    ,
    781. 

  781. 	   'numlistItemOpen'     : '.IP \a. 3\n',
    782. 

  782. 	   'numlistClose'        : '.RE'    ,
    783. 

  783. 	   'deflistItem1Open'    : '.TP\n'  ,
    784. 

  784. 	   'bar1'                : '\n\n'   ,
    785. 

  785. 	   'bar2'                : '\n\n'   ,
    786. 

  786. 	   'url'                 : '\a'     ,
    787. 

  787. 	   'urlMark'             : '\a (\a)',
    788. 

  788. 	   'email'               : '\a'     ,
    789. 

  789. 	   'emailMark'           : '\a (\a)',
    790. 

  790. 	   'img'                 : '\a'     ,
    791. 

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

  792. 	   'tableClose'          : '.TE'     ,
    793. 

  793. 	   'tableRowOpen'        : ' '       ,
    794. 

  794. 	   'tableCellSep'        : '^'       ,
    795. 

  795. 	   'tableAlignCenter'    : 'center, ',
    796. 

  796. 	   'tableBorder'         : 'allbox, ',
    797. 

  797. 	   'tableColAlignLeft'   : 'l'       ,
    798. 

  798. 	   'tableColAlignRight'  : 'r'       ,
    799. 

  799. 	   'tableColAlignCenter' : 'c'       ,
    800. 

  800. 	   'comment'             : '.\\" \a'
    801. 

  801. 	},
    802. 

  802. 	
    803. 

  803. 	'pm6': {
    804. 

  804. 	   'paragraphOpen'       : '<@Normal:>'    ,
    805. 

  805. 	   'title1'              : '\n<@Title1:>\a',
    806. 

  806. 	   'title2'              : '\n<@Title2:>\a',
    807. 

  807. 	   'title3'              : '\n<@Title3:>\a',
    808. 

  808. 	   'title4'              : '\n<@Title4:>\a',
    809. 

  809. 	   'title5'              : '\n<@Title5:>\a',
    810. 

  810. 	   'blockVerbOpen'       : '<@PreFormat:>' ,
    811. 

  811. 	   'blockQuoteLine'      : '<@Quote:>'     ,
    812. 

  812. 	   'fontMonoOpen'        : '<FONT "Lucida Console"><SIZE 9>' ,
    813. 

  813. 	   'fontMonoClose'       : '<SIZE$><FONT$>',
    814. 

  814. 	   'fontBoldOpen'        : '<B>'           ,
    815. 

  815. 	   'fontBoldClose'       : '<P>'           ,
    816. 

  816. 	   'fontItalicOpen'      : '<I>'           ,
    817. 

  817. 	   'fontItalicClose'     : '<P>'           ,
    818. 

  818. 	   'fontUnderlineOpen'   : '<U>'           ,
    819. 

  819. 	   'fontUnderlineClose'  : '<P>'           ,
    820. 

  820. 	   'listOpen'            : '<@Bullet:>'    ,
    821. 

  821. 	   'listItemOpen'        : '\x95\t'        ,  # \x95 == ~U
    822. 

  822. 	   'numlistOpen'         : '<@Bullet:>'    ,
    823. 

  823. 	   'numlistItemOpen'     : '\x95\t'        ,
    824. 

  824. 	   'bar1'                : '\a'            ,
    825. 

  825. 	   'bar2'                : '\a'            ,
    826. 

  826. 	   'url'                 : '<U>\a<P>'      ,  # underline
    827. 

  827. 	   'urlMark'             : '\a <U>\a<P>'   ,
    828. 

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

  829. 	   'emailMark'           : '\a \a'         ,
    830. 

  830. 	   'img'                 : '\a'
    831. 

  831. 	}
    832. 

  832. 	}
    833. 

  833. 	
    834. 

  834. 	# make the HTML -> XHTML inheritance
    835. 

  835. 	xhtml = alltags['html'].copy()
    836. 

  836. 	for key in xhtml.keys(): xhtml[key] = string.lower(xhtml[key])
    837. 

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

  838. 	if HTML_LOWER: alltags['html'] = xhtml.copy()
    839. 

  839. 	xhtml.update(alltags['xhtml'])
    840. 

  840. 	alltags['xhtml'] = xhtml.copy()
    841. 

  841. 	
    842. 

  842. 	# compose the target tags dictionary
    843. 

  843. 	tags = {}
    844. 

  844. 	target_tags = alltags[target].copy()
    845. 

  845. 	
    846. 

  846. 	for key in keys: tags[key] = ''     # create empty keys
    847. 

  847. 	for key in target_tags.keys():
    848. 

  848. 		tags[key] = maskEscapeChar(target_tags[key]) # populate
    849. 

  849. 	
    850. 

  850. 	return tags
    851. 

  851. 

  852. 

  853. ##############################################################################
    854. 

  854. 

  855. 

  856. def getRules(target):
    857. 

  857. 	"Returns all the target-specific syntax rules"
    858. 

  858. 	
    859. 

  859. 	ret = {}
    860. 

  860. 	allrules = [
    861. 

  861. 	
    862. 

  862. 	 # target rules (ON/OFF)
    863. 

  863. 	  'linkable',             # target supports external links
    864. 

  864. 	  'tableable',            # target supports tables
    865. 

  865. 	  'imglinkable',          # target supports images as links
    866. 

  866. 	  'imgalignable',         # target supports image alignment
    867. 

  867. 	  'imgasdefterm',         # target supports image as definition term
    868. 

  868. 	  'autonumberlist',       # target supports numbered lists natively
    869. 

  869. 	  'autonumbertitle',      # target supports numbered titles natively
    870. 

  870. 	  'parainsidelist',       # lists items supports paragraph
    871. 

  871. 	  'spacedlistitem',       # lists support blank lines between items
    872. 

  872. 	  'listnotnested',        # lists cannot be nested
    873. 

  873. 	  'quotenotnested',       # quotes cannot be nested
    874. 

  874. 	  'verbblocknotescaped',  # don't escape specials in verb block
    875. 

  875. 	  'verbblockfinalescape', # do final escapes in verb block
    876. 

  876. 	  'escapeurl',            # escape special in link URL
    877. 

  877. 	  'onelinepara',          # dump paragraph as a single long line
    878. 

  878. 	  'tabletitlerowinbold',  # manually bold any cell on table titles
    879. 

  879. 	  'tablecellstrip',       # strip extra spaces from each table cell
    880. 

  880. 	  'barinsidequote',       # bars are allowed inside quote blocks
    881. 

  881. 	  'finalescapetitle',     # perform final escapes on title lines
    882. 

  882. 	
    883. 

  883. 	# target code beautify (ON/OFF)
    884. 

  884. 	  'indentverbblock',      # add leading spaces to verb block lines
    885. 

  885. 	  'breaktablecell',       # break lines after any table cell
    886. 

  886. 	  'breaktablelineopen',   # break line after opening table line
    887. 

  887. 	  'notbreaklistopen',     # don't break line after opening a new list
    888. 

  888. 	  'notbreakparaopen',     # don't break line after opening a new para
    889. 

  889. 	  'keepquoteindent',      # don't remove the leading TABs on quotes
    890. 

  890. 	  'keeplistindent',       # don't remove the leading spaces on lists
    891. 

  891. 	  'blankendmotherlist',   # append a blank line at the mother list end
    892. 

  892. 	  'blankendtable',        # append a blank line at the table end
    893. 

  893. 	  'tagnotindentable',     # tags must be placed at the line begining
    894. 

  894. 	
    895. 

  895. 	# value settings
    896. 

  896. 	  'listmaxdepth',         # maximum depth for lists
    897. 

  897. 	  'tablecellaligntype'    # type of table cell align: cell, column
    898. 

  898. 	]
    899. 

  899. 	
    900. 

  900. 	rules_bank = {
    901. 

  901. 	  'txt' : {
    902. 

  902. 	    'indentverbblock':1,
    903. 

  903. 	    'spacedlistitem':1,
    904. 

  904. 	    'parainsidelist':1,
    905. 

  905. 	    'keeplistindent':1,
    906. 

  906. 	    'barinsidequote':1,
    907. 

  907. 	    'blankendmotherlist':1
    908. 

  908. 	    },
    909. 

  909. 	  'html': {
    910. 

  910. 	    'indentverbblock':1,
    911. 

  911. 	    'linkable':1,
    912. 

  912. 	    'escapeurl':1,
    913. 

  913. 	    'imglinkable':1,
    914. 

  914. 	    'imgalignable':1,
    915. 

  915. 	    'imgasdefterm':1,
    916. 

  916. 	    'autonumberlist':1,
    917. 

  917. 	    'spacedlistitem':1,
    918. 

  918. 	    'parainsidelist':1,
    919. 

  919. 	    'blankendmotherlist':1,
    920. 

  920. 	    'tableable':1,
    921. 

  921. 	    'tablecellstrip':1,
    922. 

  922. 	    'blankendtable':1,
    923. 

  923. 	    'breaktablecell':1,
    924. 

  924. 	    'breaktablelineopen':1,
    925. 

  925. 	    'keeplistindent':1,
    926. 

  926. 	    'keepquoteindent':1,
    927. 

  927. 	    'barinsidequote':1,
    928. 

  928. 	    'tablecellaligntype':'cell'
    929. 

  929. 	    },
    930. 

  930. 	  #TIP xhtml inherits all HTML rules
    931. 

  931. 	  'xhtml': {
    932. 

  932. 	    },
    933. 

  933. 	  'sgml': {
    934. 

  934. 	    'linkable':1,
    935. 

  935. 	    'escapeurl':1,
    936. 

  936. 	    'autonumberlist':1,
    937. 

  937. 	    'spacedlistitem':1,
    938. 

  938. 	    'blankendmotherlist':1,
    939. 

  939. 	    'tableable':1,
    940. 

  940. 	    'tablecellstrip':1,
    941. 

  941. 	    'blankendtable':1,
    942. 

  942. 	    'quotenotnested':1,
    943. 

  943. 	    'keeplistindent':1,
    944. 

  944. 	    'keepquoteindent':1,
    945. 

  945. 	    'barinsidequote':1,
    946. 

  946. 	    'finalescapetitle':1,
    947. 

  947. 	    'tablecellaligntype':'column'
    948. 

  948. 	    },
    949. 

  949. 	  'mgp' : {
    950. 

  950. 	    'blankendmotherlist':1,
    951. 

  951. 	    'tagnotindentable':1,
    952. 

  952. 	    'spacedlistitem':1,
    953. 

  953. 	    'imgalignable':1,
    954. 

  954. 	    },
    955. 

  955. 	  'tex' : {
    956. 

  956. 	    'autonumberlist':1,
    957. 

  957. 	    'autonumbertitle':1,
    958. 

  958. 	    'spacedlistitem':1,
    959. 

  959. 	    'blankendmotherlist':1,
    960. 

  960. 	    'tableable':1,
    961. 

  961. 	    'tablecellstrip':1,
    962. 

  962. 	    'tabletitlerowinbold':1,
    963. 

  963. 	    'blankendtable':1,
    964. 

  964. 	    'verbblocknotescaped':1,
    965. 

  965. 	    'keeplistindent':1,
    966. 

  966. 	    'listmaxdepth':4,
    967. 

  967. 	    'barinsidequote':1,
    968. 

  968. 	    'finalescapetitle':1,
    969. 

  969. 	    'tablecellaligntype':'column'
    970. 

  970. 	    },
    971. 

  971. 	  'moin': {
    972. 

  972. 	    'spacedlistitem':1,
    973. 

  973. 	    'linkable':1,
    974. 

  974. 	    'blankendmotherlist':1,
    975. 

  975. 	    'keeplistindent':1,
    976. 

  976. 	    'tableable':1,
    977. 

  977. 	    'barinsidequote':1,
    978. 

  978. 	    'blankendtable':1,
    979. 

  979. 	    'tabletitlerowinbold':1,
    980. 

  980. 	    'tablecellstrip':1,
    981. 

  981. 	    'tablecellaligntype':'cell'
    982. 

  982. 	    },
    983. 

  983. 	  'man' : {
    984. 

  984. 	    'spacedlistitem':1,
    985. 

  985. 	    'indentverbblock':1,
    986. 

  986. 	    'blankendmotherlist':1,
    987. 

  987. 	    'tagnotindentable':1,
    988. 

  988. 	    'tableable':1,
    989. 

  989. 	    'tablecellaligntype':'column',
    990. 

  990. 	    'tabletitlerowinbold':1,
    991. 

  991. 	    'tablecellstrip':1,
    992. 

  992. 	    'blankendtable':1,
    993. 

  993. 	    'keeplistindent':0,
    994. 

  994. 	    'barinsidequote':1,
    995. 

  995. 	    'parainsidelist':0,
    996. 

  996. 	    },
    997. 

  997. 	  'pm6' : {
    998. 

  998. 	    'keeplistindent':1,
    999. 

  999. 	    'verbblockfinalescape':1,
    1000. 

  1000. 	    #TODO add support for these - maybe set a JOINNEXT char and
    1001. 

  1001. 	    #     do it on addLineBreaks()
    1002. 

  1002. 	    'notbreaklistopen':1,
    1003. 

  1003. 	    'notbreakparaopen':1,
    1004. 

  1004. 	    'barinsidequote':1,
    1005. 

  1005. 	    'onelinepara':1,
    1006. 

  1006. 	    }
    1007. 

  1007. 	}
    1008. 

  1008. 	
    1009. 

  1009. 	# get the target specific rules
    1010. 

  1010. 	if target == 'xhtml':
    1011. 

  1011. 		myrules = rules_bank['html'].copy()   # inheritance
    1012. 

  1012. 		myrules.update(rules_bank['xhtml'])   # get XHTML specific
    1013. 

  1013. 	else:
    1014. 

  1014. 		myrules = rules_bank[target].copy()
    1015. 

  1015. 	
    1016. 

  1016. 	# populate return dictionary
    1017. 

  1017. 	for key in allrules: ret[key] = 0        # reset all
    1018. 

  1018. 	ret.update(myrules)                      # get rules
    1019. 

  1019. 	
    1020. 

  1020. 	return ret
    1021. 

  1021. 

  1022. 

  1023. ##############################################################################
    1024. 

  1024. 

  1025. 

  1026. def getRegexes():
    1027. 

  1027. 	"Returns all the regexes used to find the t2t marks"
    1028. 

  1028. 	
    1029. 

  1029. 	bank = {
    1030. 

  1030. 	'blockVerbOpen':
    1031. 

  1031. 		re.compile(r'^```\s*$'),
    1032. 

  1032. 	'blockVerbClose':
    1033. 

  1033. 		re.compile(r'^```\s*$'),
    1034. 

  1034. 	'blockRawOpen':
    1035. 

  1035. 		re.compile(r'^"""\s*$'),
    1036. 

  1036. 	'blockRawClose':
    1037. 

  1037. 		re.compile(r'^"""\s*$'),
    1038. 

  1038. 	'quote':
    1039. 

  1039. 		re.compile(r'^\t+'),
    1040. 

  1040. 	'1lineVerb':
    1041. 

  1041. 		re.compile(r'^``` (?=.)'),
    1042. 

  1042. 	'1lineRaw':
    1043. 

  1043. 		re.compile(r'^""" (?=.)'),
    1044. 

  1044. 	# mono, raw, bold, italic, underline:
    1045. 

  1045. 	# - marks must be glued with the contents, no boundary spaces
    1046. 

  1046. 	# - they are greedy, so in ****bold****, turns to <b>**bold**</b>
    1047. 

  1047. 	'fontMono':
    1048. 

  1048. 		re.compile(  r'``([^\s](|.*?[^\s])`*)``'),
    1049. 

  1049. 	'raw':
    1050. 

  1050. 		re.compile(  r'""([^\s](|.*?[^\s])"*)""'),
    1051. 

  1051. 	'fontBold':
    1052. 

  1052. 		re.compile(r'\*\*([^\s](|.*?[^\s])\**)\*\*'),
    1053. 

  1053. 	'fontItalic':
    1054. 

  1054. 		re.compile(  r'//([^\s](|.*?[^\s])/*)//'),
    1055. 

  1055. 	'fontUnderline':
    1056. 

  1056. 		re.compile(  r'__([^\s](|.*?[^\s])_*)__'),
    1057. 

  1057. 	'list':
    1058. 

  1058. 		re.compile(r'^( *)(-) (?=[^ ])'),
    1059. 

  1059. 	'numlist':
    1060. 

  1060. 		re.compile(r'^( *)(\+) (?=[^ ])'),
    1061. 

  1061. 	'deflist':
    1062. 

  1062. 		re.compile(r'^( *)(:) (.*)$'),
    1063. 

  1063. 	'bar':
    1064. 

  1064. 		re.compile(r'^(\s*)([_=-]{20,})\s*$'),
    1065. 

  1065. 	'table':
    1066. 

  1066. 		re.compile(r'^ *\|\|? '),
    1067. 

  1067. 	'blankline':
    1068. 

  1068. 		re.compile(r'^\s*$'),
    1069. 

  1069. 	'comment':
    1070. 

  1070. 		re.compile(r'^%'),
    1071. 

  1071. 	
    1072. 

  1072. 	# auxiliar tag regexes
    1073. 

  1073. 	'_imgAlign'     : re.compile(r'~A~',re.I),
    1074. 

  1074. 	'_tableAlign'   : re.compile(r'~A~',re.I),
    1075. 

  1075. 	'_anchor'       : re.compile(r'~A~',re.I),
    1076. 

  1076. 	'_tableBorder'  : re.compile(r'~B~',re.I),
    1077. 

  1077. 	'_tableColAlign': re.compile(r'~C~',re.I),
    1078. 

  1078. 	}
    1079. 

  1079. 	
    1080. 

  1080. 	# special char to place data on TAGs contents  (\a == bell)
    1081. 

  1081. 	bank['x'] = re.compile('\a')
    1082. 

  1082. 	
    1083. 

  1083. 	# %%date [ (formatting) ]
    1084. 

  1084. 	bank['date'] = re.compile(r'%%date\b(\((?P<fmt>.*?)\))?', re.I)
    1085. 

  1085. 	
    1086. 

  1086. 	# almost complicated title regexes ;)
    1087. 

  1087. 	titskel = r'^ *(?P<id>%s)(?P<txt>%s)\1(\[(?P<label>\w*)\])?\s*$'
    1088. 

  1088. 	bank[   'title'] = re.compile(titskel%('[=]{1,5}','[^=](|.*[^=])'))
    1089. 

  1089. 	bank['numtitle'] = re.compile(titskel%('[+]{1,5}','[^+](|.*[^+])'))
    1090. 

  1090. 	
    1091. 

  1091. 	### complicated regexes begin here ;)
    1092. 

  1092. 	#
    1093. 

  1093. 	# textual descriptions on --help's style: [...] is optional, | is OR
    1094. 

  1094. 	
    1095. 

  1095. 	
    1096. 

  1096. 	### first, some auxiliar variables
    1097. 

  1097. 	#
    1098. 

  1098. 	
    1099. 

  1099. 	# [image.EXT]
    1100. 

  1100. 	patt_img = r'\[([\w_,.+%$#@!?+~/-]+\.(png|jpe?g|gif|eps|bmp))\]'
    1101. 

  1101. 	
    1102. 

  1102. 	# link things
    1103. 

  1103. 	urlskel = {
    1104. 

  1104. 	  'proto' : r'(https?|ftp|news|telnet|gopher|wais)://',
    1105. 

  1105. 	  'guess' : r'(www[23]?|ftp)\.',     # w/out proto, try to guess
    1106. 

  1106. 	  'login' : r'A-Za-z0-9_.-',         # for ftp://login@domain.com
    1107. 

  1107. 	  'pass'  : r'[^ @]*',               # for ftp://login:password@dom.com
    1108. 

  1108. 	  'chars' : r'A-Za-z0-9%._/~:,=$@&-',# %20(space), :80(port), D&D
    1109. 

  1109. 	  'anchor': r'A-Za-z0-9%._-',        # %nn(encoded)
    1110. 

  1110. 	  'form'  : r'A-Za-z0-9/%&=+.,@*_-', # .,@*_-(as is)
    1111. 

  1111. 	  'punct' : r'.,;:!?'
    1112. 

  1112. 	}
    1113. 

  1113. 	
    1114. 

  1114. 	# username [ :password ] @
    1115. 

  1115. 	patt_url_login = r'([%s]+(:%s)?@)?'%(urlskel['login'],urlskel['pass'])
    1116. 

  1116. 	
    1117. 

  1117. 	# [ http:// ] [ username:password@ ] domain.com [ / ]
    1118. 

  1118. 	#     [ #anchor | ?form=data ]
    1119. 

  1119. 	retxt_url = r'\b(%s%s|%s)[%s]+\b/*(\?[%s]+)?(#[%s]+)?'%(
    1120. 

  1120. 	             urlskel['proto'],patt_url_login, urlskel['guess'],
    1121. 

  1121. 	             urlskel['chars'],urlskel['form'],urlskel['anchor'])
    1122. 

  1122. 	
    1123. 

  1123. 	# filename | [ filename ] #anchor
    1124. 

  1124. 	retxt_url_local = r'[%s]+|[%s]*(#[%s]+)'%(
    1125. 

  1125. 	             urlskel['chars'],urlskel['chars'],urlskel['anchor'])
    1126. 

  1126. 	
    1127. 

  1127. 	# user@domain [ ?form=data ]
    1128. 

  1128. 	patt_email = r'\b[%s]+@([A-Za-z0-9_-]+\.)+[A-Za-z]{2,4}\b(\?[%s]+)?'%(
    1129. 

  1129. 	             urlskel['login'],urlskel['form'])
    1130. 

  1130. 	
    1131. 

  1131. 	# saving for future use
    1132. 

  1132. 	bank['_urlskel'] = urlskel
    1133. 

  1133. 	
    1134. 

  1134. 	### and now the real regexes
    1135. 

  1135. 	#
    1136. 

  1136. 	
    1137. 

  1137. 	bank['email'] = re.compile(patt_email,re.I)
    1138. 

  1138. 	
    1139. 

  1139. 	# email | url
    1140. 

  1140. 	bank['link'] = re.compile(r'%s|%s'%(retxt_url,patt_email), re.I)
    1141. 

  1141. 	
    1142. 

  1142. 	# \[ label | imagetag    url | email | filename \]
    1143. 

  1143. 	bank['linkmark'] = re.compile(
    1144. 

  1144. 		r'\[(?P<label>%s|[^]]+) (?P<link>%s|%s|%s)\]'%(
    1145. 

  1145. 		  patt_img, retxt_url, patt_email, retxt_url_local),
    1146. 

  1146. 		re.L+re.I)
    1147. 

  1147. 	
    1148. 

  1148. 	# image
    1149. 

  1149. 	bank['img'] = re.compile(patt_img, re.L+re.I)
    1150. 

  1150. 	
    1151. 

  1151. 	# all macros
    1152. 

  1152. 	bank['macro'] = bank['date']
    1153. 

  1153. 	
    1154. 

  1154. 	# special things
    1155. 

  1155. 	bank['special'] = re.compile(r'^%!\s*')
    1156. 

  1156. 	return bank
    1157. 

  1157. ### END OF regex nightmares
    1158. 

  1158. 

  1159. 

  1160. ##############################################################################
    1161. 

  1161. 

  1162. 

  1163. def echo(msg):   # for quick debug
    1164. 

  1164. 	print '\033[32;1m%s\033[m'%msg
    1165. 

  1165. def Quit(msg, exitcode=0):
    1166. 

  1166. 	print msg
    1167. 

  1167. 	sys.exit(exitcode)
    1168. 

  1168. def Error(msg):
    1169. 

  1169. 	sys.stderr.write(_("%s: Error: ")%my_name + "%s\n"%msg)
    1170. 

  1170. 	sys.stderr.flush()
    1171. 

  1171. 	sys.exit(1)
    1172. 

  1172. def ShowTraceback():
    1173. 

  1173. 	try:
    1174. 

  1174. 		from traceback import print_exc
    1175. 

  1175. 		print_exc() ; print ; print
    1176. 

  1176. 	except: pass
    1177. 

  1177. def Message(msg,level):
    1178. 

  1178. 	if level <= VERBOSE:
    1179. 

  1179. 		prefix = '-'*5
    1180. 

  1180. 		print "%s %s"%(prefix*level, msg)
    1181. 

  1181. def Debug(msg,color=0,linenr=None):
    1182. 

  1182. 	"0gray=init,1red=conf,3yellow=line,6cyan=block,2green=detail,5pink=gui"
    1183. 

  1183. 	if not DEBUG: return
    1184. 

  1184. 	if COLOR_DEBUG: msg = '\033[3%s;1m%s\033[m'%(color,msg)
    1185. 

  1185. 	if linenr is not None: msg = "LINE %04d: %s"%(linenr,msg)
    1186. 

  1186. 	print "** %s"%msg
    1187. 

  1187. def Readfile(file, remove_linebreaks=0):
    1188. 

  1188. 	if file == '-':
    1189. 

  1189. 		try: data = sys.stdin.readlines()
    1190. 

  1190. 		except: Error(_('You must feed me with data on STDIN!'))
    1191. 

  1191. 	else:
    1192. 

  1192. 		try: f = open(file); data = f.readlines() ; f.close()
    1193. 

  1193. 		except: Error(_("Cannot read file:")+"\n    %s"%file)
    1194. 

  1194. 	if remove_linebreaks:
    1195. 

  1195. 		data = map(lambda x:re.sub('[\n\r]+$','',x), data)
    1196. 

  1196. 	Message(_("Readed file (%d lines): %s")%(len(data),file),2)
    1197. 

  1197. 	return data
    1198. 

  1198. def Savefile(file, contents):
    1199. 

  1199. 	try: f = open(file, 'wb')
    1200. 

  1200. 	except: Error(_("Cannot open file for writing:")+"\n    %s"%file)
    1201. 

  1201. 	if type(contents) == type([]): doit = f.writelines
    1202. 

  1202. 	else: doit = f.write
    1203. 

  1203. 	doit(contents) ; f.close()
    1204. 

  1204. 

  1205. def showdic(dic):
    1206. 

  1206. 	for k in dic.keys(): print "%15s : %s" % (k,dic[k])
    1207. 

  1207. def dotted_spaces(txt=''):
    1208. 

  1208. 	return string.replace(txt,' ','.')
    1209. 

  1209. 

  1210. def get_rc_path():
    1211. 

  1211. 	rc_file = RC
    1212. 

  1212. 	# try to get rc dir name (usually $HOME on win and linux)
    1213. 

  1213. 	rc_dir = os.environ.get('HOME')
    1214. 

  1214. 	if rc_dir:
    1215. 

  1215. 		# compose path and return it if the file exists
    1216. 

  1216. 		rc_path = os.path.join(rc_dir, rc_file)
    1217. 

  1217. 		if os.path.isfile(rc_path):
    1218. 

  1218. 			return rc_path
    1219. 

  1219. 	return ''
    1220. 

  1220. 

  1221. 

  1222. 

  1223. ##############################################################################
    1224. 

  1224. 

  1225. class CommandLine:
    1226. 

  1226. 	"""Command Line class - Masters command line
    1227. 

    1228. 

  1228. 	This class checks and extract data from the provided command line.
    1229. 

  1229. 	The --long options and flags are taken from the global OPTIONS,
    1230. 

  1230. 	FLAGS and ACTIONS dictionaries. The short options are registered
    1231. 

  1231. 	here, and also their equivalence to the long ones.
    1232. 

  1232. 

  1233. 	METHODS:
    1234. 

  1234. 	  _compose_short_opts() -> str
    1235. 

  1235. 	  _compose_long_opts() -> list
    1236. 

  1236. 	      Compose the valid short and long options list, on the
    1237. 

  1237. 	      'getopt' format.
    1238. 

  1238. 	  
    1239. 

  1239. 	  parse() -> (opts, args)
    1240. 

  1240. 	      Call getopt to check and parse the command line.
    1241. 

  1241. 	      It expects to receive the command line as a list, and
    1242. 

  1242. 	      without the program name (sys.argv[1:]).
    1243. 

  1243. 	  
    1244. 

  1244. 	  get_raw_config() -> [RAW config]
    1245. 

  1245. 	      Scans command line and convert the data to the RAW config
    1246. 

  1246. 	      format. See ConfigMaster class to the RAW format description.
    1247. 

  1247. 	      Optional 'ignore' and 'filter' arguments are used to filter
    1248. 

  1248. 	      in or out specified keys.
    1249. 

  1249. 	  
    1250. 

  1250. 	  compose_cmdline(dict) -> [Command line]
    1251. 

  1251. 	      Compose a command line list from an already parsed config
    1252. 

  1252. 	      dictionary, generated from RAW by ConfigMaster(). Use
    1253. 

  1253. 	      this to compose an optimal command line for a group of
    1254. 

  1254. 	      options.
    1255. 

  1255. 	
    1256. 

  1256. 	The get_raw_config() calls parse(), so the tipical use of this
    1257. 

  1257. 	class is:
    1258. 

  1258. 	
    1259. 

  1259.             raw = CommandLine().get_raw_config(sys.argv[1:])
    1260. 

  1260. 	"""
    1261. 

  1261. 	def __init__(self):
    1262. 

  1262. 		self.all_options = OPTIONS.keys()
    1263. 

  1263. 		self.all_flags   = FLAGS.keys()
    1264. 

  1264. 		self.all_actions = ACTIONS.keys()
    1265. 

  1265. 		
    1266. 

  1266. 		# short:long options equivalence
    1267. 

  1267. 		self.short_long = {
    1268. 

  1268. 		  'h':'help'     ,   'V':'version',
    1269. 

  1269. 		  'n':'enum-title',  'i':'infile' ,
    1270. 

  1270. 		  'H':'no-headers',  'o':'outfile',
    1271. 

  1271. 		  'v':'verbose'   ,  't':'target'
    1272. 

  1272. 		}
    1273. 

  1273. 		
    1274. 

  1274. 		# compose valid short and long options data for getopt
    1275. 

  1275. 		self.short_opts = self._compose_short_opts()
    1276. 

  1276. 		self.long_opts  = self._compose_long_opts()
    1277. 

  1277. 	
    1278. 

  1278. 	def _compose_short_opts(self):
    1279. 

  1279. 		"Returns a string like 'hVt:o' with all short options/flags"
    1280. 

  1280. 		ret = []
    1281. 

  1281. 		for opt in self.short_long.keys():
    1282. 

  1282. 			long = self.short_long[opt]
    1283. 

  1283. 			if long in self.all_options: # is flag or option?
    1284. 

  1284. 				opt = opt+':'        # option: have param
    1285. 

  1285. 			ret.append(opt)
    1286. 

  1286. 		Debug('Valid SHORT options: %s'%ret)
    1287. 

  1287. 		return string.join(ret, '')
    1288. 

  1288. 	
    1289. 

  1289. 	def _compose_long_opts(self):
    1290. 

  1290. 		"Returns a list with all the valid long options/flags"
    1291. 

  1291. 		ret = map(lambda x:x+'=', self.all_options)       # add =
    1292. 

  1292. 		ret.extend(self.all_flags)                        # flag ON
    1293. 

  1293. 		ret.extend(self.all_actions)                      # acts
    1294. 

  1294. 		ret.extend(map(lambda x:'no-'+x, self.all_flags)) # add no-*
    1295. 

  1295. 		ret.extend(['no-style'])                   # turn OFF option
    1296. 

  1296. 		ret.extend(['no-encoding'])                # turn OFF option
    1297. 

  1297. 		ret.extend(['no-outfile'])                 # turn OFF option
    1298. 

  1298. 		Debug('Valid LONG options: %s'%ret)
    1299. 

  1299. 		return ret
    1300. 

  1300. 	
    1301. 

  1301. 	def _tokenize(self, cmd_string=''):
    1302. 

  1302. 		"Convert a command line string to a list"
    1303. 

  1303. 		#TODO protect quotes contents
    1304. 

  1304. 		return string.split(cmd_string)
    1305. 

  1305. 	
    1306. 

  1306. 	def parse(self, cmdline=[]):
    1307. 

  1307. 		"Check/Parse a command line list     TIP: no program name!"
    1308. 

  1308. 		# get the valid options
    1309. 

  1309. 		short, long = self.short_opts, self.long_opts
    1310. 

  1310. 		# parse it!
    1311. 

  1311. 		try:
    1312. 

  1312. 			opts, args = getopt.getopt(cmdline, short, long)
    1313. 

  1313. 		except getopt.error, errmsg:
    1314. 

  1314. 			Error(_("%s (try --help)")%errmsg)
    1315. 

  1315. 		return (opts, args)
    1316. 

  1316. 	
    1317. 

  1317. 	def get_raw_config(self, cmdline=[], ignore=[], filter=[]):
    1318. 

  1318. 		"Returns the options/arguments found as RAW config"
    1319. 

  1319. 		if not cmdline: return []
    1320. 

  1320. 		ret = []
    1321. 

  1321. 		# we need lists, not strings
    1322. 

  1322. 		if type(cmdline) == type(''): cmdline = self._tokenize(cmdline)
    1323. 

  1323. 		Debug("cmdline: %s"%cmdline)
    1324. 

  1324. 		opts, args = self.parse(cmdline[:])
    1325. 

  1325. 		# get infile, if any
    1326. 

  1326. 		while args:
    1327. 

  1327. 			infile = args.pop(0)
    1328. 

  1328. 			ret.append(['infile', infile])
    1329. 

  1329. 		# parse all options
    1330. 

  1330. 		for name,value in opts:
    1331. 

  1331. 			# remove leading - and --
    1332. 

  1332. 			name = re.sub('^--?', '', name)
    1333. 

  1333. 			# translate short opt to long
    1334. 

  1334. 			if len(name) == 1: name = self.short_long.get(name)
    1335. 

  1335. 			# save it (if allowed)
    1336. 

  1336. 			ret.append([name, value])
    1337. 

  1337. 		# apply 'ignore' and 'filter' rules (filter is stronger)
    1338. 

  1338. 		temp = ret[:] ; ret = []
    1339. 

  1339. 		for name,value in temp:
    1340. 

  1340. 			if (not filter and not ignore) or \
    1341. 

  1341. 			   (filter and name in filter) or \
    1342. 

  1342. 			   (ignore and name not in ignore):
    1343. 

  1343. 				ret.append( ['all', name, value] )
    1344. 

  1344. 		# add the original command line string as 'realcmdline'
    1345. 

  1345. 		ret.append( ['all', 'realcmdline', cmdline] )
    1346. 

  1346. 		return ret
    1347. 

  1347. 	
    1348. 

  1348. 	def compose_cmdline(self, conf={}, no_check=0):
    1349. 

  1349. 		"compose a full (and diet) command line from CONF dict"
    1350. 

  1350. 		if not conf: return []
    1351. 

  1351. 		args = []
    1352. 

  1352. 		dft_options = OPTIONS.copy()
    1353. 

  1353. 		cfg = conf.copy()
    1354. 

  1354. 		valid_opts = self.all_options + self.all_flags
    1355. 

  1355. 		use_short = {'no-headers':'H', 'enum-title':'n'}
    1356. 

  1356. 		# remove useless options
    1357. 

  1357. 		if not no_check and cfg.get('toc-only'):
    1358. 

  1358. 			if cfg.has_key('no-headers'):
    1359. 

  1359. 				del cfg['no-headers']
    1360. 

  1360. 			if cfg.has_key('outfile'):
    1361. 

  1361. 				del cfg['outfile']      # defaults to STDOUT
    1362. 

  1362. 			if cfg.get('target') == 'txt':
    1363. 

  1363. 				del cfg['target']       # already default
    1364. 

  1364. 			args.append('--toc-only')  # must be the first
    1365. 

  1365. 			del cfg['toc-only']
    1366. 

  1366. 		# add target type
    1367. 

  1367. 		if cfg.has_key('target'):
    1368. 

  1368. 			args.append('-t '+cfg['target'])
    1369. 

  1369. 			del cfg['target']
    1370. 

  1370. 		# add other options
    1371. 

  1371. 		for key in cfg.keys():
    1372. 

  1372. 			if key not in valid_opts: continue  # may be a %!setting
    1373. 

  1373. 			if key in ['outfile','infile']: continue   # later
    1374. 

  1374. 			val = cfg[key]
    1375. 

  1375. 			if not val: continue
    1376. 

  1376. 			# default values are useless on cmdline
    1377. 

  1377. 			if val == dft_options.get(key): continue
    1378. 

  1378. 			# -short format
    1379. 

  1379. 			if key in use_short.keys():
    1380. 

  1380. 				args.append('-'+use_short[key])
    1381. 

  1381. 				continue
    1382. 

  1382. 			# --long format
    1383. 

  1383. 			if key in self.all_flags: # add --option
    1384. 

  1384. 				args.append('--'+key)
    1385. 

  1385. 			else:                     # add --option=value
    1386. 

  1386. 				args.append('--%s=%s'%(key,val))
    1387. 

  1387. 		# the outfile using -o
    1388. 

  1388. 		if cfg.has_key('outfile') and \
    1389. 

  1389. 		   cfg['outfile'] != dft_options.get('outfile'):
    1390. 

  1390. 			args.append('-o '+cfg['outfile'])
    1391. 

  1391. 		# place input file(s) always at the end
    1392. 

  1392. 		if cfg.has_key('infile'):
    1393. 

  1393. 			args.append(string.join(cfg['infile'],' '))
    1394. 

  1394. 		# return as a nice list
    1395. 

  1395. 		Debug("Diet command line: %s"%string.join(args,' '), 1)
    1396. 

  1396. 		return args
    1397. 

  1397. 

  1398. ##############################################################################
    1399. 

  1399. 

  1400. class SourceDocument:
    1401. 

  1401. 	"""
    1402. 

  1402. 	SourceDocument class - scan document structure, extract data
    1403. 

  1403. 	
    1404. 

  1404. 	It knows about full files. It reads a file and identify all
    1405. 

  1405. 	the areas begining (Head,Conf,Body). With this info it can
    1406. 

  1406. 	extract each area contents.
    1407. 

  1407. 	Note: the original line break is removed.
    1408. 

  1408. 	
    1409. 

  1409. 	DATA:
    1410. 

  1410. 	  self.arearef - Save Head, Conf, Body init line number
    1411. 

  1411. 	  self.areas   - Store the area names which are not empty
    1412. 

  1412. 	  self.buffer  - The full file contents (with NO \\r, \\n)
    1413. 

  1413. 

  1414. 	METHODS:
    1415. 

  1415. 	  get()   - Access the contents of an Area. Example:
    1416. 

  1416. 	            config = SourceDocument(file).get('conf')
    1417. 

  1417. 	
    1418. 

  1418. 	  split() - Get all the document Areas at once. Example:
    1419. 

  1419. 	            head, conf, body = SourceDocument(file).split()
    1420. 

  1420. 	
    1421. 

  1421. 	RULES:
    1422. 

  1422. 	    * The document parts are sequential: Head, Conf and Body.
    1423. 

  1423. 	    * One ends when the next begins.
    1424. 

  1424. 	    * The Conf Area is optional, so a document can have just
    1425. 

  1425. 	      Head and Body Areas.
    1426. 

  1426. 	
    1427. 

  1427. 	    These are the Areas limits:
    1428. 

  1428. 	      - Head Area: the first three lines
    1429. 

  1429. 	      - Body Area: from the first valid text line to the end
    1430. 

  1430. 	      - Conf Area: the comments between Head and Body Areas
    1431. 

  1431. 

  1432. 	    Exception: If the first line is blank, this means no
    1433. 

  1433. 	    header info, so the Head Area is just the first line.
    1434. 

  1434. 	"""
    1435. 

  1435. 	def __init__(self, filename=''):
    1436. 

  1436. 		self.areas = ['head','conf','body']
    1437. 

  1437. 		self.arearef = []
    1438. 

  1438. 		self.areas_fancy = ''
    1439. 

  1439. 		self.filename = filename
    1440. 

  1440. 		self.buffer = []
    1441. 

  1441. 		if filename: self.scan(filename)
    1442. 

  1442. 	
    1443. 

  1443. 	def split(self):
    1444. 

  1444. 		"Returns all document parts, splitted into lists."
    1445. 

  1445. 		return self.get('head'), self.get('conf'), self.get('body')
    1446. 

  1446. 	
    1447. 

  1447. 	def get(self, areaname):
    1448. 

  1448. 		"Returns head|conf|body contents from self.buffer"
    1449. 

  1449. 		# sanity
    1450. 

  1450. 		if areaname not in self.areas: return []
    1451. 

  1451. 		if not self.buffer           : return []
    1452. 

  1452. 		# go get it
    1453. 

  1453. 		bufini = 1
    1454. 

  1454. 		bufend = len(self.buffer)
    1455. 

  1455. 		if   areaname == 'head':
    1456. 

  1456. 			ini = bufini
    1457. 

  1457. 			end = self.arearef[1] or self.arearef[2] or bufend
    1458. 

  1458. 		elif areaname == 'conf':
    1459. 

  1459. 			ini = self.arearef[1]
    1460. 

  1460. 			end = self.arearef[2] or bufend
    1461. 

  1461. 		elif areaname == 'body':
    1462. 

  1462. 			ini = self.arearef[2]
    1463. 

  1463. 			end = bufend
    1464. 

  1464. 		else:
    1465. 

  1465. 			Error("Unknown Area name '%s'"%areaname)
    1466. 

  1466. 		lines = self.buffer[ini:end]
    1467. 

  1467. 		# make sure head will always have 3 lines
    1468. 

  1468. 		while areaname == 'head' and len(lines) < 3:
    1469. 

  1469. 			lines.append('')
    1470. 

  1470. 		return lines
    1471. 

  1471. 	
    1472. 

  1472. 	def scan(self, filename):
    1473. 

  1473. 		"Run through source file and identify head/conf/body areas"
    1474. 

  1474. 		Debug("source file: %s"%filename)
    1475. 

  1475. 		Message(_("Loading source document"),1)
    1476. 

  1476. 		buf = Readfile(filename, remove_linebreaks=1)
    1477. 

  1477. 		cfg_parser = ConfigLines().parse_line
    1478. 

  1478. 		buf.insert(0, '')                         # text start at pos 1
    1479. 

  1479. 		ref = [1,4,0]
    1480. 

  1480. 		if not string.strip(buf[1]):              # no header
    1481. 

  1481. 			ref[0] = 0 ; ref[1] = 2
    1482. 

  1482. 		for i in range(ref[1],len(buf)):          # find body init:
    1483. 

  1483. 			if string.strip(buf[i]) and (     # ... not blank and
    1484. 

  1484. 			   buf[i][0] != '%' or            # ... not comment or
    1485. 

  1485. 			   cfg_parser(buf[i],'include')[1]): # ... %!include
    1486. 

  1486. 				ref[2] = i ; break
    1487. 

  1487. 		if ref[1] == ref[2]: ref[1] = 0           # no conf area
    1488. 

  1488. 		for i in 0,1,2:                           # del !existent
    1489. 

  1489. 			if ref[i] >= len(buf): ref[i] = 0 # title-only
    1490. 

  1490. 			if not ref[i]: self.areas[i] = ''
    1491. 

  1491. 		Debug('Head,Conf,Body start line: %s'%ref)
    1492. 

  1492. 		self.arearef = ref                        # save results
    1493. 

  1493. 		self.buffer  = buf
    1494. 

  1494. 		# fancyness sample: head conf body (1 4 8)
    1495. 

  1495. 		self.areas_fancy = "%s (%s)"%(
    1496. 

  1496. 		     string.join(self.areas),
    1497. 

  1497. 		     string.join(map(str, map(lambda x:x or '', ref))))
    1498. 

  1498. 		Message(_("Areas found: %s")%self.areas_fancy, 2)
    1499. 

  1499. 	
    1500. 

  1500. 	def get_raw_config(self):
    1501. 

  1501. 		"Handy method to get the CONF area RAW config (if any)"
    1502. 

  1502. 		if not self.areas.count('conf'): return []
    1503. 

  1503. 		Message(_("Scanning source document CONF area"),1)
    1504. 

  1504. 		raw = ConfigLines(
    1505. 

  1505. 		      file=self.filename, lines=self.get('conf'),
    1506. 

  1506. 		      first_line=self.arearef[1]).get_raw_config()
    1507. 

  1507. 		Debug("document raw config: %s"%raw, 1)
    1508. 

  1508. 		return raw
    1509. 

  1509. 

  1510. ##############################################################################
    1511. 

  1511. 

  1512. class ConfigMaster:
    1513. 

  1513. 	"""ConfigMaster class - the configuration wizard
    1514. 

  1514. 	
    1515. 

  1515. 	This class is the configuration master. It knows how to handle
    1516. 

  1516. 	the RAW and PARSED config format. It also performs the sanity
    1517. 

  1517. 	checkings for a given configuration.
    1518. 

  1518. 	
    1519. 

  1519. 	DATA:
    1520. 

  1520. 	  self.raw         - Stores the config on the RAW format
    1521. 

  1521. 	  self.parsed      - Stores the config on the PARSED format
    1522. 

  1522. 	  self.defaults    - Stores the default values for all keys
    1523. 

  1523. 	  self.off         - Stores the OFF values for all keys
    1524. 

  1524. 	  self.multi       - List of keys which can have multiple values
    1525. 

  1525. 	  self.numeric     - List of keys which value must be a number
    1526. 

  1526. 	  self.incremental - List of keys which are incremental
    1527. 

  1527. 	
    1528. 

  1528.         RAW FORMAT:
    1529. 

  1529. 	  The RAW format is a list of lists, being each mother list item
    1530. 

  1530. 	  a full configuration entry. Any entry is a 3 item list, on
    1531. 

  1531. 	  the following format: [ TARGET, KEY, VALUE ]
    1532. 

  1532. 	  Being a list, the order is preserved, so it's easy to use
    1533. 

  1533. 	  different kinds of configs, as CONF area and command line,
    1534. 

  1534. 	  respecting the precedence.
    1535. 

  1535. 	  The special target 'all' is used when no specific target was
    1536. 

  1536. 	  defined on the original config.
    1537. 

  1537. 	
    1538. 

  1538. 	PARSED FORMAT:
    1539. 

  1539. 	  The PARSED format is a dictionary, with all the 'key : value'
    1540. 

  1540. 	  found by reading the RAW config. The self.target contents
    1541. 

  1541. 	  matters, so this dictionary only contains the target's
    1542. 

  1542. 	  config. The configs of other targets are ignored.
    1543. 

  1543. 	
    1544. 

  1544. 	The CommandLine and ConfigLines classes have the get_raw_config()
    1545. 

  1545. 	method which convert the configuration found to the RAW format.
    1546. 

  1546. 	Just feed it to parse() and get a brand-new ready-to-use config
    1547. 

  1547. 	dictionary. Example:
    1548. 

  1548. 	
    1549. 

  1549. 	    >>> raw = CommandLine().get_raw_config(['-n', '-H'])
    1550. 

  1550. 	    >>> print raw
    1551. 

  1551. 	    [['all', 'enum-title', ''], ['all', 'no-headers', '']]
    1552. 

  1552. 	    >>> parsed = ConfigMaster(raw).parse()
    1553. 

  1553. 	    >>> print parsed
    1554. 

  1554. 	    {'enum-title': 1, 'headers': 0}
    1555. 

  1555. 	"""
    1556. 

  1556. 	def __init__(self, raw=[], target=''):
    1557. 

  1557. 		self.raw          = raw
    1558. 

  1558. 		self.target       = target
    1559. 

  1559. 		self.parsed       = {}
    1560. 

  1560. 		self.dft_options  = OPTIONS.copy()
    1561. 

  1561. 		self.dft_flags    = FLAGS.copy()
    1562. 

  1562. 		self.dft_actions  = ACTIONS.copy()
    1563. 

  1563. 		self.dft_settings = SETTINGS.copy()
    1564. 

  1564. 		self.defaults     = self._get_defaults()
    1565. 

  1565. 		self.off          = self._get_off()
    1566. 

  1566. 		self.multi        = ['infile', 'options','preproc','postproc']
    1567. 

  1567. 		self.incremental  = ['verbose']
    1568. 

  1568. 		self.numeric      = ['toc-level','split']
    1569. 

  1569. 	
    1570. 

  1570. 	def _get_defaults(self):
    1571. 

  1571. 		"Get the default values for all config/options/flags"
    1572. 

  1572. 		empty = {}
    1573. 

  1573. 		for kw in CONFIG_KEYWORDS: empty[kw] = ''
    1574. 

  1574. 		empty.update(self.dft_options)
    1575. 

  1575. 		empty.update(self.dft_flags)
    1576. 

  1576. 		empty.update(self.dft_actions)
    1577. 

  1577. 		empty.update(self.dft_settings)
    1578. 

  1578. 		empty['realcmdline'] = ''  # internal use only
    1579. 

  1579. 		empty['sourcefile']  = ''  # internal use only
    1580. 

  1580. 		return empty
    1581. 

  1581. 	
    1582. 

  1582. 	def _get_off(self):
    1583. 

  1583. 		"Turns OFF all the config/options/flags"
    1584. 

  1584. 		off = {}
    1585. 

  1585. 		for key in self.defaults.keys():
    1586. 

  1586. 			kind = type(self.defaults[key])
    1587. 

  1587. 			if kind == type(9):
    1588. 

  1588. 				off[key] = 0
    1589. 

  1589. 			elif kind == type(''):
    1590. 

  1590. 				off[key] = ''
    1591. 

  1591. 			elif kind == type([]):
    1592. 

  1592. 				off[key] = []
    1593. 

  1593. 			else:
    1594. 

  1594. 				Error('ConfigMaster: %s: Unknown type'+key)
    1595. 

  1595. 		return off
    1596. 

  1596. 	
    1597. 

  1597. 	def _check_target(self):
    1598. 

  1598. 		"Checks if the target is already defined. If not, do it"
    1599. 

  1599. 		if not self.target:
    1600. 

  1600. 			self.target = self.find_value('target')
    1601. 

  1601. 	
    1602. 

  1602. 	def get_target_raw(self):
    1603. 

  1603. 		"Returns the raw config for self.target or 'all'"
    1604. 

  1604. 		ret = []
    1605. 

  1605. 		self._check_target()
    1606. 

  1606. 		for entry in self.raw:
    1607. 

  1607. 			if entry[0] in [self.target, 'all']:
    1608. 

  1608. 				ret.append(entry)
    1609. 

  1609. 		return ret
    1610. 

  1610. 	
    1611. 

  1611. 	def add(self, key, val):
    1612. 

  1612. 		"Adds the key:value pair to the config dictionary (if needed)"
    1613. 

  1613. 		# %!options
    1614. 

  1614. 		if key == 'options':
    1615. 

  1615. 			ignoreme = self.dft_actions.keys() + ['target']
    1616. 

  1616. 			raw_opts = CommandLine().get_raw_config(
    1617. 

  1617. 			             val, ignore=ignoreme)
    1618. 

  1618. 			for target, key, val in raw_opts:
    1619. 

  1619. 				self.add(key, val)
    1620. 

  1620. 			return
    1621. 

  1621. 		# the no- prefix turns OFF this key
    1622. 

  1622. 		if key[:3] == 'no-':
    1623. 

  1623. 			key = key[3:]              # remove prefix
    1624. 

  1624. 			val = self.off.get(key)    # turn key OFF
    1625. 

  1625. 		# is this key valid?
    1626. 

  1626. 		if key not in self.defaults.keys():
    1627. 

  1627. 			Debug('Bogus Config %s:%s'%(key,val),1)
    1628. 

  1628. 			return
    1629. 

  1629. 		# is this value the default one?
    1630. 

  1630. 		if val == self.defaults.get(key):
    1631. 

  1631. 			# if default value, remove previous key:val
    1632. 

  1632. 			if self.parsed.has_key(key):
    1633. 

  1633. 				del self.parsed[key]
    1634. 

  1634. 			# nothing more to do
    1635. 

  1635. 			return
    1636. 

  1636. 		# flags ON comes empty. we'll add the 1 value now
    1637. 

  1637. 		if val == '' and \
    1638. 

  1638. 		   key in self.dft_flags.keys()+self.dft_actions.keys():
    1639. 

  1639. 			val = 1
    1640. 

  1640. 		# multi value or single?
    1641. 

  1641. 		if key in self.multi:
    1642. 

  1642. 			# first one? start new list
    1643. 

  1643. 			if not self.parsed.has_key(key):
    1644. 

  1644. 				self.parsed[key] = []
    1645. 

  1645. 			self.parsed[key].append(val)
    1646. 

  1646. 		# incremental value? so let's add it
    1647. 

  1647. 		elif key in self.incremental:
    1648. 

  1648. 			self.parsed[key] = (self.parsed.get(key) or 0) + val
    1649. 

  1649. 		else:
    1650. 

  1650. 			self.parsed[key] = val
    1651. 

  1651. 		fancykey = dotted_spaces("%12s"%key)
    1652. 

  1652. 		Message(_("Added config %s : %s")%(fancykey,val),3)
    1653. 

  1653. 	
    1654. 

  1654. 	def get_outfile_name(self, config={}):
    1655. 

  1655. 		"Dirname is the same for {in,out}file"
    1656. 

  1656. 		infile, outfile = config['sourcefile'], config['outfile']
    1657. 

  1657. 		if infile == STDIN and not outfile: outfile = STDOUT
    1658. 

  1658. 		if not outfile and (infile and config.get('target')):
    1659. 

  1659. 			basename = re.sub('\.(txt|t2t)$','',infile)
    1660. 

  1660. 			outfile = "%s.%s"%(basename, config['target'])
    1661. 

  1661. 		Debug(" infile: '%s'"%infile , 1)
    1662. 

  1662. 		Debug("outfile: '%s'"%outfile, 1)
    1663. 

  1663. 		return outfile
    1664. 

  1664. 	
    1665. 

  1665. 	def sanity(self, config, gui=0):
    1666. 

  1666. 		"Basic config sanity checkings"
    1667. 

  1667. 		if not config: return {}
    1668. 

  1668. 		target = config.get('target')
    1669. 

  1669. 		# --toc-only doesn't require target specification
    1670. 

  1670. 		if not target and config.get('toc-only'):
    1671. 

  1671. 			target = 'txt'
    1672. 

  1672. 		# on GUI, some checkings are skipped
    1673. 

  1673. 		if not gui:
    1674. 

  1674. 			# we *need* a target
    1675. 

  1675. 			if not target:
    1676. 

  1676. 				Error(_('No target specified (try --help)')+\
    1677. 

  1677. 				'\n\n'+\
    1678. 

  1678. 				_('Maybe trying to convert an old v1.x file?'))
    1679. 

  1679. 			# and of course, an infile also
    1680. 

  1680. 			if not config['infile']:
    1681. 

  1681. 				Error(_('Missing input file (try --help)'))
    1682. 

  1682. 			# is the target valid?
    1683. 

  1683. 			if not TARGETS.count(target):
    1684. 

  1684. 				Error(_("Invalid target '%s' (try --help)"
    1685. 

  1685. 				        )%target)
    1686. 

  1686. 		# ensure all keys are present
    1687. 

  1687. 		empty = self.defaults.copy() ; empty.update(config)
    1688. 

  1688. 		config = empty.copy()
    1689. 

  1689. 		# check integers options
    1690. 

  1690. 		for key in config.keys():
    1691. 

  1691. 			if key in self.numeric:
    1692. 

  1692. 				try: config[key] = int(config[key])
    1693. 

  1693. 				except: Error(_('--%s value must be a number'
    1694. 

  1694. 				                )%key)
    1695. 

  1695. 		# check split level value
    1696. 

  1696. 		if config['split'] not in [0,1,2]:
    1697. 

  1697. 			Error(_('Option --split must be 0, 1 or 2'))
    1698. 

  1698. 		# --toc-only is stronger than others
    1699. 

  1699. 		if config['toc-only']:
    1700. 

  1700. 			config['headers'] = 0
    1701. 

  1701. 			config['toc']     = 0
    1702. 

  1702. 			config['split']   = 0
    1703. 

  1703. 			config['gui']     = 0
    1704. 

  1704. 			config['outfile'] = STDOUT
    1705. 

  1705. 		# splitting is disable for now (future: HTML only, no STDOUT)
    1706. 

  1706. 		config['split'] = 0
    1707. 

  1707. 		# restore target
    1708. 

  1708. 		config['target'] = target
    1709. 

  1709. 		# set output file name
    1710. 

  1710. 		config['outfile'] = self.get_outfile_name(config)
    1711. 

  1711. 		# checking suicide
    1712. 

  1712. 		if config['sourcefile'] == config['outfile'] and \
    1713. 

  1713. 		   config['outfile'] != STDOUT and not gui:
    1714. 

  1714. 			Error(_("Input and Output files are the same: %s")%(
    1715. 

  1715. 			config['outfile']))
    1716. 

  1716. 		return config
    1717. 

  1717. 	
    1718. 

  1718. 	def parse(self):
    1719. 

  1719. 		"Returns the parsed config for the current target"
    1720. 

  1720. 		raw = self.get_target_raw()
    1721. 

  1721. 		for target, key, value in raw:
    1722. 

  1722. 			self.add(key, value)
    1723. 

  1723. 		Message(_("Added the following keys: %s")%string.join(
    1724. 

  1724. 		         self.parsed.keys(),', '),2)
    1725. 

  1725. 		return self.parsed.copy()
    1726. 

  1726. 	
    1727. 

  1727. 	def find_value(self, key='', target=''):
    1728. 

  1728. 		"Scans ALL raw config to find the desired key"
    1729. 

  1729. 		ret = []
    1730. 

  1730. 		# scan and save all values found
    1731. 

  1731. 		for targ, k, val in self.raw:
    1732. 

  1732. 			if targ in [target, 'all'] and k == key:
    1733. 

  1733. 				ret.append(val)
    1734. 

  1734. 		if not ret: return ''
    1735. 

  1735. 		# if not multi value, return only the last found
    1736. 

  1736. 		if key in self.multi: return ret
    1737. 

  1737. 		else                : return ret[-1]
    1738. 

  1738. 

  1739. ########################################################################
    1740. 

  1740. 

  1741. class ConfigLines:
    1742. 

  1742. 	"""ConfigLines class - the config file data extractor
    1743. 

  1743. 	
    1744. 

  1744. 	This class reads and parse the config lines on the %!key:val
    1745. 

  1745. 	format, converting it to RAW config. It deals with user
    1746. 

  1746. 	config file (RC file), source document CONF area and
    1747. 

  1747. 	%!includeconf directives.
    1748. 

  1748. 

  1749. 	Call it passing a file name or feed the desired config lines.
    1750. 

  1750. 	Then just call the get_raw_config() method and wait to
    1751. 

  1751. 	receive the full config data on the RAW format. This method
    1752. 

  1752. 	also follows the possible %!includeconf directives found on
    1753. 

  1753. 	the config lines. Example:
    1754. 

  1754. 

  1755. 	    raw = ConfigLines(file=".txt2tagsrc").get_raw_config()
    1756. 

  1756. 

  1757. 	The parse_line() method is also useful to be used alone,
    1758. 

  1758. 	to identify and tokenize a single config line. For example,
    1759. 

  1759. 	to get the %!include command components, on the source
    1760. 

  1760. 	document BODY:
    1761. 

  1761. 	
    1762. 

  1762. 	    target, key, value = ConfigLines().parse_line(body_line)
    1763. 

  1763. 	"""
    1764. 

  1764. 	def __init__(self, file='', lines=[], first_line=1):
    1765. 

  1765. 		self.file = file or 'NOFILE'
    1766. 

  1766. 		self.lines = lines
    1767. 

  1767. 		self.first_line = first_line
    1768. 

  1768. 	
    1769. 

  1769. 	def load_lines(self):
    1770. 

  1770. 		"Make sure we've loaded the file contents into buffer"
    1771. 

  1771. 		if not self.lines and not self.file:
    1772. 

  1772. 			Error("ConfigLines: No file or lines provided")
    1773. 

  1773. 		if not self.lines:
    1774. 

  1774. 			self.lines = self.read_config_file(self.file)
    1775. 

  1775. 	
    1776. 

  1776. 	def read_config_file(self, filename=''):
    1777. 

  1777. 		"Read a Config File contents, aborting on invalid line"
    1778. 

  1778. 		if not filename: return []
    1779. 

  1779. 		errormsg = _("Invalid CONFIG line on %s")+"\n%03d:%s"
    1780. 

  1780. 		lines = Readfile(filename, remove_linebreaks=1)
    1781. 

  1781. 		# sanity: try to find invalid config lines
    1782. 

  1782. 		for i in range(len(lines)):
    1783. 

  1783. 			line = string.rstrip(lines[i])
    1784. 

  1784. 			if not line: continue  # empty
    1785. 

  1785. 			if line[0] != '%': Error(errormsg%(filename,i+1,line))
    1786. 

  1786. 		return lines
    1787. 

  1787. 	
    1788. 

  1788. 	def include_config_file(self, file=''):
    1789. 

  1789. 		"Perform the %!includeconf action, returning RAW config"
    1790. 

  1790. 		if not file: return []
    1791. 

  1791. 		# current dir relative to the current file (self.file)
    1792. 

  1792. 		current_dir = os.path.dirname(self.file)
    1793. 

  1793. 		file = os.path.join(current_dir, file)
    1794. 

  1794. 		# read and parse included config file contents
    1795. 

  1795. 		lines = self.read_config_file(file)
    1796. 

  1796. 		return ConfigLines(file=file, lines=lines).get_raw_config()
    1797. 

  1797. 	
    1798. 

  1798. 	def get_raw_config(self):
    1799. 

  1799. 		"Scan buffer and extract all config as RAW (including includes)"
    1800. 

  1800. 		ret = []
    1801. 

  1801. 		self.load_lines()
    1802. 

  1802. 		first = self.first_line
    1803. 

  1803. 		for i in range(len(self.lines)):
    1804. 

  1804. 			line = self.lines[i]
    1805. 

  1805. 			Message(_("Processing line %03d: %s")%(first+i,line),2)
    1806. 

  1806. 			target, key, val = self.parse_line(line)
    1807. 

  1807. 			if not key: continue    # no config on this line
    1808. 

  1808. 			if key == 'includeconf':
    1809. 

  1809. 				more_raw = self.include_config_file(val)
    1810. 

  1810. 				ret.extend(more_raw)
    1811. 

  1811. 				Message(_("Finished Config file inclusion: %s"
    1812. 

  1812. 				          )%(val),2)
    1813. 

  1813. 			else:
    1814. 

  1814. 				ret.append([target, key, val])
    1815. 

  1815. 				Message(_("Added %s")%key,3)
    1816. 

  1816. 		return ret
    1817. 

  1817. 	
    1818. 

  1818. 	def parse_line(self, line='', keyname='', target=''):
    1819. 

  1819. 		"Detects %!key:val config lines and extract data from it"
    1820. 

  1820. 		empty = ['', '', '']
    1821. 

  1821. 		if not line: return empty
    1822. 

  1822. 		no_target = ['target', 'includeconf']
    1823. 

  1823. 		re_name   = keyname or '[a-z]+'
    1824. 

  1824. 		re_target = target  or '[a-z]*'
    1825. 

  1825. 		cfgregex  = re.compile("""
    1826. 

  1826. 		  ^%%!\s*               # leading id with opt spaces
    1827. 

  1827. 		  (?P<name>%s)\s*       # config name
    1828. 

  1828. 		  (\((?P<target>%s)\))? # optional target spec inside ()
    1829. 

  1829. 		  \s*:\s*               # key:value delimiter with opt spaces
    1830. 

  1830. 		  (?P<value>\S.+?)      # config value
    1831. 

  1831. 		  \s*$                  # rstrip() spaces and hit EOL
    1832. 

  1832. 		  """%(re_name,re_target), re.I+re.VERBOSE)
    1833. 

  1833. 		prepostregex = re.compile("""
    1834. 

  1834. 		                        # ---[ PATTERN ]---
    1835. 

  1835. 		  ^( "([^"]*)"          # "double quoted" or
    1836. 

  1836. 		   | '([^']*)'          # 'single quoted' or
    1837. 

  1837. 		   | ([^\s]+)           # single_word
    1838. 

  1838. 		   )
    1839. 

  1839. 		    \s+                 # separated by spaces
    1840. 

  1840. 		
    1841. 

  1841. 		                        # ---[ REPLACE ]---
    1842. 

  1842. 		       ( "([^"]*)"      # "double quoted" or
    1843. 

  1843. 		       | '([^']*)'      # 'single quoted' or
    1844. 

  1844. 		       | (.*)           # anything
    1845. 

  1845. 		           )
    1846. 

  1846. 		            \s*$
    1847. 

  1847. 		  """, re.VERBOSE)
    1848. 

  1848. 		guicolors = re.compile("^([^\s]+\s+){3}[^\s]+") # 4 tokens
    1849. 

  1849. 		match = cfgregex.match(line)
    1850. 

  1850. 		if not match: return empty
    1851. 

  1851. 		
    1852. 

  1852. 		name   = string.lower(match.group('name') or '')
    1853. 

  1853. 		target = string.lower(match.group('target') or 'all')
    1854. 

  1854. 		value  = match.group('value')
    1855. 

  1855. 		
    1856. 

  1856. 		# NO target keywords: force all targets
    1857. 

  1857. 		if name in no_target: target = 'all'
    1858. 

  1858. 		
    1859. 

  1859. 		# special config for GUI colors
    1860. 

  1860. 		if name == 'guicolors':
    1861. 

  1861. 			valmatch = guicolors.search(value)
    1862. 

  1862. 			if not valmatch: return empty
    1863. 

  1863. 			value = re.split('\s+', value)
    1864. 

  1864. 		
    1865. 

  1865. 		# Special config with two quoted values (%!preproc: "foo" 'bar')
    1866. 

  1866. 		if name in ['preproc','postproc']:
    1867. 

  1867. 			valmatch = prepostregex.search(value)
    1868. 

  1868. 			if not valmatch: return empty
    1869. 

  1869. 			getval = valmatch.group
    1870. 

  1870. 			patt   = getval(2) or getval(3) or getval(4) or ''
    1871. 

  1871. 			repl   = getval(6) or getval(7) or getval(8) or ''
    1872. 

  1872. 			value  = (patt, repl)
    1873. 

  1873. 		return [target, name, value]
    1874. 

  1874. 

  1875. ##############################################################################
    1876. 

  1876. 

  1877. class MaskMaster:
    1878. 

  1878. 	"(Un)Protect important structures from escaping and formatting"
    1879. 

  1879. 	def __init__(self):
    1880. 

  1880. 		self.linkmask  = '@@_link_@@'
    1881. 

  1881. 		self.monomask  = '@@_mono_@@'
    1882. 

  1882. 		self.macromask = '@@_macro_@@'
    1883. 

  1883. 		self.rawmask   = '@@_raw_@@'
    1884. 

  1884. 		self.reset()
    1885. 

  1885. 	
    1886. 

  1886. 	def reset(self):
    1887. 

  1887. 		self.linkbank = []
    1888. 

  1888. 		self.monobank = []
    1889. 

  1889. 		self.macrobank = []
    1890. 

  1890. 		self.rawbank = []
    1891. 

  1891. 	
    1892. 

  1892. 	def mask(self, line=''):
    1893. 

  1893. 		
    1894. 

  1894. 		# protect raw text
    1895. 

  1895. 		while regex['raw'].search(line):
    1896. 

  1896. 			txt = regex['raw'].search(line).group(1)
    1897. 

  1897. 			txt = doEscape(TARGET,txt)
    1898. 

  1898. 			self.rawbank.append(txt)
    1899. 

  1899. 			line = regex['raw'].sub(self.rawmask,line,1)
    1900. 

  1900. 		
    1901. 

  1901. 		# protect pre-formatted font text
    1902. 

  1902. 		while regex['fontMono'].search(line):
    1903. 

  1903. 			txt = regex['fontMono'].search(line).group(1)
    1904. 

  1904. 			txt = doEscape(TARGET,txt)
    1905. 

  1905. 			self.monobank.append(txt)
    1906. 

  1906. 			line = regex['fontMono'].sub(self.monomask,line,1)
    1907. 

  1907. 		
    1908. 

  1908. 		# protect macros
    1909. 

  1909. 		while regex['macro'].search(line):
    1910. 

  1910. 			txt = regex['macro'].search(line).group()
    1911. 

  1911. 			self.macrobank.append(txt)
    1912. 

  1912. 			line = regex['macro'].sub(self.macromask,line,1)
    1913. 

  1913. 		
    1914. 

  1914. 		# protect URLs and emails
    1915. 

  1915. 		while regex['linkmark'].search(line) or \
    1916. 

  1916. 		      regex['link'    ].search(line):
    1917. 

  1917. 			
    1918. 

  1918. 			# try to match plain or named links
    1919. 

  1919. 			match_link  = regex['link'].search(line)
    1920. 

  1920. 			match_named = regex['linkmark'].search(line)
    1921. 

  1921. 			
    1922. 

  1922. 			# define the current match
    1923. 

  1923. 			if match_link and match_named:
    1924. 

  1924. 				# both types found, which is the first?
    1925. 

  1925. 				m = match_link
    1926. 

  1926. 				if match_named.start() < match_link.start():
    1927. 

  1927. 					m = match_named
    1928. 

  1928. 			else:
    1929. 

  1929. 				# just one type found, we're fine
    1930. 

  1930. 				m = match_link or match_named
    1931. 

  1931. 			
    1932. 

  1932. 			# extract link data and apply mask
    1933. 

  1933. 			if m == match_link:              # plain link
    1934. 

  1934. 				link = m.group()
    1935. 

  1935. 				label = ''
    1936. 

  1936. 				link_re = regex['link']
    1937. 

  1937. 			else:                            # named link
    1938. 

  1938. 				link = m.group('link')
    1939. 

  1939. 				label = string.rstrip(m.group('label'))
    1940. 

  1940. 				link_re = regex['linkmark']
    1941. 

  1941. 			line = link_re.sub(self.linkmask,line,1)
    1942. 

  1942. 			
    1943. 

  1943. 			# save link data to the link bank
    1944. 

  1944. 			self.linkbank.append((label, link))
    1945. 

  1945. 		return line
    1946. 

  1946. 	
    1947. 

  1947. 	def undo(self, line):
    1948. 

  1948. 		
    1949. 

  1949. 		# url & email
    1950. 

  1950. 		for label,url in self.linkbank:
    1951. 

  1951. 			link = get_tagged_link(label, url)
    1952. 

  1952. 			line = string.replace(line, self.linkmask, link, 1)
    1953. 

  1953. 		
    1954. 

  1954. 		# expand macros
    1955. 

  1955. 		for macro in self.macrobank:
    1956. 

  1956. 			line = string.replace(line, self.macromask, macro,1)
    1957. 

  1957. 		if self.macrobank:
    1958. 

  1958. 			line = doDateMacro(line)
    1959. 

  1959. 		
    1960. 

  1960. 		# expand verb
    1961. 

  1961. 		for mono in self.monobank:
    1962. 

  1962. 			open,close = TAGS['fontMonoOpen'],TAGS['fontMonoClose']
    1963. 

  1963. 			tagged = open+mono+close
    1964. 

  1964. 			line = string.replace(line,self.monomask,tagged,1)
    1965. 

  1965. 		
    1966. 

  1966. 		# expand raw
    1967. 

  1967. 		for raw in self.rawbank:
    1968. 

  1968. 			line = string.replace(line,self.rawmask,raw,1)
    1969. 

  1969. 		
    1970. 

  1970. 		return line
    1971. 

  1971. 

  1972. 

  1973. ##############################################################################
    1974. 

  1974. 

  1975. 

  1976. class TitleMaster:
    1977. 

  1977. 	"Title things"
    1978. 

  1978. 	def __init__(self):
    1979. 

  1979. 		self.count = ['',0,0,0,0,0]
    1980. 

  1980. 		self.toc   = []
    1981. 

  1981. 		self.level = 0
    1982. 

  1982. 		self.kind  = ''
    1983. 

  1983. 		self.txt   = ''
    1984. 

  1984. 		self.label = ''
    1985. 

  1985. 		self.tag   = ''
    1986. 

  1986. 		self.count_id = ''
    1987. 

  1987. 		self.user_labels = {}
    1988. 

  1988. 		self.anchor_count = 0
    1989. 

  1989. 		self.anchor_prefix = 'toc'
    1990. 

  1990. 	
    1991. 

  1991. 	def add(self, line):
    1992. 

  1992. 		"Parses a new title line."
    1993. 

  1993. 		if not line: return
    1994. 

  1994. 		self._set_prop(line)
    1995. 

  1995. 		self._set_count_id()
    1996. 

  1996. 		self._set_label()
    1997. 

  1997. 		self._save_toc_info()
    1998. 

  1998. 	
    1999. 

  1999. 	def _save_toc_info(self):
    2000. 

  2000. 		"Save TOC info, used by self.dump_marked_toc()"
    2001. 

  2001. 		self.toc.append((self.level, self.count_id,
    2002. 

  2002. 		                 self.txt  , self.label   ))
    2003. 

  2003. 	
    2004. 

  2004. 	def _set_prop(self, line=''):
    2005. 

  2005. 		"Extract info from original line and set data holders."
    2006. 

  2006. 		# detect title type (numbered or not)
    2007. 

  2007. 		id = string.lstrip(line)[0]
    2008. 

  2008. 		if   id == '=': kind = 'title'
    2009. 

  2009. 		elif id == '+': kind = 'numtitle'
    2010. 

  2010. 		else: Error("Unknown Title ID '%s'"%id)
    2011. 

  2011. 		# extract line info
    2012. 

  2012. 		match = regex[kind].search(line)
    2013. 

  2013. 		level = len(match.group('id'))
    2014. 

  2014. 		txt   = string.strip(match.group('txt'))
    2015. 

  2015. 		label = match.group('label')
    2016. 

  2016. 		# parse info & save
    2017. 

  2017. 		if CONF['enum-title']: kind = 'numtitle'  # force
    2018. 

  2018. 		self.tag   = TAGS[kind+`level`] or TAGS['title'+`level`]
    2019. 

  2019. 		self.kind  = kind
    2020. 

  2020. 		self.level = level
    2021. 

  2021. 		self.txt   = txt
    2022. 

  2022. 		self.label = label
    2023. 

  2023. 	
    2024. 

  2024. 	def _set_count_id(self):
    2025. 

  2025. 		"Compose and save the title count identifier (if needed)."
    2026. 

  2026. 		count_id = ''
    2027. 

  2027. 		if self.kind == 'numtitle' and not rules['autonumbertitle']:
    2028. 

  2028. 			# manually increase title count
    2029. 

  2029. 			self.count[self.level] = self.count[self.level] +1
    2030. 

  2030. 			# reset sublevels count (if any)
    2031. 

  2031. 			max_levels = len(self.count)
    2032. 

  2032. 			if self.level < max_levels-1:
    2033. 

  2033. 				for i in range(self.level+1, max_levels):
    2034. 

  2034. 					self.count[i] = 0
    2035. 

  2035. 			# compose count id from hierarchy
    2036. 

  2036. 			for i in range(self.level):
    2037. 

  2037. 				count_id= "%s%d."%(count_id, self.count[i+1])
    2038. 

  2038. 		self.count_id = count_id
    2039. 

  2039. 	
    2040. 

  2040. 	def _set_label(self):
    2041. 

  2041. 		"Compose and save title label, used by anchors."
    2042. 

  2042. 		# remove invalid chars from label set by user
    2043. 

  2043. 		self.label = re.sub('[^A-Za-z0-9_]', '', self.label or '')
    2044. 

  2044. 		# generate name as 15 first :alnum: chars
    2045. 

  2045. 		#TODO how to translate safely accented chars to plain?
    2046. 

  2046. 		#self.label = re.sub('[^A-Za-z0-9]', '', self.txt)[:15]
    2047. 

  2047. 		# 'tocN' label - sequential count, ignoring 'toc-level'
    2048. 

  2048. 		#self.label = self.anchor_prefix + str(len(self.toc)+1)
    2049. 

  2049. 	
    2050. 

  2050. 	def _get_tagged_anchor(self):
    2051. 

  2051. 		"Return anchor if user defined a label, or TOC is on."
    2052. 

  2052. 		ret = ''
    2053. 

  2053. 		label = self.label
    2054. 

  2054. 		if CONF['toc'] and self.level <= CONF['toc-level']:
    2055. 

  2055. 			# this count is needed bcos self.toc stores all
    2056. 

  2056. 			# titles, regardless of the 'toc-level' setting,
    2057. 

  2057. 			# so we can't use self.toc lenght to number anchors
    2058. 

  2058. 			self.anchor_count = self.anchor_count + 1
    2059. 

  2059. 			# autonumber label (if needed)
    2060. 

  2060. 			label = label or '%s%s'%(
    2061. 

  2061. 			        self.anchor_prefix, self.anchor_count)
    2062. 

  2062. 		if label and TAGS['anchor']:
    2063. 

  2063. 			ret = regex['x'].sub(label,TAGS['anchor'])
    2064. 

  2064. 		return ret
    2065. 

  2065. 	
    2066. 

  2066. 	def _get_full_title_text(self):
    2067. 

  2067. 		"Returns the full title contents, already escaped."
    2068. 

  2068. 		ret = self.txt
    2069. 

  2069. 		# insert count_id (if any) before text
    2070. 

  2070. 		if self.count_id:
    2071. 

  2071. 			ret = '%s %s'%(self.count_id, ret)
    2072. 

  2072. 		# escape specials
    2073. 

  2073. 		ret = doEscape(TARGET, ret)
    2074. 

  2074. 		# same targets needs final escapes on title lines
    2075. 

  2075. 		# it's here because there is a 'continue' after title
    2076. 

  2076. 		if rules['finalescapetitle']:
    2077. 

  2077. 			ret = doFinalEscape(TARGET, ret)
    2078. 

  2078. 		return ret
    2079. 

  2079. 	
    2080. 

  2080. 	def get(self):
    2081. 

  2081. 		"Returns the tagged title as a list."
    2082. 

  2082. 		ret = []
    2083. 

  2083. 		
    2084. 

  2084. 		# maybe some anchoring before?
    2085. 

  2085. 		anchor = self._get_tagged_anchor()
    2086. 

  2086. 		self.tag = regex['_anchor'].sub(anchor, self.tag)
    2087. 

  2087. 		
    2088. 

  2088. 		### compose & escape title text (TOC uses unescaped)
    2089. 

  2089. 		full_title = self._get_full_title_text()
    2090. 

  2090. 		
    2091. 

  2091. 		# finish title, adding "underline" on TXT target
    2092. 

  2092. 		tagged = regex['x'].sub(full_title, self.tag)
    2093. 

  2093. 		if TARGET == 'txt':
    2094. 

  2094. 			ret.append('') # blank line before
    2095. 

  2095. 			ret.append(tagged)
    2096. 

  2096. 			ret.append(regex['x'].sub('='*len(full_title),self.tag))
    2097. 

  2097. 			ret.append('') # blank line after
    2098. 

  2098. 		else:
    2099. 

  2099. 			ret.append(tagged)
    2100. 

  2100. 		return ret
    2101. 

  2101. 	
    2102. 

  2102. 	def dump_marked_toc(self, max_level=99):
    2103. 

  2103. 		"Dumps all toc itens as a valid t2t markup list"
    2104. 

  2104. 		#TODO maybe use quote+linebreaks instead lists
    2105. 

  2105. 		ret = []
    2106. 

  2106. 		toc_count = 1
    2107. 

  2107. 		for level, count_id, txt, label in self.toc:
    2108. 

  2108. 			if level > max_level: continue   # ignore
    2109. 

  2109. 			indent = '  '*level
    2110. 

  2110. 			id_txt = string.lstrip('%s %s'%(count_id, txt))
    2111. 

  2111. 			label = label or self.anchor_prefix+`toc_count`
    2112. 

  2112. 			toc_count = toc_count + 1
    2113. 

  2113. 			# TOC will have links
    2114. 

  2114. 			if TAGS['anchor']:
    2115. 

  2115. 				# TOC is more readable with master topics
    2116. 

  2116. 				# not linked at number. This is a stoled
    2117. 

  2117. 				# idea from Windows .CHM help files
    2118. 

  2118. 				if CONF['enum-title'] and level == 1:
    2119. 

  2119. 					tocitem = '%s+ [""%s"" #%s]'%(
    2120. 

  2120. 					          indent, txt, label)
    2121. 

  2121. 				else:
    2122. 

  2122. 					tocitem = '%s- [""%s"" #%s]'%(
    2123. 

  2123. 					          indent, id_txt, label)
    2124. 

  2124. 			# no links on TOC, just text
    2125. 

  2125. 			else:
    2126. 

  2126. 				# man don't reformat TOC lines, cool!
    2127. 

  2127. 				if TARGET in ['txt', 'man']:
    2128. 

  2128. 					tocitem = '%s""%s""' %(
    2129. 

  2129. 					          indent, id_txt)
    2130. 

  2130. 				else:
    2131. 

  2131. 					tocitem = '%s- ""%s""'%(
    2132. 

  2132. 					          indent, id_txt)
    2133. 

  2133. 			ret.append(tocitem)
    2134. 

  2134. 		return ret
    2135. 

  2135. 

  2136. 

  2137. ##############################################################################
    2138. 

  2138. 

  2139. #TODO check all this table mess
    2140. 

  2140. # trata linhas TABLE, com as prop do parse_row
    2141. 

  2141. # o metodo table() do BLOCK xunxa e troca as celulas pelas parseadas
    2142. 

  2142. class TableMaster:
    2143. 

  2143. 	def __init__(self, line=''):
    2144. 

  2144. 		self.rows      = []
    2145. 

  2145. 		self.border    = 0
    2146. 

  2146. 		self.align     = 'Left'
    2147. 

  2147. 		self.cellalign = []
    2148. 

  2148. 		if line:
    2149. 

  2149. 			prop = self.parse_row(line)
    2150. 

  2150. 			self.border    = prop['border']
    2151. 

  2151. 			self.align     = prop['align']
    2152. 

  2152. 			self.cellalign = prop['cellalign']
    2153. 

  2153. 	
    2154. 

  2154. 	def _get_open_tag(self):
    2155. 

  2155. 		topen     = TAGS['tableOpen']
    2156. 

  2156. 		tborder   = TAGS['tableBorder']
    2157. 

  2157. 		talign    = TAGS['tableAlign'+self.align]
    2158. 

  2158. 		calignsep = TAGS['tableColAlignSep']
    2159. 

  2159. 		calign    = ''
    2160. 

  2160. 		
    2161. 

  2161. 		# the first line defines if table has border or not
    2162. 

  2162. 		if not self.border: tborder = ''
    2163. 

  2163. 		# set the columns alignment
    2164. 

  2164. 		if rules['tablecellaligntype'] == 'column':
    2165. 

  2165. 			calign = map(lambda x: TAGS['tableColAlign%s'%x],
    2166. 

  2166. 			             self.cellalign)
    2167. 

  2167. 			calign = string.join(calign, calignsep)
    2168. 

  2168. 		# align full table, set border and Column align (if any)
    2169. 

  2169. 		topen = regex['_tableAlign'   ].sub(talign , topen)
    2170. 

  2170. 		topen = regex['_tableBorder'  ].sub(tborder, topen)
    2171. 

  2171. 		topen = regex['_tableColAlign'].sub(calign , topen)
    2172. 

  2172. 		# tex table spec, border or not: {|l|c|r|} , {lcr}
    2173. 

  2173. 		if calignsep and not self.border:
    2174. 

  2174. 			# remove cell align separator
    2175. 

  2175. 			topen = string.replace(topen, calignsep, '')
    2176. 

  2176. 		return topen
    2177. 

  2177. 	
    2178. 

  2178. 	def _get_cell_align(self, cells):
    2179. 

  2179. 		ret = []
    2180. 

  2180. 		for cell in cells:
    2181. 

  2181. 			align = 'Left'
    2182. 

  2182. 			if string.strip(cell):
    2183. 

  2183. 				if cell[0] == ' ' and cell[-1] == ' ':
    2184. 

  2184. 					align = 'Center'
    2185. 

  2185. 				elif cell[0] == ' ':
    2186. 

  2186. 					align = 'Right'
    2187. 

  2187. 			ret.append(align)
    2188. 

  2188. 		return ret
    2189. 

  2189. 	
    2190. 

  2190. 	def _tag_cells(self, rowdata):
    2191. 

  2191. 		row = []
    2192. 

  2192. 		cells  = rowdata['cells']
    2193. 

  2193. 		open   = TAGS['tableCellOpen']
    2194. 

  2194. 		close  = TAGS['tableCellClose']
    2195. 

  2195. 		sep    = TAGS['tableCellSep']
    2196. 

  2196. 		calign = map(lambda x: TAGS['tableCellAlign'+x],
    2197. 

  2197. 		             rowdata['cellalign'])
    2198. 

  2198. 		
    2199. 

  2199. 		# maybe is it a title row?
    2200. 

  2200. 		if rowdata['title']:
    2201. 

  2201. 			open  = TAGS['tableTitleCellOpen']  or open
    2202. 

  2202. 			close = TAGS['tableTitleCellClose'] or close
    2203. 

  2203. 			sep   = TAGS['tableTitleCellSep']   or sep
    2204. 

  2204. 		
    2205. 

  2205. 		# should we break the line on *each* table cell?
    2206. 

  2206. 		if rules['breaktablecell']: close = close+'\n'
    2207. 

  2207. 		
    2208. 

  2208. 		# cells pre processing
    2209. 

  2209. 		if rules['tablecellstrip']:
    2210. 

  2210. 			cells = map(lambda x: string.strip(x), cells)
    2211. 

  2211. 		if rowdata['title'] and rules['tabletitlerowinbold']:
    2212. 

  2212. 			cells = map(lambda x: enclose_me('fontBold',x), cells)
    2213. 

  2213. 		
    2214. 

  2214. 		# add cell BEGIN/END tags
    2215. 

  2215. 		for cell in cells:
    2216. 

  2216. 			# insert cell align into open tag (if cell is alignable)
    2217. 

  2217. 			if rules['tablecellaligntype'] == 'cell':
    2218. 

  2218. 				copen = string.replace(open,'\a',calign.pop(0))
    2219. 

  2219. 			else:
    2220. 

  2220. 				copen = open
    2221. 

  2221. 			row.append(copen + cell + close)
    2222. 

  2222. 		
    2223. 

  2223. 		# maybe there are cell separators?
    2224. 

  2224. 		return string.join(row, sep)
    2225. 

  2225. 	
    2226. 

  2226. 	def add_row(self, cells):
    2227. 

  2227. 		self.rows.append(cells)
    2228. 

  2228. 	
    2229. 

  2229. 	def parse_row(self, line):
    2230. 

  2230. 		# default table proprierties
    2231. 

  2231. 		ret = {'border':0,'title':0,'align':'Left',
    2232. 

  2232. 		       'cells':[],'cellalign':[]}
    2233. 

  2233. 		# detect table align (and remove spaces mark)
    2234. 

  2234. 		if line[0] == ' ': ret['align'] = 'Center'
    2235. 

  2235. 		line = string.lstrip(line)
    2236. 

  2236. 		# detect title mark
    2237. 

  2237. 		if line[1] == '|': ret['title'] = 1
    2238. 

  2238. 		# delete trailing spaces after last cell border
    2239. 

  2239. 		line = re.sub('\|\s*$','|', line)
    2240. 

  2240. 		# detect (and delete) border mark (and leading space)
    2241. 

  2241. 		if line[-1] == '|': ret['border'] = 1 ; line = line[:-2]
    2242. 

  2242. 		# delete table mark
    2243. 

  2243. 		line = regex['table'].sub('', line)
    2244. 

  2244. 		# split cells
    2245. 

  2245. 		ret['cells'] = string.split(line, ' | ')
    2246. 

  2246. 		# find cells align
    2247. 

  2247. 		ret['cellalign'] = self._get_cell_align(ret['cells'])
    2248. 

  2248. 		
    2249. 

  2249. 		Debug('Table Prop: %s' % ret, 2)
    2250. 

  2250. 		return ret
    2251. 

  2251. 	
    2252. 

  2252. 	def dump(self):
    2253. 

  2253. 		open  = self._get_open_tag()
    2254. 

  2254. 		rows  = self.rows
    2255. 

  2255. 		close = TAGS['tableClose']
    2256. 

  2256. 		
    2257. 

  2257. 		rowopen     = TAGS['tableRowOpen']
    2258. 

  2258. 		rowclose    = TAGS['tableRowClose']
    2259. 

  2259. 		rowsep      = TAGS['tableRowSep']
    2260. 

  2260. 		titrowopen  = TAGS['tableTitleRowOpen']  or rowopen
    2261. 

  2261. 		titrowclose = TAGS['tableTitleRowClose'] or rowclose
    2262. 

  2262. 		
    2263. 

  2263. 		if rules['breaktablelineopen']:
    2264. 

  2264. 			rowopen = rowopen + '\n'
    2265. 

  2265. 			titrowopen = titrowopen + '\n'
    2266. 

  2266. 		
    2267. 

  2267. 		# tex gotchas
    2268. 

  2268. 		if TARGET == 'tex':
    2269. 

  2269. 			if not self.border:
    2270. 

  2270. 				rowopen = titrowopen = ''
    2271. 

  2271. 			else:
    2272. 

  2272. 				close = rowopen + close
    2273. 

  2273. 		
    2274. 

  2274. 		# now we tag all the table cells on each row
    2275. 

  2275. 		#tagged_cells = map(lambda x: self._tag_cells(x), rows) #!py15
    2276. 

  2276. 		tagged_cells = []
    2277. 

  2277. 		for cell in rows: tagged_cells.append(self._tag_cells(cell))
    2278. 

  2278. 		
    2279. 

  2279. 		# add row separator tags between lines
    2280. 

  2280. 		tagged_rows = []
    2281. 

  2281. 		if rowsep:
    2282. 

  2282. 			#!py15
    2283. 

  2283. 			#tagged_rows = map(lambda x:x+rowsep, tagged_cells)
    2284. 

  2284. 			for cell in tagged_cells:
    2285. 

  2285. 				tagged_rows.append(cell+rowsep)
    2286. 

  2286. 			# remove last rowsep, because the table is over
    2287. 

  2287. 			tagged_rows[-1] = string.replace(
    2288. 

  2288. 			                  tagged_rows[-1], rowsep, '')
    2289. 

  2289. 		# add row BEGIN/END tags for each line
    2290. 

  2290. 		else:
    2291. 

  2291. 			for rowdata in rows:
    2292. 

  2292. 				if rowdata['title']:
    2293. 

  2293. 					o,c = titrowopen, titrowclose
    2294. 

  2294. 				else:
    2295. 

  2295. 					o,c = rowopen, rowclose
    2296. 

  2296. 				row = tagged_cells.pop(0)
    2297. 

  2297. 				tagged_rows.append(o + row + c)
    2298. 

  2298. 		
    2299. 

  2299. 		fulltable = [open] + tagged_rows + [close]
    2300. 

  2300. 		
    2301. 

  2301. 		if rules['blankendtable']: fulltable.append('')
    2302. 

  2302. 		return fulltable
    2303. 

  2303. 

  2304. 

  2305. ##############################################################################
    2306. 

  2306. 

  2307. 

  2308. class BlockMaster:
    2309. 

  2309. 	"TIP: use blockin/out to add/del holders"
    2310. 

  2310. 	def __init__(self):
    2311. 

  2311. 		self.BLK = []
    2312. 

  2312. 		self.HLD = []
    2313. 

  2313. 		self.PRP = []
    2314. 

  2314. 		self.depth = 0
    2315. 

  2315. 		self.last = ''
    2316. 

  2316. 		self.tableparser = None
    2317. 

  2317. 		self.contains = {
    2318. 

  2318. 		  'para'    :['passthru','raw'],
    2319. 

  2319. 		  'verb'    :[],
    2320. 

  2320. 		  'table'   :[],
    2321. 

  2321. 		  'raw'     :[],
    2322. 

  2322. 		  'passthru':[],
    2323. 

  2323. 		  'quote'   :['quote','passthru','raw'],
    2324. 

  2324. 		  'list'    :['list' ,'numlist' ,'deflist','para','verb',
    2325. 

  2325. 		              'raw'  ,'passthru'],
    2326. 

  2326. 		  'numlist' :['list' ,'numlist' ,'deflist','para','verb',
    2327. 

  2327. 		              'raw'  ,'passthru'],
    2328. 

  2328. 		  'deflist' :['list' ,'numlist' ,'deflist','para','verb',
    2329. 

  2329. 		              'raw'  ,'passthru']
    2330. 

  2330. 		}
    2331. 

  2331. 		self.allblocks = self.contains.keys()
    2332. 

  2332. 	
    2333. 

  2333. 	def block(self):
    2334. 

  2334. 		if not self.BLK: return ''
    2335. 

  2335. 		return self.BLK[-1]
    2336. 

  2336. 	
    2337. 

  2337. 	def isblock(self, name=''):
    2338. 

  2338. 		return self.block() == name
    2339. 

  2339. 	
    2340. 

  2340. 	def prop(self, key):
    2341. 

  2341. 		if not self.PRP: return ''
    2342. 

  2342. 		return self.PRP[-1].get(key) or ''
    2343. 

  2343. 	
    2344. 

  2344. 	def propset(self, key, val):
    2345. 

  2345. 		self.PRP[-1][key] = val
    2346. 

  2346. 		#Debug('BLOCK prop ++: %s->%s'%(key,repr(val)), 1)
    2347. 

  2347. 		#Debug('BLOCK props: %s'%(repr(self.PRP)), 1)
    2348. 

  2348. 	
    2349. 

  2349. 	def hold(self):
    2350. 

  2350. 		if not self.HLD: return []
    2351. 

  2351. 		return self.HLD[-1]
    2352. 

  2352. 	
    2353. 

  2353. 	def holdadd(self, line):
    2354. 

  2354. 		if self.block()[-4:] == 'list': line = [line]
    2355. 

  2355. 		self.HLD[-1].append(line)
    2356. 

  2356. 		Debug('HOLD add: %s'%repr(line), 5)
    2357. 

  2357. 		Debug('FULL HOLD: %s'%self.HLD, 2)
    2358. 

  2358. 	
    2359. 

  2359. 	def holdaddsub(self, line):
    2360. 

  2360. 		self.HLD[-1][-1].append(line)
    2361. 

  2361. 		Debug('HOLD addsub: %s'%repr(line), 5)
    2362. 

  2362. 		Debug('FULL HOLD: %s'%self.HLD, 2)
    2363. 

  2363. 	
    2364. 

  2364. 	def holdextend(self, lines):
    2365. 

  2365. 		if self.block()[-4:] == 'list': lines = [lines]
    2366. 

  2366. 		self.HLD[-1].extend(lines)
    2367. 

  2367. 		Debug('HOLD extend: %s'%repr(lines), 5)
    2368. 

  2368. 		Debug('FULL HOLD: %s'%self.HLD, 2)
    2369. 

  2369. 	
    2370. 

  2370. 	def blockin(self, block):
    2371. 

  2371. 		ret = []
    2372. 

  2372. 		if block not in self.allblocks:
    2373. 

  2373. 			Error("Invalid block '%s'"%block)
    2374. 

  2374. 		# first, let's close other possible open blocks
    2375. 

  2375. 		while self.block() and block not in self.contains[self.block()]:
    2376. 

  2376. 			ret.extend(self.blockout())
    2377. 

  2377. 		# now we can gladly add this new one
    2378. 

  2378. 		self.BLK.append(block)
    2379. 

  2379. 		self.HLD.append([])
    2380. 

  2380. 		self.PRP.append({})
    2381. 

  2381. 		if block == 'table': self.tableparser = TableMaster()
    2382. 

  2382. 		# deeper and deeper
    2383. 

  2383. 		self.depth = len(self.BLK)
    2384. 

  2384. 		Debug('block ++ (%s): %s' % (block,self.BLK), 6)
    2385. 

  2385. 		return ret
    2386. 

  2386. 	
    2387. 

  2387. 	def blockout(self):
    2388. 

  2388. 		if not self.BLK: Error('No block to pop')
    2389. 

  2389. 		self.last = self.BLK.pop()
    2390. 

  2390. 		tagged = getattr(self, self.last)()
    2391. 

  2391. 		parsed = self.HLD.pop()
    2392. 

  2392. 		self.PRP.pop()
    2393. 

  2393. 		self.depth = len(self.BLK)
    2394. 

  2394. 		if self.last == 'table': del self.tableparser
    2395. 

  2395. 		# inserting a nested block into mother
    2396. 

  2396. 		if self.block():
    2397. 

  2397. 			if self.block()[-4:] == 'list':
    2398. 

  2398. 				self.HLD[-1][-1].append(tagged)
    2399. 

  2399. 			else:
    2400. 

  2400. 				self.HLD[-1].append(tagged)
    2401. 

  2401. 			tagged = []   # reset. mother will have it all
    2402. 

  2402. 		Debug('block -- (%s): %s' % (self.last,self.BLK), 6)
    2403. 

  2403. 		Debug('RELEASED (%s): %s' % (self.last,parsed), 6)
    2404. 

  2404. 		if tagged: Debug('DUMPED: %s'%tagged, 2)
    2405. 

  2405. 		return tagged
    2406. 

  2406. 	
    2407. 

  2407. 	def _last_escapes(self, line):
    2408. 

  2408. 		return doFinalEscape(TARGET, line)
    2409. 

  2409. 	
    2410. 

  2410. 	def _get_escaped_hold(self):
    2411. 

  2411. 		ret = []
    2412. 

  2412. 		for line in self.hold():
    2413. 

  2413. 			linetype = type(line)
    2414. 

  2414. 			if linetype == type(''):
    2415. 

  2415. 				ret.append(self._last_escapes(line))
    2416. 

  2416. 			elif linetype == type([]):
    2417. 

  2417. 				ret.extend(line)
    2418. 

  2418. 			else:
    2419. 

  2419. 				Error("BlockMaster: Unknown HOLD item type:"
    2420. 

  2420. 				      " %s"%linetype)
    2421. 

  2421. 		return ret
    2422. 

  2422. 	
    2423. 

  2423. 	def _remove_twoblanks(self, lastitem):
    2424. 

  2424. 		if len(lastitem) > 1 and lastitem[-2:] == ['','']:
    2425. 

  2425. 			return lastitem[:-2]
    2426. 

  2426. 		return lastitem
    2427. 

  2427. 	
    2428. 

  2428. 	def passthru(self):
    2429. 

  2429. 		return self.hold()
    2430. 

  2430. 	
    2431. 

  2431. 	def raw(self):
    2432. 

  2432. 		lines = self.hold()
    2433. 

  2433. 		return map(lambda x: doEscape(TARGET, x), lines)
    2434. 

  2434. 	
    2435. 

  2435. 	def para(self):
    2436. 

  2436. 		tagged = []
    2437. 

  2437. 		open  = TAGS['paragraphOpen']
    2438. 

  2438. 		close = TAGS['paragraphClose']
    2439. 

  2439. 		lines = self._get_escaped_hold()
    2440. 

  2440. 		# open (or not) paragraph
    2441. 

  2441. 		if not open+close and self.last == 'para':
    2442. 

  2442. 			pass # avoids multiple blank lines
    2443. 

  2443. 		else:
    2444. 

  2444. 			tagged.append(open)
    2445. 

  2445. 		# pagemaker likes a paragraph as a single long line
    2446. 

  2446. 		if rules['onelinepara']:
    2447. 

  2447. 			tagged.append(string.join(lines,' '))
    2448. 

  2448. 		# others are normal :)
    2449. 

  2449. 		else:
    2450. 

  2450. 			tagged.extend(lines)
    2451. 

  2451. 		tagged.append(close)
    2452. 

  2452. 		
    2453. 

  2453. 		# very very very very very very very very very UGLY fix
    2454. 

  2454. 		# needed because <center> can't appear inside <p>
    2455. 

  2455. 		try:
    2456. 

  2456. 			if len(lines) == 1 and \
    2457. 

  2457. 			   TARGET in ('html', 'xhtml') and \
    2458. 

  2458. 			   re.match('^\s*<center>.*</center>\s*$', lines[0]):
    2459. 

  2459. 				tagged = [lines[0]]
    2460. 

  2460. 		except: pass
    2461. 

  2461. 		
    2462. 

  2462. 		return tagged
    2463. 

  2463. 	
    2464. 

  2464. 	def verb(self):
    2465. 

  2465. 		"Verbatim lines are not masked, so there's no need to unmask"
    2466. 

  2466. 		tagged = []
    2467. 

  2467. 		tagged.append(TAGS['blockVerbOpen'])
    2468. 

  2468. 		for line in self.hold():
    2469. 

  2469. 			if not rules['verbblocknotescaped']:
    2470. 

  2470. 				line = doEscape(TARGET,line)
    2471. 

  2471. 			if rules['indentverbblock']:
    2472. 

  2472. 				line = '  '+line
    2473. 

  2473. 			if rules['verbblockfinalescape']:
    2474. 

  2474. 				line = doFinalEscape(TARGET, line)
    2475. 

  2475. 			tagged.append(line)
    2476. 

  2476. 		#TODO maybe use if not TAGS['blockVerbClose']
    2477. 

  2477. 		if TARGET != 'pm6':
    2478. 

  2478. 			tagged.append(TAGS['blockVerbClose'])
    2479. 

  2479. 		return tagged
    2480. 

  2480. 	
    2481. 

  2481. 	def table(self):
    2482. 

  2482. 		# rewrite all table cells by the unmasked and escaped data
    2483. 

  2483. 		lines = self._get_escaped_hold()
    2484. 

  2484. 		for i in range(len(lines)):
    2485. 

  2485. 			cells = string.split(lines[i], SEPARATOR)
    2486. 

  2486. 			self.tableparser.rows[i]['cells'] = cells
    2487. 

  2487. 		
    2488. 

  2488. 		return self.tableparser.dump()
    2489. 

  2489. 	
    2490. 

  2490. 	def quote(self):
    2491. 

  2491. 		tagged = []
    2492. 

  2492. 		myre   = regex['quote']
    2493. 

  2493. 		open   = TAGS['blockQuoteOpen']            # block based
    2494. 

  2494. 		close  = TAGS['blockQuoteClose']
    2495. 

  2495. 		qline  = TAGS['blockQuoteLine']            # line based
    2496. 

  2496. 		indent = tagindent = '\t'*self.depth
    2497. 

  2497. 		if rules['tagnotindentable']: tagindent = ''
    2498. 

  2498. 		if not rules['keepquoteindent']: indent = ''
    2499. 

  2499. 		
    2500. 

  2500. 		if open: tagged.append(tagindent+open)     # open block
    2501. 

  2501. 		for item in self.hold():
    2502. 

  2502. 			if type(item) == type([]):
    2503. 

  2503. 				tagged.extend(item)        # subquotes
    2504. 

  2504. 			else:
    2505. 

  2505. 				item = myre.sub('', item)  # del TABs
    2506. 

  2506. 				if rules['barinsidequote']:
    2507. 

  2507. 					item = get_tagged_bar(item)
    2508. 

  2508. 				item = self._last_escapes(item)
    2509. 

  2509. 				item = qline*self.depth + item
    2510. 

  2510. 				tagged.append(indent+item) # quote line
    2511. 

  2511. 		if close: tagged.append(tagindent+close)   # close block
    2512. 

  2512. 		return tagged
    2513. 

  2513. 	
    2514. 

  2514. 	def deflist(self): return self.list('deflist')
    2515. 

  2515. 	def numlist(self): return self.list('numlist')
    2516. 

  2516. 	def list(self, name='list'):
    2517. 

  2517. 		tagged    = []
    2518. 

  2518. 		items     = self.hold()
    2519. 

  2519. 		indent    = self.prop('indent')
    2520. 

  2520. 		tagindent = indent
    2521. 

  2521. 		listopen  = TAGS.get(name+'Open')
    2522. 

  2522. 		listclose = TAGS.get(name+'Close')
    2523. 

  2523. 		listline  = TAGS.get(name+'ItemLine')
    2524. 

  2524. 		itemcount = 0
    2525. 

  2525. 		if rules['tagnotindentable']: tagindent = ''
    2526. 

  2526. 		if not rules['keeplistindent']: indent = ''
    2527. 

  2527. 		
    2528. 

  2528. 		if name == 'deflist':
    2529. 

  2529. 			itemopen  = TAGS[name+'Item1Open']
    2530. 

  2530. 			itemclose = TAGS[name+'Item2Close']
    2531. 

  2531. 			itemsep   = TAGS[name+'Item1Close']+\
    2532. 

  2532. 			            TAGS[name+'Item2Open']
    2533. 

  2533. 		else:
    2534. 

  2534. 			itemopen  = TAGS[name+'ItemOpen']
    2535. 

  2535. 			itemclose = TAGS[name+'ItemClose']
    2536. 

  2536. 			itemsep   = ''
    2537. 

  2537. 		
    2538. 

  2538. 		# ItemLine: number of leading chars identifies list depth
    2539. 

  2539. 		if listline:
    2540. 

  2540. 			itemopen  = listline*self.depth
    2541. 

  2541. 			# dirty fix for mgp
    2542. 

  2542. 			if name == 'numlist': itemopen = itemopen + '\a. '
    2543. 

  2543. 		
    2544. 

  2544. 		# remove two-blanks from list ending mark, to avoid <p>
    2545. 

  2545. 		items[-1] = self._remove_twoblanks(items[-1])
    2546. 

  2546. 		
    2547. 

  2547. 		# open list (not nestable lists are only opened at mother)
    2548. 

  2548. 		if listopen and not \
    2549. 

  2549. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    2550. 

  2550. 			tagged.append(tagindent+listopen)
    2551. 

  2551. 		
    2552. 

  2552. 		# tag each list item (multine items)
    2553. 

  2553. 		itemopenorig = itemopen
    2554. 

  2554. 		for item in items:
    2555. 

  2555. 			
    2556. 

  2556. 			# add "manual" item count for noautonum targets
    2557. 

  2557. 			itemcount = itemcount + 1
    2558. 

  2558. 			if name == 'numlist' and not rules['autonumberlist']:
    2559. 

  2559. 				n = str(itemcount)
    2560. 

  2560. 				itemopen = regex['x'].sub(n, itemopenorig)
    2561. 

  2561. 				del n
    2562. 

  2562. 			
    2563. 

  2563. 			item[0] = self._last_escapes(item[0])
    2564. 

  2564. 			if name == 'deflist':
    2565. 

  2565. 				term, rest = string.split(item[0],SEPARATOR,1)
    2566. 

  2566. 				item[0] = rest
    2567. 

  2567. 				if not item[0]: del item[0]      # to avoid <p>
    2568. 

  2568. 				tagged.append(tagindent+itemopen+term+itemsep)
    2569. 

  2569. 			else:
    2570. 

  2570. 				fullitem = tagindent+itemopen
    2571. 

  2571. 				tagged.append(string.replace(
    2572. 

  2572. 				              item[0], SEPARATOR, fullitem))
    2573. 

  2573. 				del item[0]
    2574. 

  2574. 			
    2575. 

  2575. 			# process next lines for this item (if any)
    2576. 

  2576. 			for line in item:
    2577. 

  2577. 				if type(line) == type([]): # sublist inside
    2578. 

  2578. 					tagged.extend(line)
    2579. 

  2579. 				else:
    2580. 

  2580. 					line = self._last_escapes(line)
    2581. 

  2581. 					# blank lines turns to <p>
    2582. 

  2582. 					if not line and rules['parainsidelist']:
    2583. 

  2583. 						line = string.rstrip(indent   +\
    2584. 

  2584. 						         TAGS['paragraphOpen']+\
    2585. 

  2585. 						         TAGS['paragraphClose'])
    2586. 

  2586. 					if not rules['keeplistindent']:
    2587. 

  2587. 						line = string.lstrip(line)
    2588. 

  2588. 					tagged.append(line)
    2589. 

  2589. 			
    2590. 

  2590. 			# close item (if needed)
    2591. 

  2591. 			if itemclose: tagged.append(tagindent+itemclose)
    2592. 

  2592. 		
    2593. 

  2593. 		# close list (not nestable lists are only closed at mother)
    2594. 

  2594. 		if listclose and not \
    2595. 

  2595. 		   (rules['listnotnested'] and BLOCK.depth != 1):
    2596. 

  2596. 			tagged.append(tagindent+listclose)
    2597. 

  2597. 		
    2598. 

  2598. 		if rules['blankendmotherlist'] and BLOCK.depth == 1:
    2599. 

  2599. 			tagged.append('')
    2600. 

  2600. 		
    2601. 

  2601. 		return tagged
    2602. 

  2602. 

  2603. 

  2604. ##############################################################################
    2605. 

  2605. 

  2606. 

  2607. def dumpConfig(source_raw, parsed_config):
    2608. 

  2608. 	onoff = {1:_('ON'), 0:_('OFF')}
    2609. 

  2609. 	data = [
    2610. 

  2610. 	  (_('RC file')        , RC_RAW     ),
    2611. 

  2611. 	  (_('source document'), source_raw ),
    2612. 

  2612. 	  (_('command line')   , CMDLINE_RAW)
    2613. 

  2613. 	]
    2614. 

  2614. 	# first show all RAW data found
    2615. 

  2615. 	for label, cfg in data:
    2616. 

  2616. 		print _('RAW config for %s')%label
    2617. 

  2617. 		for target,key,val in cfg:
    2618. 

  2618. 			target = '(%s)'%target
    2619. 

  2619. 			key    = dotted_spaces("%-14s"%key)
    2620. 

  2620. 			val    = val or _('ON')
    2621. 

  2621. 			print '  %-8s %s: %s'%(target,key,val)
    2622. 

  2622. 		print
    2623. 

  2623. 	# then the parsed results of all of them
    2624. 

  2624. 	print _('Full PARSED config')
    2625. 

  2625. 	keys = parsed_config.keys() ; keys.sort()  # sorted
    2626. 

  2626. 	for key in keys:
    2627. 

  2627. 		val = parsed_config[key]
    2628. 

  2628. 		# filters are the last
    2629. 

  2629. 		if key in ['preproc', 'postproc']:
    2630. 

  2630. 			continue
    2631. 

  2631. 		# flag beautifier
    2632. 

  2632. 		if key in FLAGS.keys()+ACTIONS.keys():
    2633. 

  2633. 			val = onoff.get(val) or val
    2634. 

  2634. 		# list beautifier
    2635. 

  2635. 		if type(val) == type([]):
    2636. 

  2636. 			if key == 'options': sep = ' '
    2637. 

  2637. 			else               : sep = ', '
    2638. 

  2638. 			val = string.join(val, sep)
    2639. 

  2639. 		print "%25s: %s"%(dotted_spaces("%-14s"%key),val)
    2640. 

  2640. 	print
    2641. 

  2641. 	print _('Active filters')
    2642. 

  2642. 	for filter in ['preproc','postproc']:
    2643. 

  2643. 		for rule in parsed_config.get(filter) or []:
    2644. 

  2644. 			print "%25s: %s  ->  %s"%(
    2645. 

  2645. 			   dotted_spaces("%-14s"%filter),rule[0],rule[1])
    2646. 

  2646. 

  2647. 

  2648. def get_file_body(file):
    2649. 

  2649. 	"Returns all the document BODY lines"
    2650. 

  2650. 	return process_source_file(file, noconf=1)[1][2]
    2651. 

  2651. 

  2652. 

  2653. def finish_him(outlist, config):
    2654. 

  2654. 	"Writing output to screen or file"
    2655. 

  2655. 	outfile = config['outfile']
    2656. 

  2656. 	outlist = unmaskEscapeChar(outlist)
    2657. 

  2657. 	
    2658. 

  2658. 	# do PostProc
    2659. 

  2659. 	if config['postproc']:
    2660. 

  2660. 		postoutlist = []
    2661. 

  2661. 		errmsg = _('Invalid PostProc filter regex')
    2662. 

  2662. 		for line in outlist:
    2663. 

  2663. 			for patt,repl in config['postproc']:
    2664. 

  2664. 				try   : line = re.sub(patt, repl, line)
    2665. 

  2665. 				except: Error("%s: '%s'"% (errmsg,patt))
    2666. 

  2666. 			postoutlist.append(line)
    2667. 

  2667. 		outlist = postoutlist[:]
    2668. 

  2668. 	
    2669. 

  2669. 	if outfile == STDOUT:
    2670. 

  2670. 		if GUI:
    2671. 

  2671. 			return outlist, config
    2672. 

  2672. 		else:
    2673. 

  2673. 			for line in outlist: print line
    2674. 

  2674. 	else:
    2675. 

  2675. 		Savefile(outfile, addLineBreaks(outlist))
    2676. 

  2676. 		if not GUI: print _('%s wrote %s')%(my_name,outfile)
    2677. 

  2677. 	
    2678. 

  2678. 	if config['split']:
    2679. 

  2679. 		print "--- html..."
    2680. 

  2680. 		sgml2html = 'sgml2html -s %s -l %s %s'%(
    2681. 

  2681. 		            config['split'],config['lang'] or lang,outfile)
    2682. 

  2682. 		print "Running system command:", sgml2html
    2683. 

  2683. 		os.system(sgml2html)
    2684. 

  2684. 

  2685. 

  2686. def toc_maker(toc, config):
    2687. 

  2687. 	"Compose TOC list 'by hand'"
    2688. 

  2688. 	ret = []
    2689. 

  2689. 	# TOC is a tag, so there's nothing to do here
    2690. 

  2690. 	if TAGS['TOC'] and not config['toc-only']: return []
    2691. 

  2691. 	# TOC is a valid t2t marked text (list type), that is converted
    2692. 

  2692. 	if config['toc'] or config['toc-only']:
    2693. 

  2693. 		fakeconf = config.copy()
    2694. 

  2694. 		fakeconf['headers']    = 0
    2695. 

  2695. 		fakeconf['toc-only']   = 0
    2696. 

  2696. 		fakeconf['mask-email'] = 0
    2697. 

  2697. 		fakeconf['preproc']    = []
    2698. 

  2698. 		fakeconf['postproc']   = []
    2699. 

  2699. 		fakeconf['css-suggar'] = 0
    2700. 

  2700. 		ret,foo = convert(toc, fakeconf)
    2701. 

  2701. 	# TOC between bars (not for --toc-only)
    2702. 

  2702. 	if config['toc']:
    2703. 

  2703. 		if TAGS['tocOpenCss'] and config['css-suggar']:
    2704. 

  2704. 			ret = [TAGS['tocOpenCss']] +ret +[TAGS['tocCloseCss']]
    2705. 

  2705. 		else:
    2706. 

  2706. 			para = TAGS['paragraphOpen']+TAGS['paragraphClose']
    2707. 

  2707. 			tag  = regex['x'].sub('-'*72,TAGS['bar1'])
    2708. 

  2708. 			tocbar = [para, tag, para]
    2709. 

  2709. 			ret = tocbar + ret + tocbar
    2710. 

  2710. 			open, close = TAGS['tocOpen'], TAGS['tocClose']
    2711. 

  2711. 			if open : ret = [open] + ret
    2712. 

  2712. 			if close: ret = ret + [close]
    2713. 

  2713. 	return ret
    2714. 

  2714. 

  2715. 

  2716. def doHeader(headers, config):
    2717. 

  2717. 	if not config['headers']: return []
    2718. 

  2718. 	if not headers: headers = ['','','']
    2719. 

  2719. 	target = config['target']
    2720. 

  2720. 	if not HEADER_TEMPLATE.has_key(target):
    2721. 

  2721. 		Error("doheader: Unknow target '%s'"%target)
    2722. 

  2722. 	
    2723. 

  2723. 	if target in ['html','xhtml'] and config.get('css-suggar'):
    2724. 

  2724. 		template = string.split(HEADER_TEMPLATE[target+'css'], '\n')
    2725. 

  2725. 	else:
    2726. 

  2726. 		template = string.split(HEADER_TEMPLATE[target], '\n')
    2727. 

  2727. 	
    2728. 

  2728. 	head_data = {'STYLE':'', 'ENCODING':''}
    2729. 

  2729. 	for key in head_data.keys():
    2730. 

  2730. 		val = config.get(string.lower(key))
    2731. 

  2731. 		if key == 'ENCODING': val = get_encoding_string(val, target)
    2732. 

  2732. 		head_data[key] = val
    2733. 

  2733. 	# parse header contents
    2734. 

  2734. 	for i in 0,1,2:
    2735. 

  2735. 		contents = doDateMacro(headers[i])  # expand %%date
    2736. 

  2736. 		# Escapes - on tex, just do it if any \tag{} present
    2737. 

  2737. 		if target != 'tex' or \
    2738. 

  2738. 		  (target == 'tex' and re.search(r'\\\w+{', contents)):
    2739. 

  2739. 			contents = doEscape(target, contents)
    2740. 

  2740. 		
    2741. 

  2741. 		head_data['HEADER%d'%(i+1)] = contents
    2742. 

  2742. 	Debug("Header Data: %s"%head_data, 1)
    2743. 

  2743. 	# scan for empty dictionary keys
    2744. 

  2744. 	# if found, scan template lines for that key reference
    2745. 

  2745. 	# if found, remove the reference
    2746. 

  2746. 	# if there isn't any other key reference on the same line, remove it
    2747. 

  2747. 	for key in head_data.keys():
    2748. 

  2748. 		if head_data.get(key): continue
    2749. 

  2749. 		for line in template:
    2750. 

  2750. 			if string.count(line, '%%(%s)s'%key):
    2751. 

  2751. 				sline = string.replace(line, '%%(%s)s'%key, '')
    2752. 

  2752. 				if not re.search(r'%\([A-Z0-9]+\)s', sline):
    2753. 

  2753. 					template.remove(line)
    2754. 

  2754. 	# populate template with data
    2755. 

  2755. 	template = string.join(template, '\n') % head_data
    2756. 

  2756. 	### post processing
    2757. 

  2757. 	#
    2758. 

  2758. 	# let tex format today
    2759. 

  2759. 	# DISABLED: not a good idea have date format different on tex
    2760. 

  2760. 	#if target == 'tex' and head_data['HEADER3'] == currdate:
    2761. 

  2761. 	#	template = re.sub(r'\\date\{.*?}', r'\date', template)
    2762. 

  2762. 	
    2763. 

  2763. 	return string.split(template, '\n')
    2764. 

  2764. 

  2765. def doDateMacro(line):
    2766. 

  2766. 	re_date = getRegexes()['date']
    2767. 

  2767. 	while re_date.search(line):
    2768. 

  2768. 		m = re_date.search(line)
    2769. 

  2769. 		fmt = m.group('fmt') or ''
    2770. 

  2770. 		dateme = currdate
    2771. 

  2771. 		if fmt: dateme = strftime(fmt,localtime(time()))
    2772. 

  2772. 		line = re_date.sub(dateme,line,1)
    2773. 

  2773. 	return line
    2774. 

  2774. 

  2775. def doCommentLine(txt):
    2776. 

  2776. 	# the -- string ends a (h|sg|xht)ml comment :(
    2777. 

  2777. 	txt = maskEscapeChar(txt)
    2778. 

  2778. 	if string.count(TAGS['comment'], '--') and \
    2779. 

  2779. 	   string.count(txt, '--'):
    2780. 

  2780. 		txt = re.sub('-(?=-)', r'-\\', txt)
    2781. 

  2781. 	
    2782. 

  2782. 	if TAGS['comment']:
    2783. 

  2783. 		return regex['x'].sub(txt, TAGS['comment'])
    2784. 

  2784. 	return ''
    2785. 

  2785. 

  2786. def doFooter(config):
    2787. 

  2787. 	if not config['headers']: return []
    2788. 

  2788. 	ret = []
    2789. 

  2789. 	target = config['target']
    2790. 

  2790. 	cmdline = config['realcmdline']
    2791. 

  2791. 	typename = target
    2792. 

  2792. 	if target == 'tex': typename = 'LaTeX2e'
    2793. 

  2793. 	ppgd = '%s code generated by %s %s (%s)'%(
    2794. 

  2794. 	        typename,my_name,my_version,my_url)
    2795. 

  2795. 	cmdline = 'cmdline: %s %s'%(my_name, string.join(cmdline, ' '))
    2796. 

  2796. 	ret.append('\n'+doCommentLine(ppgd))
    2797. 

  2797. 	ret.append(doCommentLine(cmdline))
    2798. 

  2798. 	ret.append(TAGS['EOD'])
    2799. 

  2799. 	return ret
    2800. 

  2800. 

  2801. def doEscape(target,txt):
    2802. 

  2802. 	"Target-specific special escapes. Apply *before* insert any tag."
    2803. 

  2803. 	if target in ['html','sgml','xhtml']:
    2804. 

  2804. 		txt = re.sub('&','&amp;',txt)
    2805. 

  2805. 		txt = re.sub('<','&lt;',txt)
    2806. 

  2806. 		txt = re.sub('>','&gt;',txt)
    2807. 

  2807. 		if target == 'sgml':
    2808. 

  2808. 			txt = re.sub('\xff','&yuml;',txt)  # "+y
    2809. 

  2809. 	elif target == 'pm6':
    2810. 

  2810. 		txt = re.sub('<','<\#60>',txt)
    2811. 

  2811. 	elif target == 'mgp':
    2812. 

  2812. 		txt = re.sub('^%',' %',txt)  # add leading blank to avoid parse
    2813. 

  2813. 	elif target == 'man':
    2814. 

  2814. 		txt = re.sub("^([.'])", '\\&\\1',txt)           # command ID
    2815. 

  2815. 		txt = string.replace(txt,ESCCHAR, ESCCHAR+'e')  # \e
    2816. 

  2816. 	elif target == 'tex':
    2817. 

  2817. 		# mark literal \ to be changed to $\backslash$ later
    2818. 

  2818. 		txt = string.replace( txt, ESCCHAR, '@@LaTeX-escaping-SUX@@')
    2819. 

  2819. 		txt = re.sub('([#$&%{}])', ESCCHAR+r'\1'  , txt)  # \%
    2820. 

  2820. 		txt = re.sub('([~^])'    , ESCCHAR+r'\1{}', txt)  # \~{}
    2821. 

  2821. 		txt = re.sub('([<|>])'   ,         r'$\1$', txt)  # $>$
    2822. 

  2822. 		txt = string.replace(txt, '@@LaTeX-escaping-SUX@@',
    2823. 

  2823. 		                     maskEscapeChar(r'$\backslash$'))
    2824. 

  2824. 		# TIP the _ is escaped at the end
    2825. 

  2825. 	return txt
    2826. 

  2826. 

  2827. # TODO man: where - really needs to be escaped?
    2828. 

  2828. def doFinalEscape(target, txt):
    2829. 

  2829. 	"Last escapes of each line"
    2830. 

  2830. 	if   target == 'pm6' : txt = string.replace(txt,ESCCHAR+'<',r'<\#92><')
    2831. 

  2831. 	elif target == 'man' : txt = string.replace(txt, '-', r'\-')
    2832. 

  2832. 	elif target == 'tex' : txt = string.replace(txt, '_', r'\_')
    2833. 

  2833. 	elif target == 'sgml': txt = string.replace(txt, '[', '&lsqb;')
    2834. 

  2834. 	return txt
    2835. 

  2835. 

  2836. def EscapeCharHandler(action, data):
    2837. 

  2837. 	"Mask/Unmask the Escape Char on the given string"
    2838. 

  2838. 	if not string.strip(data): return data
    2839. 

  2839. 	if action not in ['mask','unmask']:
    2840. 

  2840. 		Error("EscapeCharHandler: Invalid action '%s'"%action)
    2841. 

  2841. 	if action == 'mask': return string.replace(data,'\\',ESCCHAR)
    2842. 

  2842. 	else:                return string.replace(data,ESCCHAR,'\\')
    2843. 

  2843. 

  2844. def maskEscapeChar(data):
    2845. 

  2845. 	"Replace any Escape Char \ with a text mask (Input: str or list)"
    2846. 

  2846. 	if type(data) == type([]):
    2847. 

  2847. 		return map(lambda x: EscapeCharHandler('mask', x), data)
    2848. 

  2848. 	return EscapeCharHandler('mask',data)
    2849. 

  2849. 

  2850. def unmaskEscapeChar(data):
    2851. 

  2851. 	"Undo the Escape char \ masking (Input: str or list)"
    2852. 

  2852. 	if type(data) == type([]):
    2853. 

  2853. 		return map(lambda x: EscapeCharHandler('unmask', x), data)
    2854. 

  2854. 	return EscapeCharHandler('unmask',data)
    2855. 

  2855. 

  2856. def addLineBreaks(list):
    2857. 

  2857. 	"use LB to respect sys.platform"
    2858. 

  2858. 	ret = []
    2859. 

  2859. 	for line in list:
    2860. 

  2860. 		line = string.replace(line,'\n',LB)  # embedded \n's
    2861. 

  2861. 		ret.append(line+LB)                  # add final line break
    2862. 

  2862. 	return ret
    2863. 

  2863. 

  2864. def enclose_me(tagname, txt):
    2865. 

  2865. 	return TAGS.get(tagname+'Open') + txt + TAGS.get(tagname+'Close')
    2866. 

  2866. 

  2867. def beautify_me(name, line):
    2868. 

  2868. 	"where name is: bold, italic or underline"
    2869. 

  2869. 	name  = 'font%s' % string.capitalize(name)
    2870. 

  2870. 	open  = TAGS['%sOpen'%name]
    2871. 

  2871. 	close = TAGS['%sClose'%name]
    2872. 

  2872. 	txt = r'%s\1%s'%(open, close)
    2873. 

  2873. 	line = regex[name].sub(txt,line)
    2874. 

  2874. 	return line
    2875. 

  2875. 

  2876. def get_tagged_link(label, url):
    2877. 

  2877. 	ret = ''
    2878. 

  2878. 	target = CONF['target']
    2879. 

  2879. 	image_re = regex['img']
    2880. 

  2880. 	
    2881. 

  2881. 	# set link type
    2882. 

  2882. 	if regex['email'].match(url):
    2883. 

  2883. 		linktype = 'email'
    2884. 

  2884. 	else:
    2885. 

  2885. 		linktype = 'url';
    2886. 

  2886. 	
    2887. 

  2887. 	# escape specials from TEXT parts
    2888. 

  2888. 	label = doEscape(target,label)
    2889. 

  2889. 	
    2890. 

  2890. 	# escape specials from link URL
    2891. 

  2891. 	if rules['linkable'] and rules['escapeurl']:
    2892. 

  2892. 		url = doEscape(target, url)
    2893. 

  2893. 	
    2894. 

  2894. 	# if not linkable, the URL is plain text, that needs escape
    2895. 

  2895. 	if not rules['linkable']:
    2896. 

  2896. 		if target == 'tex':
    2897. 

  2897. 			url = re.sub('^#', '\#', url) # ugly, but compile
    2898. 

  2898. 		else:
    2899. 

  2899. 			url = doEscape(target,url)
    2900. 

  2900. 	
    2901. 

  2901. 	# adding protocol to guessed link
    2902. 

  2902. 	guessurl = ''
    2903. 

  2903. 	if linktype == 'url' and \
    2904. 

  2904. 	   re.match(regex['_urlskel']['guess'], url):
    2905. 

  2905. 		if url[0] == 'w': guessurl = 'http://' +url
    2906. 

  2906. 		else            : guessurl =  'ftp://' +url
    2907. 

  2907. 		
    2908. 

  2908. 		# not link aware targets -> protocol is useless
    2909. 

  2909. 		if not rules['linkable']: guessurl = ''
    2910. 

  2910. 	
    2911. 

  2911. 	# simple link (not guessed)
    2912. 

  2912. 	if not label and not guessurl:
    2913. 

  2913. 		if CONF['mask-email'] and linktype == 'email':
    2914. 

  2914. 			# do the email mask feature (no TAGs, just text)
    2915. 

  2915. 			url = string.replace(url,'@',' (a) ')
    2916. 

  2916. 			url = string.replace(url,'.',' ')
    2917. 

  2917. 			url = "<%s>" % url
    2918. 

  2918. 			if rules['linkable']: url = doEscape(target, url)
    2919. 

  2919. 			ret = url
    2920. 

  2920. 		else:
    2921. 

  2921. 			# just add link data to tag
    2922. 

  2922. 			tag = TAGS[linktype]
    2923. 

  2923. 			ret = regex['x'].sub(url,tag)
    2924. 

  2924. 	
    2925. 

  2925. 	# named link or guessed simple link
    2926. 

  2926. 	else:
    2927. 

  2927. 		# adjusts for guessed link
    2928. 

  2928. 		if not label: label = url         # no   protocol
    2929. 

  2929. 		if guessurl : url   = guessurl    # with protocol
    2930. 

  2930. 		
    2931. 

  2931. 		# image inside link!
    2932. 

  2932. 		if image_re.match(label):
    2933. 

  2933. 			if rules['imglinkable']:  # get image tag
    2934. 

  2934. 				label = parse_images(label)
    2935. 

  2935. 			else:                     #  img@link !supported
    2936. 

  2936. 				label = "(%s)"%image_re.match(label).group(1)
    2937. 

  2937. 		
    2938. 

  2938. 		# putting data on the right appearance order
    2939. 

  2939. 		if rules['linkable']:
    2940. 

  2940. 			urlorder = [url, label]   # link before label
    2941. 

  2941. 		else:
    2942. 

  2942. 			urlorder = [label, url]   # label before link
    2943. 

  2943. 		
    2944. 

  2944. 		# add link data to tag (replace \a's)
    2945. 

  2945. 		ret = TAGS["%sMark"%linktype]
    2946. 

  2946. 		for data in urlorder:
    2947. 

  2947. 			ret = regex['x'].sub(data,ret,1)
    2948. 

  2948. 	
    2949. 

  2949. 	return ret
    2950. 

  2950. 

  2951. 

  2952. def parse_deflist_term(line):
    2953. 

  2953. 	"Extract and parse definition list term contents"
    2954. 

  2954. 	img_re = regex['img']
    2955. 

  2955. 	term   = regex['deflist'].search(line).group(3)
    2956. 

  2956. 	
    2957. 

  2957. 	# mask image inside term as (image.jpg), where not supported
    2958. 

  2958. 	if not rules['imgasdefterm'] and img_re.search(term):
    2959. 

  2959. 		while img_re.search(term):
    2960. 

  2960. 			imgfile = img_re.search(term).group(1)
    2961. 

  2961. 			term = img_re.sub('(%s)'%imgfile, term, 1)
    2962. 

  2962. 	
    2963. 

  2963. 	#TODO tex: escape ] on term. \], \rbrack{} and \verb!]! don't work :(
    2964. 

  2964. 	return term
    2965. 

  2965. 

  2966. 

  2967. def get_tagged_bar(line):
    2968. 

  2968. 	m = regex['bar'].search(line)
    2969. 

  2969. 	if not m: return line
    2970. 

  2970. 	txt = m.group(2)
    2971. 

  2971. 	
    2972. 

  2972. 	# set bar type
    2973. 

  2973. 	if txt[0] == '=': bar = TAGS['bar2']
    2974. 

  2974. 	else            : bar = TAGS['bar1']
    2975. 

  2975. 	
    2976. 

  2976. 	# to avoid comment tag confusion like <!-- ------ -->
    2977. 

  2977. 	if string.count(TAGS['comment'], '--'):
    2978. 

  2978. 		txt = string.replace(txt,'--','__')
    2979. 

  2979. 	
    2980. 

  2980. 	# tag line
    2981. 

  2981. 	return regex['x'].sub(txt, bar)
    2982. 

  2982. 

  2983. 

  2984. def get_image_align(line):
    2985. 

  2985. 	"Return the image (first found) align for the given line"
    2986. 

  2986. 	
    2987. 

  2987. 	# first clear marks that can mess align detection
    2988. 

  2988. 	line = re.sub(SEPARATOR+'$', '', line)  # remove deflist sep
    2989. 

  2989. 	line = re.sub('^'+SEPARATOR, '', line)  # remove list sep
    2990. 

  2990. 	line = re.sub('^[\t]+'     , '', line)  # remove quote mark
    2991. 

  2991. 	
    2992. 

  2992. 	# get image position on the line
    2993. 

  2993. 	m = regex['img'].search(line)
    2994. 

  2994. 	ini = m.start() ; head = 0
    2995. 

  2995. 	end = m.end()   ; tail = len(line)
    2996. 

  2996. 	
    2997. 

  2997. 	# the align detection algorithm
    2998. 

  2998. 	if   ini == head and end != tail: align = 'left'   # ^img + text$
    2999. 

  2999. 	elif ini != head and end == tail: align = 'right'  # ^text + img$
    3000. 

  3000. 	else                            : align = 'middle' # default align
    3001. 

  3001. 	
    3002. 

  3002. 	# some special cases
    3003. 

  3003. 	if BLOCK.isblock('table'): align = 'middle'    # ignore when table
    3004. 

  3004. 	if TARGET == 'mgp' and align == 'middle': align = 'center'
    3005. 

  3005. 	
    3006. 

  3006. 	return align
    3007. 

  3007. 

  3008. 

  3009. # reference: http://www.iana.org/assignments/character-sets
    3010. 

  3010. # http://www.drclue.net/F1.cgi/HTML/META/META.html
    3011. 

  3011. def get_encoding_string(enc, target):
    3012. 

  3012. 	if not enc: return ''
    3013. 

  3013. 	# target specific translation table
    3014. 

  3014. 	translate = {
    3015. 

  3015. 	'tex': {
    3016. 

  3016. 	  # missing: ansinew , applemac , cp437 , cp437de , cp865
    3017. 

  3017. 	  'us-ascii'    : 'ascii',
    3018. 

  3018. 	  'windows-1250': 'cp1250',
    3019. 

  3019. 	  'windows-1252': 'cp1252',
    3020. 

  3020. 	  'ibm850'      : 'cp850',
    3021. 

  3021. 	  'ibm852'      : 'cp852',
    3022. 

  3022. 	  'iso-8859-1'  : 'latin1',
    3023. 

  3023. 	  'iso-8859-2'  : 'latin2',
    3024. 

  3024. 	  'iso-8859-3'  : 'latin3',
    3025. 

  3025. 	  'iso-8859-4'  : 'latin4',
    3026. 

  3026. 	  'iso-8859-5'  : 'latin5',
    3027. 

  3027. 	  'iso-8859-9'  : 'latin9',
    3028. 

  3028. 	  'koi8-r'      : 'koi8-r'
    3029. 

  3029. 	  }
    3030. 

  3030. 	}
    3031. 

  3031. 	# normalization
    3032. 

  3032. 	enc = re.sub('(?i)(us[-_]?)?ascii|us|ibm367','us-ascii'  , enc)
    3033. 

  3033. 	enc = re.sub('(?i)(ibm|cp)?85([02])'        ,'ibm85\\2'  , enc)
    3034. 

  3034. 	enc = re.sub('(?i)(iso[_-]?)?8859[_-]?'     ,'iso-8859-' , enc)
    3035. 

  3035. 	enc = re.sub('iso-8859-($|[^1-9]).*'        ,'iso-8859-1', enc)
    3036. 

  3036. 	# apply translation table
    3037. 

  3037. 	try: enc = translate[target][string.lower(enc)]
    3038. 

  3038. 	except: pass
    3039. 

  3039. 	return enc
    3040. 

  3040. 

  3041. 

  3042. ##############################################################################
    3043. 

  3043. ##MerryChristmas,IdontwanttofighttonightwithyouImissyourbodyandIneedyourlove##
    3044. 

  3044. ##############################################################################
    3045. 

  3045. 

  3046. 

  3047. def process_source_file(file, noconf=0):
    3048. 

  3048. 	"""
    3049. 

  3049. 	Find and Join all the configuration available for a source file.
    3050. 

  3050. 	No sanity checkings are done on this step.
    3051. 

  3051. 	It also extracts the source document parts into separate holders.
    3052. 

  3052. 	
    3053. 

  3053. 	The config scan order is:
    3054. 

  3054. 	   1. The user configuration file (i.e. $HOME/.txt2tagsrc)
    3055. 

  3055. 	   2. The source document's CONF area
    3056. 

  3056. 	   3. The command line options
    3057. 

  3057. 

  3058. 	The return data is a tuple of two items:
    3059. 

  3059. 	   1. The parsed config dictionary
    3060. 

  3060. 	   2. The document's parts, as a (head, conf, body) tuple
    3061. 

  3061. 	
    3062. 

  3062. 	All the convertion process will be based on the data and
    3063. 

  3063. 	configuration returned by this function.
    3064. 

  3064. 	The source files is readed on this step only.
    3065. 

  3065. 	"""
    3066. 

  3066. 	source = SourceDocument(file)
    3067. 

  3067. 	head, conf, body = source.split()
    3068. 

  3068. 	Message(_("Source document contents stored"),2)
    3069. 

  3069. 	if not noconf:
    3070. 

  3070. 		# read document config
    3071. 

  3071. 		source_raw = source.get_raw_config()
    3072. 

  3072. 		# join all the config directives found, then parse it
    3073. 

  3073. 		full_raw = RC_RAW + source_raw + CMDLINE_RAW
    3074. 

  3074. 		Message(_("Parsing and saving all config found (%03d items)")%(
    3075. 

  3075. 		        len(full_raw)),1)
    3076. 

  3076. 		full_parsed = ConfigMaster(full_raw).parse()
    3077. 

  3077. 		# add manually the filemane to the conf dic
    3078. 

  3078. 		full_parsed['sourcefile'] = file
    3079. 

  3079. 		# maybe should we dump the config found?
    3080. 

  3080. 		if full_parsed.get('dump-config'):
    3081. 

  3081. 			dumpConfig(source_raw, full_parsed)
    3082. 

  3082. 			sys.exit()
    3083. 

  3083. 		# okay, all done
    3084. 

  3084. 		Debug("FULL config for this file: %s"%full_parsed, 1)
    3085. 

  3085. 	else:
    3086. 

  3086. 		full_parsed = {}
    3087. 

  3087. 	return full_parsed, (head,conf,body)
    3088. 

  3088. 

  3089. def get_infiles_config(infiles):
    3090. 

  3090. 	"""Find and Join into a single list, all configuration available
    3091. 

  3091. 	for each input file. This function is supposed to be the very
    3092. 

  3092. 	first one to be called, before any processing.
    3093. 

  3093. 	"""
    3094. 

  3094. 	ret = []
    3095. 

  3095. 	if not infiles: return []
    3096. 

  3096. 	for infile in infiles:
    3097. 

  3097. 		ret.append((process_source_file(infile)))
    3098. 

  3098. 	return ret
    3099. 

  3099. 

  3100. def convert_this_files(configs):
    3101. 

  3101. 	global CONF
    3102. 

  3102. 	for myconf,doc in configs:                 # multifile support
    3103. 

  3103. 		target_head = []
    3104. 

  3104. 		target_toc  = []
    3105. 

  3105. 		target_body = []
    3106. 

  3106. 		target_foot = []
    3107. 

  3107. 		source_head, source_conf, source_body = doc
    3108. 

  3108. 		myconf = ConfigMaster().sanity(myconf)
    3109. 

  3109. 		# compose the target file Headers
    3110. 

  3110. 		#TODO escape line before?
    3111. 

  3111. 		#TODO see exceptions by tex and mgp
    3112. 

  3112. 		Message(_("Composing target Headers"),1)
    3113. 

  3113. 		target_head = doHeader(source_head, myconf)
    3114. 

  3114. 		# parse the full marked body into tagged target
    3115. 

  3115. 		first_body_line = (len(source_head) or 1)+ len(source_conf) + 1
    3116. 

  3116. 		Message(_("Composing target Body"),1)
    3117. 

  3117. 		target_body, marked_toc = convert(source_body, myconf,
    3118. 

  3118. 		                          firstlinenr=first_body_line)
    3119. 

  3119. 		# make TOC (if needed)
    3120. 

  3120. 		Message(_("Composing target TOC"),1)
    3121. 

  3121. 		target_toc = toc_maker(marked_toc,myconf)
    3122. 

  3122. 		# compose the target file Footer
    3123. 

  3123. 		Message(_("Composing target Footer"),1)
    3124. 

  3124. 		target_foot = doFooter(myconf)
    3125. 

  3125. 		# finally, we have our document
    3126. 

  3126. 		outlist = target_head + target_toc + target_body + target_foot
    3127. 

  3127. 		# if on GUI, abort before finish_him
    3128. 

  3128. 		# else, write results to file or STDOUT
    3129. 

  3129. 		if GUI:
    3130. 

  3130. 			return outlist, myconf
    3131. 

  3131. 		else:
    3132. 

  3132. 			Message(_("Saving results to the output file"),1)
    3133. 

  3133. 			finish_him(outlist, myconf)
    3134. 

  3134. 

  3135. 

  3136. def parse_images(line):
    3137. 

  3137. 	"Tag all images found"
    3138. 

  3138. 	while regex['img'].search(line) and TAGS['img'] != '[\a]':
    3139. 

  3139. 		txt = regex['img'].search(line).group(1)
    3140. 

  3140. 		tag = TAGS['img']
    3141. 

  3141. 		
    3142. 

  3142. 		# HTML, XHTML and mgp!
    3143. 

  3143. 		if rules['imgalignable']:
    3144. 

  3144. 			align = get_image_align(line)
    3145. 

  3145. 			# add align on tag
    3146. 

  3146. 			tag = regex['_imgAlign'].sub(align, tag, 1)
    3147. 

  3147. 			# dirty fix to allow centered solo images
    3148. 

  3148. 			if align == 'middle' and TARGET in ['html','xhtml']:
    3149. 

  3149. 				rest = regex['img'].sub('',line,1)
    3150. 

  3150. 				if re.match('^\s+$', rest):
    3151. 

  3151. 					tag = "<center>%s</center>" %tag
    3152. 

  3152. 		
    3153. 

  3153. 		if TARGET == 'tex': tag = re.sub(r'\\b',r'\\\\b',tag)
    3154. 

  3154. 		line = regex['img'].sub(tag,line,1)
    3155. 

  3155. 		line = regex['x'].sub(txt,line,1)
    3156. 

  3156. 	return line
    3157. 

  3157. 

  3158. 

  3159. def add_inline_tags(line):
    3160. 

  3160. 	# beautifiers
    3161. 

  3161. 	for beauti in ['Bold', 'Italic', 'Underline']:
    3162. 

  3162. 		if regex['font%s'%beauti].search(line):
    3163. 

  3163. 			line = beautify_me(beauti, line)
    3164. 

  3164. 	
    3165. 

  3165. 	line = parse_images(line)
    3166. 

  3166. 	return line
    3167. 

  3167. 

  3168. 

  3169. def get_include_contents(file, path=''):
    3170. 

  3170. 	"Parses %!include: value and extract file contents"
    3171. 

  3171. 	ids = {'`':'verb', '"':'raw', "'":'passthru' }
    3172. 

  3172. 	id = 't2t'
    3173. 

  3173. 	# set include type and remove identifier marks
    3174. 

  3174. 	mark = file[0]
    3175. 

  3175. 	if mark in ids.keys():
    3176. 

  3176. 		if file[:2] == file[-2:] == mark*2:
    3177. 

  3177. 			id = ids[mark]     # set type
    3178. 

  3178. 			file = file[2:-2]  # remove marks
    3179. 

  3179. 	# handle remote dir execution
    3180. 

  3180. 	filepath = os.path.join(path, file)
    3181. 

  3181. 	# read included file contents
    3182. 

  3182. 	lines = Readfile(filepath, remove_linebreaks=1)
    3183. 

  3183. 	# default txt2tags marked text, just BODY matters
    3184. 

  3184. 	if id == 't2t':
    3185. 

  3185. 		lines = get_file_body(filepath)
    3186. 

  3186. 		lines.insert(0, '%%INCLUDED(%s) starts here: %s'%(id,file))
    3187. 

  3187. 		lines.append('%%INCLUDED(%s) ends here: %s'%(id,file))
    3188. 

  3188. 	return id, lines
    3189. 

  3189. 

  3190. 

  3191. def convert(bodylines, config, firstlinenr=1):
    3192. 

  3192. 	# global vars for doClose*()
    3193. 

  3193. 	global TAGS, regex, rules, TARGET, BLOCK, CONF
    3194. 

  3194. 	
    3195. 

  3195. 	CONF = config
    3196. 

  3196. 	target = CONF['target']
    3197. 

  3197. 	TAGS  = getTags(target)
    3198. 

  3198. 	rules = getRules(target)
    3199. 

  3199. 	regex = getRegexes()
    3200. 

  3200. 	TARGET = target    # save for buggy functions that need global
    3201. 

  3201. 	
    3202. 

  3202. 	BLOCK = BlockMaster()
    3203. 

  3203. 	MASK  =  MaskMaster()
    3204. 

  3204. 	TITLE = TitleMaster()
    3205. 

  3205. 	
    3206. 

  3206. 	ret = []
    3207. 

  3207. 	f_lastwasblank = 0
    3208. 

  3208. 	
    3209. 

  3209. 	# if TOC is a header tag, add it
    3210. 

  3210. 	if CONF['toc'] and TAGS['TOC']:
    3211. 

  3211. 		ret.append(TAGS['TOC']+'\n')
    3212. 

  3212. 	
    3213. 

  3213. 	# no forced indent for verbatim block when using CSS
    3214. 

  3214. 	if target in ('html','xhtml') and CONF['css-suggar']:
    3215. 

  3215. 		rules['indentverbblock'] = 0
    3216. 

  3216. 	
    3217. 

  3217. 	# let's mark it up!
    3218. 

  3218. 	linenr = firstlinenr-1
    3219. 

  3219. 	lineref = 0
    3220. 

  3220. 	while lineref < len(bodylines):
    3221. 

  3221. 		# defaults
    3222. 

  3222. 		MASK.reset()
    3223. 

  3223. 		results_box = ''
    3224. 

  3224. 		
    3225. 

  3225. 		untouchedline = bodylines[lineref]
    3226. 

  3226. 		line = re.sub('[\n\r]+$','',untouchedline)   # del line break
    3227. 

  3227. 		
    3228. 

  3228. 		# apply PreProc rules
    3229. 

  3229. 		if CONF['preproc']:
    3230. 

  3230. 			errmsg = _('Invalid PreProc filter regex')
    3231. 

  3231. 			for patt,repl in CONF['preproc']:
    3232. 

  3232. 				try   : line = re.sub(patt, repl, line)
    3233. 

  3233. 				except: Error("%s: '%s'"% (errmsg,patt))
    3234. 

  3234. 		
    3235. 

  3235. 		line = maskEscapeChar(line)                  # protect \ char
    3236. 

  3236. 		linenr  = linenr  +1
    3237. 

  3237. 		lineref = lineref +1
    3238. 

  3238. 		
    3239. 

  3239. 		Debug(repr(line), 3, linenr)  # heavy debug: show each line
    3240. 

  3240. 		
    3241. 

  3241. 		# any NOT table line (or comment), closes an open table
    3242. 

  3242. 		if ( BLOCK.isblock('table') or
    3243. 

  3243. 		      ( BLOCK.isblock('verb') and
    3244. 

  3244. 		        BLOCK.prop('mapped') == 'table'
    3245. 

  3245. 		       )
    3246. 

  3246. 		    ) \
    3247. 

  3247. 		   and not regex['table'].search(line) \
    3248. 

  3248. 		   and not regex['comment'].search(line):
    3249. 

  3249. 			ret.extend(BLOCK.blockout())
    3250. 

  3250. 		
    3251. 

  3251. 		# any NOT quote line (or comment) closes all open quotes
    3252. 

  3252. 		if BLOCK.isblock('quote') \
    3253. 

  3253. 		   and not regex['quote'].search(line) \
    3254. 

  3254. 		   and not regex['comment'].search(line):
    3255. 

  3255. 			while BLOCK.isblock('quote'):
    3256. 

  3256. 				ret.extend(BLOCK.blockout())
    3257. 

  3257. 		
    3258. 

  3258. 		
    3259. 

  3259. 		#-------------------------[ Raw Text ]----------------------
    3260. 

  3260. 		
    3261. 

  3261. 		# we're already on a raw block
    3262. 

  3262. 		if BLOCK.block() == 'raw':
    3263. 

  3263. 		
    3264. 

  3264. 			# closing raw
    3265. 

  3265. 			if regex['blockRawClose'].search(line):
    3266. 

  3266. 				ret.extend(BLOCK.blockout())
    3267. 

  3267. 				continue
    3268. 

  3268. 			
    3269. 

  3269. 			# normal raw-inside line
    3270. 

  3270. 			BLOCK.holdadd(line)
    3271. 

  3271. 			continue
    3272. 

  3272. 		
    3273. 

  3273. 		# detecting raw block init
    3274. 

  3274. 		if regex['blockRawOpen'].search(line):
    3275. 

  3275. 			ret.extend(BLOCK.blockin('raw'))
    3276. 

  3276. 			continue
    3277. 

  3277. 		
    3278. 

  3278. 		# one line verb-formatted text
    3279. 

  3279. 		if regex['1lineRaw'].search(line):
    3280. 

  3280. 			ret.extend(BLOCK.blockin('raw'))
    3281. 

  3281. 			line = regex['1lineRaw'].sub('',line)
    3282. 

  3282. 			BLOCK.holdadd(line)
    3283. 

  3283. 			ret.extend(BLOCK.blockout())
    3284. 

  3284. 			continue
    3285. 

  3285. 		
    3286. 

  3286. 		#-----------------[ Verbatim (PRE-formatted) ]--------------
    3287. 

  3287. 		
    3288. 

  3288. 		#TIP we'll never support beautifiers inside verbatim
    3289. 

  3289. 		
    3290. 

  3290. 		# we're already on a verb block
    3291. 

  3291. 		if BLOCK.block() == 'verb':
    3292. 

  3292. 			
    3293. 

  3293. 			# closing verb
    3294. 

  3294. 			if regex['blockVerbClose'].search(line):
    3295. 

  3295. 				ret.extend(BLOCK.blockout())
    3296. 

  3296. 				continue
    3297. 

  3297. 			
    3298. 

  3298. 			# normal verb-inside line
    3299. 

  3299. 			BLOCK.holdadd(line)
    3300. 

  3300. 			continue
    3301. 

  3301. 		
    3302. 

  3302. 		# detecting verb block init
    3303. 

  3303. 		if regex['blockVerbOpen'].search(line):
    3304. 

  3304. 			ret.extend(BLOCK.blockin('verb'))
    3305. 

  3305. 			f_lastwasblank = 0
    3306. 

  3306. 			continue
    3307. 

  3307. 		
    3308. 

  3308. 		# one line verb-formatted text
    3309. 

  3309. 		if regex['1lineVerb'].search(line):
    3310. 

  3310. 			ret.extend(BLOCK.blockin('verb'))
    3311. 

  3311. 			line = regex['1lineVerb'].sub('',line)
    3312. 

  3312. 			BLOCK.holdadd(line)
    3313. 

  3313. 			ret.extend(BLOCK.blockout())
    3314. 

  3314. 			f_lastwasblank = 0
    3315. 

  3315. 			continue
    3316. 

  3316. 		
    3317. 

  3317. 		# tables are mapped to verb when target is not table-aware
    3318. 

  3318. 		if not rules['tableable'] and regex['table'].search(line):
    3319. 

  3319. 			if not BLOCK.isblock('verb'):
    3320. 

  3320. 				ret.extend(BLOCK.blockin('verb'))
    3321. 

  3321. 				BLOCK.propset('mapped', 'table')
    3322. 

  3322. 				BLOCK.holdadd(line)
    3323. 

  3323. 				continue
    3324. 

  3324. 		
    3325. 

  3325. 		#---------------------[ blank lines ]-----------------------
    3326. 

  3326. 		
    3327. 

  3327. 		if regex['blankline'].search(line):
    3328. 

  3328. 			
    3329. 

  3329. 			# close open paragraph
    3330. 

  3330. 			if BLOCK.isblock('para'):
    3331. 

  3331. 				ret.extend(BLOCK.blockout())
    3332. 

  3332. 				f_lastwasblank = 1
    3333. 

  3333. 				continue
    3334. 

  3334. 			
    3335. 

  3335. 			# close all open quotes
    3336. 

  3336. 			while BLOCK.isblock('quote'):
    3337. 

  3337. 				ret.extend(BLOCK.blockout())
    3338. 

  3338. 			
    3339. 

  3339. 			# closing all open lists
    3340. 

  3340. 			if f_lastwasblank:          # 2nd consecutive blank
    3341. 

  3341. 				if BLOCK.block()[-4:] == 'list':
    3342. 

  3342. 					BLOCK.holdaddsub('')   # helps parser
    3343. 

  3343. 				while BLOCK.depth:  # closes list (if any)
    3344. 

  3344. 					ret.extend(BLOCK.blockout())
    3345. 

  3345. 				continue            # ignore consecutive blanks
    3346. 

  3346. 			
    3347. 

  3347. 			# paragraph (if any) is wanted inside lists also
    3348. 

  3348. 			if BLOCK.block()[-4:] == 'list':
    3349. 

  3349. 				BLOCK.holdaddsub('')
    3350. 

  3350. 			else:
    3351. 

  3351. 				# html: show blank line (needs tag)
    3352. 

  3352. 				if target in ['html','xhtml']:
    3353. 

  3353. 					ret.append(TAGS['paragraphOpen']+\
    3354. 

  3354. 					           TAGS['paragraphClose'])
    3355. 

  3355. 				# otherwise we just show a blank line
    3356. 

  3356. 				else:
    3357. 

  3357. 					ret.append('')
    3358. 

  3358. 			
    3359. 

  3359. 			f_lastwasblank = 1
    3360. 

  3360. 			continue
    3361. 

  3361. 		
    3362. 

  3362. 		
    3363. 

  3363. 		#---------------------[ special ]---------------------------
    3364. 

  3364. 		
    3365. 

  3365. 		if regex['special'].search(line):
    3366. 

  3366. 			# include command
    3367. 

  3367. 			targ, key, val = ConfigLines().parse_line(
    3368. 

  3368. 			                   line, 'include', target)
    3369. 

  3369. 			if key:
    3370. 

  3370. 				Debug("Found config '%s', value '%s'"%(
    3371. 

  3371. 				       key,val),1,linenr)
    3372. 

  3372. 				
    3373. 

  3373. 				incpath = os.path.dirname(CONF['sourcefile'])
    3374. 

  3374. 				incfile = val
    3375. 

  3375. 				err = _('A file cannot include itself (loop!)')
    3376. 

  3376. 				if CONF['sourcefile'] == incfile:
    3377. 

  3377. 					Error("%s: %s"%(err,incfile))
    3378. 

  3378. 				inctype, inclines = get_include_contents(
    3379. 

  3379. 				                      incfile, incpath)
    3380. 

  3380. 				# verb, raw and passthru are easy
    3381. 

  3381. 				if inctype != 't2t':
    3382. 

  3382. 					ret.extend(BLOCK.blockin(inctype))
    3383. 

  3383. 					BLOCK.holdextend(inclines)
    3384. 

  3384. 					ret.extend(BLOCK.blockout())
    3385. 

  3385. 				else:
    3386. 

  3386. 					# insert include lines into body
    3387. 

  3387. 					#TODO del %!include command call
    3388. 

  3388. 					#TODO include maxdepth limit
    3389. 

  3389. 					bodylines = bodylines[:lineref] \
    3390. 

  3390. 					           +inclines \
    3391. 

  3391. 					           +bodylines[lineref:]
    3392. 

  3392. 				continue
    3393. 

  3393. 			else:
    3394. 

  3394. 				Debug('Bogus Special Line',1,linenr)
    3395. 

  3395. 		
    3396. 

  3396. 		#---------------------[ comments ]--------------------------
    3397. 

  3397. 		
    3398. 

  3398. 		# just skip them (if not macro or config)
    3399. 

  3399. 		if regex['comment'].search(line) and not \
    3400. 

  3400. 		   regex['date'].match(line):
    3401. 

  3401. 			continue
    3402. 

  3402. 		
    3403. 

  3403. 		# valid line, reset blank status
    3404. 

  3404. 		f_lastwasblank = 0
    3405. 

  3405. 		
    3406. 

  3406. 		#---------------------[ Horizontal Bar ]--------------------
    3407. 

  3407. 		
    3408. 

  3408. 		if regex['bar'].search(line):
    3409. 

  3409. 			
    3410. 

  3410. 			# a bar closes a paragraph
    3411. 

  3411. 			if BLOCK.isblock('para'):
    3412. 

  3412. 				ret.extend(BLOCK.blockout())
    3413. 

  3413. 			
    3414. 

  3414. 			# we need to close all opened quote blocks
    3415. 

  3415. 			# if bar isn't allowed inside or if not a quote line
    3416. 

  3416. 			if BLOCK.isblock('quote'):
    3417. 

  3417. 				if not rules['barinsidequote'] or \
    3418. 

  3418. 				   not regex['quote'].search(line):
    3419. 

  3419. 					while BLOCK.isblock('quote'):
    3420. 

  3420. 						ret.extend(BLOCK.blockout())
    3421. 

  3421. 			
    3422. 

  3422. 			# quote + bar: continue processing for quoting
    3423. 

  3423. 			if rules['barinsidequote'] and \
    3424. 

  3424. 			   regex['quote'].search(line):
    3425. 

  3425. 				pass
    3426. 

  3426. 			
    3427. 

  3427. 			# just quote: save tagged line and we're done
    3428. 

  3428. 			else:
    3429. 

  3429. 				line = get_tagged_bar(line)
    3430. 

  3430. 				if BLOCK.block()[-4:] == 'list':
    3431. 

  3431. 					BLOCK.holdaddsub(line)
    3432. 

  3432. 				elif BLOCK.block():
    3433. 

  3433. 					BLOCK.holdadd(line)
    3434. 

  3434. 				else:
    3435. 

  3435. 					ret.append(line)
    3436. 

  3436. 				continue
    3437. 

  3437. 		
    3438. 

  3438. 		#---------------------[ Title ]-----------------------------
    3439. 

  3439. 		
    3440. 

  3440. 		#TODO set next blank and set f_lastwasblank or f_lasttitle
    3441. 

  3441. 		if (regex['title'].search(line) or
    3442. 

  3442. 		    regex['numtitle'].search(line)) and \
    3443. 

  3443. 		    BLOCK.block()[-4:] != 'list':
    3444. 

  3444. 			
    3445. 

  3445. 			# a title closes a paragraph
    3446. 

  3446. 			if BLOCK.isblock('para'):
    3447. 

  3447. 				ret.extend(BLOCK.blockout())
    3448. 

  3448. 			
    3449. 

  3449. 			TITLE.add(line)
    3450. 

  3450. 			ret.extend(TITLE.get())
    3451. 

  3451. 			
    3452. 

  3452. 			f_lastwasblank = 1
    3453. 

  3453. 			continue
    3454. 

  3454. 		
    3455. 

  3455. 		#---------------------[ apply masks ]-----------------------
    3456. 

  3456. 		
    3457. 

  3457. 		line = MASK.mask(line)
    3458. 

  3458. 		
    3459. 

  3459. 		#XXX from here, only block-inside lines will pass
    3460. 

  3460. 		
    3461. 

  3461. 		#---------------------[ Quote ]-----------------------------
    3462. 

  3462. 		
    3463. 

  3463. 		if regex['quote'].search(line):
    3464. 

  3464. 			
    3465. 

  3465. 			# store number of leading TABS
    3466. 

  3466. 			quotedepth = len(regex['quote'].search(line).group(0))
    3467. 

  3467. 			
    3468. 

  3468. 			# SGML doesn't support nested quotes
    3469. 

  3469. 			if rules['quotenotnested']: quotedepth = 1
    3470. 

  3470. 			
    3471. 

  3471. 			# new quote
    3472. 

  3472. 			if not BLOCK.isblock('quote'):
    3473. 

  3473. 				ret.extend(BLOCK.blockin('quote'))
    3474. 

  3474. 			
    3475. 

  3475. 			# new subquotes
    3476. 

  3476. 			while BLOCK.depth < quotedepth:
    3477. 

  3477. 				BLOCK.blockin('quote')
    3478. 

  3478. 			
    3479. 

  3479. 			# closing quotes
    3480. 

  3480. 			while quotedepth < BLOCK.depth:
    3481. 

  3481. 				ret.extend(BLOCK.blockout())
    3482. 

  3482. 		
    3483. 

  3483. 		#---------------------[ Lists ]-----------------------------
    3484. 

  3484. 		
    3485. 

  3485. 		if   regex['list'].search(line) or \
    3486. 

  3486. 		  regex['numlist'].search(line) or \
    3487. 

  3487. 		  regex['deflist'].search(line):
    3488. 

  3488. 			
    3489. 

  3489. 			listindent = BLOCK.prop('indent')
    3490. 

  3490. 			listids = string.join(LISTNAMES.keys(), '')
    3491. 

  3491. 			m = re.match('^( *)([%s]) '%listids, line)
    3492. 

  3492. 			listitemindent = m.group(1)
    3493. 

  3493. 			listtype = m.group(2)
    3494. 

  3494. 			listname = LISTNAMES[listtype]
    3495. 

  3495. 			results_box = BLOCK.holdadd
    3496. 

  3496. 			
    3497. 

  3497. 			# del list ID (and separate term from definition)
    3498. 

  3498. 			if listname == 'deflist':
    3499. 

  3499. 				term = parse_deflist_term(line)
    3500. 

  3500. 				line = regex['deflist'].sub(term+SEPARATOR,line)
    3501. 

  3501. 			else:
    3502. 

  3502. 				line = regex[listname].sub(SEPARATOR,line)
    3503. 

  3503. 			
    3504. 

  3504. 			# don't cross depth limit
    3505. 

  3505. 			maxdepth = rules['listmaxdepth']
    3506. 

  3506. 			if maxdepth and BLOCK.depth == maxdepth:
    3507. 

  3507. 				if len(listitemindent) > len(listindent):
    3508. 

  3508. 					listitemindent = listindent
    3509. 

  3509. 			
    3510. 

  3510. 			# open mother list or sublist
    3511. 

  3511. 			if BLOCK.block()[-4:] != 'list' or \
    3512. 

  3512. 			   len(listitemindent) > len(listindent):
    3513. 

  3513. 				ret.extend(BLOCK.blockin(listname))
    3514. 

  3514. 				BLOCK.propset('indent',listitemindent)
    3515. 

  3515. 			
    3516. 

  3516. 			# closing sublists
    3517. 

  3517. 			while len(listitemindent) < len(BLOCK.prop('indent')):
    3518. 

  3518. 				ret.extend(BLOCK.blockout())
    3519. 

  3519. 		
    3520. 

  3520. 		#---------------------[ Table ]-----------------------------
    3521. 

  3521. 		
    3522. 

  3522. 		#TODO escape undesired format inside table
    3523. 

  3523. 		#TODO add pm6 target
    3524. 

  3524. 		if regex['table'].search(line):
    3525. 

  3525. 			
    3526. 

  3526. 			if not BLOCK.isblock('table'):   # first table line!
    3527. 

  3527. 				ret.extend(BLOCK.blockin('table'))
    3528. 

  3528. 				BLOCK.tableparser.__init__(line)
    3529. 

  3529. 			
    3530. 

  3530. 			tablerow = TableMaster().parse_row(line)
    3531. 

  3531. 			BLOCK.tableparser.add_row(tablerow)     # save config
    3532. 

  3532. 			
    3533. 

  3533. 			# maintain line to unmask and inlines
    3534. 

  3534. 			line = string.join(tablerow['cells'], SEPARATOR)
    3535. 

  3535. 		
    3536. 

  3536. 		#---------------------[ Paragraph ]-------------------------
    3537. 

  3537. 		
    3538. 

  3538. 		if not BLOCK.block(): # new para!
    3539. 

  3539. 			ret.extend(BLOCK.blockin('para'))
    3540. 

  3540. 		
    3541. 

  3541. 		
    3542. 

  3542. 		############################################################
    3543. 

  3543. 		############################################################
    3544. 

  3544. 		############################################################
    3545. 

  3545. 		
    3546. 

  3546. 		
    3547. 

  3547. 		#---------------------[ Final Parses ]----------------------
    3548. 

  3548. 		
    3549. 

  3549. 		# the target-specific special char escapes for body lines
    3550. 

  3550. 		line = doEscape(target,line)
    3551. 

  3551. 		
    3552. 

  3552. 		line = add_inline_tags(line)
    3553. 

  3553. 		line = MASK.undo(line)
    3554. 

  3554. 		
    3555. 

  3555. 		
    3556. 

  3556. 		#---------------------[ Hold or Return? ]-------------------
    3557. 

  3557. 		
    3558. 

  3558. 		### now we must choose here to put the parsed line
    3559. 

  3559. 		#
    3560. 

  3560. 		if not results_box:
    3561. 

  3561. 			# list item extra lines
    3562. 

  3562. 			if BLOCK.block()[-4:] == 'list':
    3563. 

  3563. 				results_box = BLOCK.holdaddsub
    3564. 

  3564. 			# other blocks
    3565. 

  3565. 			elif BLOCK.block():
    3566. 

  3566. 				results_box = BLOCK.holdadd
    3567. 

  3567. 			# no blocks
    3568. 

  3568. 			else:
    3569. 

  3569. 				line = doFinalEscape(target, line)
    3570. 

  3570. 				results_box = ret.append
    3571. 

  3571. 		
    3572. 

  3572. 		results_box(line)
    3573. 

  3573. 	
    3574. 

  3574. 	# EOF: close any open para/verb/lists/table/quotes
    3575. 

  3575. 	Debug('EOF',2)
    3576. 

  3576. 	while BLOCK.block():
    3577. 

  3577. 		ret.extend(BLOCK.blockout())
    3578. 

  3578. 	
    3579. 

  3579. 	# if CSS, enclose body inside DIV
    3580. 

  3580. 	if TAGS['bodyOpenCss'] and config['css-suggar']:
    3581. 

  3581. 		ret.insert(0, TAGS['bodyOpenCss'])
    3582. 

  3582. 		ret.append(TAGS['bodyCloseCss'])
    3583. 

  3583. 	
    3584. 

  3584. 	if CONF['toc-only']: ret = []
    3585. 

  3585. 	marked_toc = TITLE.dump_marked_toc(CONF['toc-level'])
    3586. 

  3586. 	return ret, marked_toc
    3587. 

  3587. 

  3588. 

  3589. 

  3590. ##############################################################################
    3591. 

  3591. ################################### GUI ######################################
    3592. 

  3592. ##############################################################################
    3593. 

  3593. #
    3594. 

  3594. # tk help: http://python.org/topics/tkinter/
    3595. 

  3595. #          /usr/lib/python*/lib-tk/Tkinter.py
    3596. 

  3596. #
    3597. 

  3597. # grid table : row=0, column=0, columnspan=2, rowspan=2
    3598. 

  3598. # grid align : sticky='n,s,e,w' (North, South, East, West)
    3599. 

  3599. # pack place : side='top,bottom,right,left'
    3600. 

  3600. # pack fill  : fill='x,y,both,none', expand=1
    3601. 

  3601. # pack align : anchor='n,s,e,w' (North, South, East, West)
    3602. 

  3602. # padding    : padx=10, pady=10, ipadx=10, ipady=10 (internal)
    3603. 

  3603. # checkbox   : offvalue is return if the _user_ deselected the box
    3604. 

  3604. # label align: justify=left,right,center
    3605. 

  3605. 

  3606. def load_GUI_resources():
    3607. 

  3607. 	"Load all extra modules and methods used by GUI"
    3608. 

  3608. 	global askopenfilename, showinfo, showwarning, showerror, Tkinter
    3609. 

  3609. 	from tkFileDialog import askopenfilename
    3610. 

  3610. 	from tkMessageBox import showinfo,showwarning,showerror
    3611. 

  3611. 	import Tkinter
    3612. 

  3612. 

  3613. class Gui:
    3614. 

  3614. 	"Graphical Tk Interface"
    3615. 

  3615. 	def __init__(self, conf={}):
    3616. 

  3616. 		self.root = Tkinter.Tk()    # mother window, come to butthead
    3617. 

  3617. 		self.root.title(my_name)    # window title bar text
    3618. 

  3618. 		self.window = self.root     # variable "focus" for inclusion
    3619. 

  3619. 		self.row = 0                # row count for grid()
    3620. 

  3620. 		
    3621. 

  3621. 		self.action_lenght = 150    # left column lenght (pixel)
    3622. 

  3622. 		self.frame_margin  = 10     # frame margin size  (pixel)
    3623. 

  3623. 		self.frame_border  = 6      # frame border size  (pixel)
    3624. 

  3624. 		
    3625. 

  3625. 		# the default Gui colors, can be changed by %!guicolors
    3626. 

  3626. 		self.dft_gui_colors = ['blue','white','lightblue','black']
    3627. 

  3627. 		self.gui_colors = []
    3628. 

  3628. 		self.bg1 = self.fg1 = self.bg2 = self.fg2 = ''
    3629. 

  3629. 		
    3630. 

  3630. 		# on Tk, vars need to be set/get using setvar()/get()
    3631. 

  3631. 		self.infile  = self.setvar('')
    3632. 

  3632. 		self.target  = self.setvar('')
    3633. 

  3633. 		self.target_name = self.setvar('')
    3634. 

  3634. 		
    3635. 

  3635. 		# the checks appearance order
    3636. 

  3636. 		self.checks  = [
    3637. 

  3637. 		  'headers','enum-title','toc','mask-email',
    3638. 

  3638. 		  'toc-only','stdout']
    3639. 

  3639. 		
    3640. 

  3640. 		# creating variables for all checks
    3641. 

  3641. 		for check in self.checks:
    3642. 

  3642. 			setattr(self, 'f_'+check, self.setvar(''))
    3643. 

  3643. 		
    3644. 

  3644. 		# load RC config
    3645. 

  3645. 		self.conf = {}
    3646. 

  3646. 		if conf: self.load_config(conf)
    3647. 

  3647. 	
    3648. 

  3648. 	def load_config(self, conf):
    3649. 

  3649. 		self.conf = conf
    3650. 

  3650. 		self.gui_colors = conf.get('guicolors') or self.dft_gui_colors
    3651. 

  3651. 		self.bg1, self.fg1, self.bg2, self.fg2 = self.gui_colors
    3652. 

  3652. 		self.root.config(bd=15,bg=self.bg1)
    3653. 

  3653. 	
    3654. 

  3654. 	### config as dic for python 1.5 compat (**opts don't work :( )
    3655. 

  3655. 	def entry(self, **opts): return Tkinter.Entry(self.window, opts)
    3656. 

  3656. 	def label(self, txt='', bg=None, **opts):
    3657. 

  3657. 		opts.update({'text':txt,'bg':bg or self.bg1})
    3658. 

  3658. 		return Tkinter.Label(self.window, opts)
    3659. 

  3659. 	def button(self,name,cmd,**opts):
    3660. 

  3660. 		opts.update({'text':name,'command':cmd})
    3661. 

  3661. 		return Tkinter.Button(self.window, opts)
    3662. 

  3662. 	def check(self,name,checked=0,**opts):
    3663. 

  3663. 		bg, fg = self.bg2, self.fg2
    3664. 

  3664. 		opts.update({
    3665. 

  3665. 		  'text':name, 'onvalue':1, 'offvalue':0,
    3666. 

  3666. 		  'activeforeground':fg, 'fg':fg,
    3667. 

  3667. 		  'activebackground':bg, 'bg':bg,
    3668. 

  3668. 		  'highlightbackground':bg, 'anchor':'w'
    3669. 

  3669. 		})
    3670. 

  3670. 		chk = Tkinter.Checkbutton(self.window, opts)
    3671. 

  3671. 		if checked: chk.select()
    3672. 

  3672. 		chk.grid(columnspan=2, sticky='w', padx=0)
    3673. 

  3673. 	def menu(self,sel,items):
    3674. 

  3674. 		return apply(Tkinter.OptionMenu,(self.window,sel)+tuple(items))
    3675. 

  3675. 	
    3676. 

  3676. 	# handy auxiliar functions
    3677. 

  3677. 	def action(self, txt):
    3678. 

  3678. 		self.label(txt, fg=self.fg1, bg=self.bg1,
    3679. 

  3679. 		     wraplength=self.action_lenght).grid(column=0,row=self.row)
    3680. 

  3680. 	def frame_open(self):
    3681. 

  3681. 		self.window = Tkinter.Frame(self.root,bg=self.bg2,
    3682. 

  3682. 		     borderwidth=self.frame_border)
    3683. 

  3683. 	def frame_close(self):
    3684. 

  3684. 		self.window.grid(column=1, row=self.row, sticky='w',
    3685. 

  3685. 		     padx=self.frame_margin)
    3686. 

  3686. 		self.window = self.root
    3687. 

  3687. 		self.label('').grid()
    3688. 

  3688. 		self.row = self.row + 2   # update row count
    3689. 

  3689. 	def target_name2key(self):
    3690. 

  3690. 		name = self.target_name.get()
    3691. 

  3691. 		target = filter(lambda x: TARGET_NAMES[x] == name, TARGETS)
    3692. 

  3692. 		try   : key = target[0]
    3693. 

  3693. 		except: key = ''
    3694. 

  3694. 		self.target = self.setvar(key)
    3695. 

  3695. 	def target_key2name(self):
    3696. 

  3696. 		key = self.target.get()
    3697. 

  3697. 		name = TARGET_NAMES.get(key) or key
    3698. 

  3698. 		self.target_name = self.setvar(name)
    3699. 

  3699. 	
    3700. 

  3700. 	def exit(self): self.root.destroy()
    3701. 

  3701. 	def setvar(self, val): z = Tkinter.StringVar() ; z.set(val) ; return z
    3702. 

  3702. 	
    3703. 

  3703. 	def askfile(self):
    3704. 

  3704. 		ftypes= [(_('txt2tags files'),('*.t2t','*.txt')),
    3705. 

  3705. 		         (_('All files'),'*')]
    3706. 

  3706. 		newfile = askopenfilename(filetypes=ftypes)
    3707. 

  3707. 		if newfile:
    3708. 

  3708. 			self.infile.set(newfile)
    3709. 

  3709. 			newconf = process_source_file(newfile)[0]
    3710. 

  3710. 			newconf = ConfigMaster().sanity(newconf, gui=1)
    3711. 

  3711. 			# restate all checkboxes after file selection
    3712. 

  3712. 			#TODO how to make a refresh without killing it?
    3713. 

  3713. 			self.root.destroy()
    3714. 

  3714. 			self.__init__(newconf)
    3715. 

  3715. 			self.mainwindow()
    3716. 

  3716. 	
    3717. 

  3717. 	def scrollwindow(self, txt='no text!', title=''):
    3718. 

  3718. 		# create components
    3719. 

  3719. 		win    = Tkinter.Toplevel() ; win.title(title)
    3720. 

  3720. 		frame  = Tkinter.Frame(win)
    3721. 

  3721. 		scroll = Tkinter.Scrollbar(frame)
    3722. 

  3722. 		text   = Tkinter.Text(frame,yscrollcommand=scroll.set)
    3723. 

  3723. 		button = Tkinter.Button(win)
    3724. 

  3724. 		# config
    3725. 

  3725. 		text.insert(Tkinter.END, string.join(txt,'\n'))
    3726. 

  3726. 		scroll.config(command=text.yview)
    3727. 

  3727. 		button.config(text=_('Close'), command=win.destroy)
    3728. 

  3728. 		button.focus_set()
    3729. 

  3729. 		# packing
    3730. 

  3730. 		text.pack(side='left',fill='both')
    3731. 

  3731. 		scroll.pack(side='right',fill='y')
    3732. 

  3732. 		frame.pack()
    3733. 

  3733. 		button.pack(ipadx=30)
    3734. 

  3734. 	
    3735. 

  3735. 	def runprogram(self):
    3736. 

  3736. 		global CMDLINE_RAW
    3737. 

  3737. 		# prepare
    3738. 

  3738. 		self.target_name2key()
    3739. 

  3739. 		infile, target = self.infile.get(), self.target.get()
    3740. 

  3740. 		# sanity
    3741. 

  3741. 		if not target:
    3742. 

  3742. 			showwarning(my_name,_("You must select a target type!"))
    3743. 

  3743. 			return
    3744. 

  3744. 		if not infile:
    3745. 

  3745. 			showwarning(my_name,
    3746. 

  3746. 			   _("You must provide the source file location!"))
    3747. 

  3747. 			return
    3748. 

  3748. 		# compose cmdline
    3749. 

  3749. 		guiflags = []
    3750. 

  3750. 		real_cmdline_conf = ConfigMaster(CMDLINE_RAW).parse()
    3751. 

  3751. 		if real_cmdline_conf.has_key('infile'):
    3752. 

  3752. 			del real_cmdline_conf['infile']
    3753. 

  3753. 		if real_cmdline_conf.has_key('target'):
    3754. 

  3754. 			del real_cmdline_conf['target']
    3755. 

  3755. 		real_cmdline = CommandLine().compose_cmdline(real_cmdline_conf)
    3756. 

  3756. 		default_outfile = ConfigMaster().get_outfile_name(
    3757. 

  3757. 		     {'sourcefile':infile, 'outfile':'', 'target':target})
    3758. 

  3758. 		for opt in self.checks:
    3759. 

  3759. 			val = int(getattr(self, 'f_%s'%opt).get() or "0")
    3760. 

  3760. 			if opt == 'stdout': opt = 'outfile'
    3761. 

  3761. 			on_config  = self.conf.get(opt) or 0
    3762. 

  3762. 			on_cmdline = real_cmdline_conf.get(opt) or 0
    3763. 

  3763. 			if opt == 'outfile':
    3764. 

  3764. 				if on_config  == STDOUT: on_config = 1
    3765. 

  3765. 				else: on_config = 0
    3766. 

  3766. 				if on_cmdline == STDOUT: on_cmdline = 1
    3767. 

  3767. 				else: on_cmdline = 0
    3768. 

  3768. 			if val != on_config or (
    3769. 

  3769. 			  val == on_config == on_cmdline and
    3770. 

  3770. 			  real_cmdline_conf.has_key(opt)):
    3771. 

  3771. 				if val:
    3772. 

  3772. 					# was not set, but user selected on GUI
    3773. 

  3773. 					Debug("user turned  ON: %s"%opt)
    3774. 

  3774. 					if opt == 'outfile': opt = '-o-'
    3775. 

  3775. 					else: opt = '--%s'%opt
    3776. 

  3776. 				else:
    3777. 

  3777. 					# was set, but user deselected on GUI
    3778. 

  3778. 					Debug("user turned OFF: %s"%opt)
    3779. 

  3779. 					if opt == 'outfile':
    3780. 

  3780. 						opt = "-o%s"%default_outfile
    3781. 

  3781. 					else: opt = '--no-%s'%opt
    3782. 

  3782. 				guiflags.append(opt)
    3783. 

  3783. 		cmdline = [my_name, '-t', target] +real_cmdline \
    3784. 

  3784. 		          +guiflags +[infile]
    3785. 

  3785. 		Debug('Gui/Tk cmdline: %s'%cmdline,5)
    3786. 

  3786. 		# run!
    3787. 

  3787. 		cmdline_raw_orig = CMDLINE_RAW
    3788. 

  3788. 		try:
    3789. 

  3789. 			# fake the GUI cmdline as the real one, and parse file
    3790. 

  3790. 			CMDLINE_RAW = CommandLine().get_raw_config(cmdline[1:])
    3791. 

  3791. 			data = process_source_file(infile)
    3792. 

  3792. 			# on GUI, convert_* returns the data, not finish_him()
    3793. 

  3793. 			outlist, config = convert_this_files([data])
    3794. 

  3794. 			# on GUI and STDOUT, finish_him() returns the data
    3795. 

  3795. 			result = finish_him(outlist, config)
    3796. 

  3796. 			# show outlist in s a nice new window
    3797. 

  3797. 			if result:
    3798. 

  3798. 				outlist, config = result
    3799. 

  3799. 				title = _('%s: %s converted to %s')%(
    3800. 

  3800. 				  my_name, os.path.basename(infile),
    3801. 

  3801. 				  string.upper(config['target']))
    3802. 

  3802. 				self.scrollwindow(outlist, title)
    3803. 

  3803. 			# show the "file saved" message
    3804. 

  3804. 			else:
    3805. 

  3805. 				msg = "%s\n\n  %s\n%s\n\n  %s\n%s"%(
    3806. 

  3806. 				      _('Conversion done!'),
    3807. 

  3807. 				      _('FROM:'), infile,
    3808. 

  3808. 				      _('TO:'), config['outfile'])
    3809. 

  3809. 				showinfo(my_name, msg)
    3810. 

  3810. 		except ZeroDivisionError:   # common error, not quit
    3811. 

  3811. 			pass
    3812. 

  3812. 		except:                     # fatal error
    3813. 

  3813. 			ShowTraceback()
    3814. 

  3814. 			print _('Sorry! txt2tags-Tk Fatal Error.')
    3815. 

  3815. 			errmsg = '%s\n\n%s\n    %s'%(
    3816. 

  3816. 			  _('Unknown error occurred.'),
    3817. 

  3817. 			  _('Please send the Error Traceback to the author:'),
    3818. 

  3818. 			  my_email)
    3819. 

  3819. 			showerror(_('%s FATAL ERROR!')%my_name,errmsg)
    3820. 

  3820. 			self.exit()
    3821. 

  3821. 		CMDLINE_RAW = cmdline_raw_orig
    3822. 

  3822. 	
    3823. 

  3823. 	def mainwindow(self):
    3824. 

  3824. 		self.infile.set(self.conf.get('sourcefile') or '')
    3825. 

  3825. 		self.target.set(self.conf.get('target') or \
    3826. 

  3826. 		              _('-- select one --'))
    3827. 

  3827. 		outfile = self.conf.get('outfile')
    3828. 

  3828. 		if outfile == STDOUT:                  # map -o-
    3829. 

  3829. 			self.conf['stdout'] = 1
    3830. 

  3830. 		if self.conf.get('headers') == None:
    3831. 

  3831. 			self.conf['headers'] = 1       # map default
    3832. 

  3832. 		
    3833. 

  3833. 		action1 = _("Enter the source file location:")
    3834. 

  3834. 		action2 = _("Choose the target document type:")
    3835. 

  3835. 		action3 = _("Some options you may check:")
    3836. 

  3836. 		action4 = _("Some extra options:")
    3837. 

  3837. 		checks_txt = {
    3838. 

  3838. 		  'headers'   : _("Include headers on output"),
    3839. 

  3839. 		  'enum-title': _("Number titles (1, 1.1, 1.1.1, etc)"),
    3840. 

  3840. 		  'toc'       : _("Do TOC also (Table of Contents)"),
    3841. 

  3841. 		  'mask-email': _("Hide e-mails from SPAM robots"),
    3842. 

  3842. 		
    3843. 

  3843. 		  'toc-only'  : _("Just do TOC, nothing more"),
    3844. 

  3844. 		  'stdout'    : _("Dump to screen (Don't save target file)")
    3845. 

  3845. 		}
    3846. 

  3846. 		targets_menu = map(lambda x: TARGET_NAMES[x], TARGETS)
    3847. 

  3847. 		
    3848. 

  3848. 		# header
    3849. 

  3849. 		self.label("%s %s"%(string.upper(my_name), my_version),
    3850. 

  3850. 		     bg=self.bg2, fg=self.fg2).grid(columnspan=2, ipadx=10)
    3851. 

  3851. 		self.label(_("ONE source, MULTI targets")+'\n%s\n'%my_url,
    3852. 

  3852. 		     bg=self.bg1, fg=self.fg1).grid(columnspan=2)
    3853. 

  3853. 		self.row = 2
    3854. 

  3854. 		# choose input file
    3855. 

  3855. 		self.action(action1) ; self.frame_open()
    3856. 

  3856. 		e_infile = self.entry(textvariable=self.infile,width=25)
    3857. 

  3857. 		e_infile.grid(row=self.row, column=0, sticky='e')
    3858. 

  3858. 		if not self.infile.get(): e_infile.focus_set()
    3859. 

  3859. 		self.button(_("Browse"), self.askfile).grid(
    3860. 

  3860. 		    row=self.row, column=1, sticky='w', padx=10)
    3861. 

  3861. 		# show outfile name, style and encoding (if any)
    3862. 

  3862. 		txt = ''
    3863. 

  3863. 		if outfile:
    3864. 

  3864. 			txt = outfile
    3865. 

  3865. 			if outfile == STDOUT: txt = _('<screen>')
    3866. 

  3866. 			l_output = self.label(_('Output: ')+txt,
    3867. 

  3867. 			                fg=self.fg2,bg=self.bg2)
    3868. 

  3868. 			l_output.grid(columnspan=2, sticky='w')
    3869. 

  3869. 		for setting in ['style','encoding']:
    3870. 

  3870. 			if self.conf.get(setting):
    3871. 

  3871. 				name = string.capitalize(setting)
    3872. 

  3872. 				val  = self.conf[setting]
    3873. 

  3873. 				self.label('%s: %s'%(name, val),
    3874. 

  3874. 				     fg=self.fg2, bg=self.bg2).grid(
    3875. 

  3875. 				     columnspan=2, sticky='w')
    3876. 

  3876. 		# choose target
    3877. 

  3877. 		self.frame_close() ; self.action(action2)
    3878. 

  3878. 		self.frame_open()
    3879. 

  3879. 		self.target_key2name()
    3880. 

  3880. 		self.menu(self.target_name, targets_menu).grid(
    3881. 

  3881. 		     columnspan=2, sticky='w')
    3882. 

  3882. 		# options checkboxes label
    3883. 

  3883. 		self.frame_close() ; self.action(action3)
    3884. 

  3884. 		self.frame_open()
    3885. 

  3885. 		# compose options check boxes, example:
    3886. 

  3886. 		# self.check(checks_txt['toc'],1,variable=self.f_toc)
    3887. 

  3887. 		for check in self.checks:
    3888. 

  3888. 			# extra options label
    3889. 

  3889. 			if check == 'toc-only':
    3890. 

  3890. 				self.frame_close() ; self.action(action4)
    3891. 

  3891. 				self.frame_open()
    3892. 

  3892. 			txt = checks_txt[check]
    3893. 

  3893. 			var = getattr(self, 'f_'+check)
    3894. 

  3894. 			checked = self.conf.get(check)
    3895. 

  3895. 			self.check(txt,checked,variable=var)
    3896. 

  3896. 		self.frame_close()
    3897. 

  3897. 		# spacer and buttons	
    3898. 

  3898. 		self.label('').grid() ; self.row = self.row + 1
    3899. 

  3899. 		b_quit = self.button(_("Quit"), self.exit)
    3900. 

  3900. 		b_quit.grid(row=self.row, column=0, sticky='w', padx=30)
    3901. 

  3901. 		b_conv = self.button(_("Convert!"), self.runprogram)
    3902. 

  3902. 		b_conv.grid(row=self.row, column=1, sticky='e', padx=30)
    3903. 

  3903. 		if self.target.get() and self.infile.get():
    3904. 

  3904. 			b_conv.focus_set()
    3905. 

  3905. 		
    3906. 

  3906. 		# as documentation told me
    3907. 

  3907. 		if sys.platform[:3] == 'win':
    3908. 

  3908. 			self.root.iconify()
    3909. 

  3909. 			self.root.update()
    3910. 

  3910. 			self.root.deiconify()
    3911. 

  3911. 		
    3912. 

  3912. 		self.root.mainloop()
    3913. 

  3913. 

  3914. 

  3915. ##############################################################################
    3916. 

  3916. ##############################################################################
    3917. 

  3917. 

  3918. def exec_command_line(user_cmdline=[]):
    3919. 

  3919. 	global CMDLINE_RAW, RC_RAW, DEBUG, VERBOSE, GUI, Error
    3920. 

  3920. 	
    3921. 

  3921. 	# extract command line data
    3922. 

  3922. 	cmdline_data = user_cmdline or sys.argv[1:]
    3923. 

  3923. 	CMDLINE_RAW = CommandLine().get_raw_config(cmdline_data)
    3924. 

  3924. 	cmdline_parsed = ConfigMaster(CMDLINE_RAW).parse()
    3925. 

  3925. 	DEBUG   = cmdline_parsed.get('debug'  ) or 0
    3926. 

  3926. 	VERBOSE = cmdline_parsed.get('verbose') or 0
    3927. 

  3927. 	GUI     = cmdline_parsed.get('gui'    ) or 0
    3928. 

  3928. 	infiles = cmdline_parsed.get('infile' ) or []
    3929. 

  3929. 	
    3930. 

  3930. 	Message(_("Txt2tags %s processing begins")%my_version,1)
    3931. 

  3931. 	
    3932. 

  3932. 	# the easy ones
    3933. 

  3933. 	if cmdline_parsed.get('help'   ): Quit(USAGE)
    3934. 

  3934. 	if cmdline_parsed.get('version'): Quit(VERSIONSTR)
    3935. 

  3935. 	
    3936. 

  3936. 	# multifile haters
    3937. 

  3937. 	if len(infiles) > 1:
    3938. 

  3938. 		errmsg=_("Option --%s can't be used with multiple input files")
    3939. 

  3939. 		for option in ['gui','dump-config']:
    3940. 

  3940. 			if cmdline_parsed.get(option):
    3941. 

  3941. 				Error(errmsg%option)
    3942. 

  3942. 	
    3943. 

  3943. 	Debug("system platform: %s"%sys.platform)
    3944. 

  3944. 	Debug("line break char: %s"%repr(LB))
    3945. 

  3945. 	Debug("command line: %s"%sys.argv)
    3946. 

  3946. 	Debug("command line raw config: %s"%CMDLINE_RAW,1)
    3947. 

  3947. 	
    3948. 

  3948. 	# extract RC file config
    3949. 

  3949. 	if cmdline_parsed.get('rc') == 0:
    3950. 

  3950. 		Message(_("Ignoring user configuration file"),1)
    3951. 

  3951. 	else:
    3952. 

  3952. 		rc_file = get_rc_path()
    3953. 

  3953. 		if rc_file:
    3954. 

  3954. 			Message(_("Loading user configuration file"),1)
    3955. 

  3955. 			RC_RAW = ConfigLines(file=rc_file).get_raw_config()
    3956. 

  3956. 		
    3957. 

  3957. 		Debug("rc file: %s"%rc_file)
    3958. 

  3958. 		Debug("rc file raw config: %s"%RC_RAW,1)
    3959. 

  3959. 	
    3960. 

  3960. 	# get all infiles config (if any)
    3961. 

  3961. 	infiles_config = get_infiles_config(infiles)
    3962. 

  3962. 	
    3963. 

  3963. 	# is GUI available?
    3964. 

  3964. 	# try to load and start GUI interface for --gui
    3965. 

  3965. 	# if program was called with no arguments, try GUI also
    3966. 

  3966. 	if GUI or not infiles:
    3967. 

  3967. 		try:
    3968. 

  3968. 			load_GUI_resources()
    3969. 

  3969. 			Debug("GUI resources OK (Tk module is installed)")
    3970. 

  3970. 			winbox = Gui()
    3971. 

  3971. 			Debug("GUI display OK")
    3972. 

  3972. 			GUI = 1
    3973. 

  3973. 		except:
    3974. 

  3974. 			Debug("GUI Error: no Tk module or no DISPLAY")
    3975. 

  3975. 			GUI = 0
    3976. 

  3976. 	
    3977. 

  3977. 	# user forced --gui, but it's not available
    3978. 

  3978. 	if cmdline_parsed.get('gui') and not GUI:
    3979. 

  3979. 		ShowTraceback()
    3980. 

  3980. 		Error("Sorry, I can't run my Graphical Interface - GUI\n"
    3981. 

  3981. 		      "- Check if Python Tcl/Tk module is installed (Tkinter)\n"
    3982. 

  3982. 		      "- Make sure you are in a graphical environment (like X)")
    3983. 

  3983. 	
    3984. 

  3984. 	# Okay, we will use GUI
    3985. 

  3985. 	if GUI:
    3986. 

  3986. 		Message(_("We are on GUI interface"),1)
    3987. 

  3987. 		
    3988. 

  3988. 		# redefine Error function to raise exception instead sys.exit()
    3989. 

  3989. 		def Error(msg):
    3990. 

  3990. 			showerror(_('txt2tags ERROR!'), msg)
    3991. 

  3991. 			raise ZeroDivisionError
    3992. 

  3992. 		
    3993. 

  3993. 		# if no input file, get RC+cmdline config, else full config
    3994. 

  3994. 		if not infiles:
    3995. 

  3995. 			gui_conf = ConfigMaster(RC_RAW+CMDLINE_RAW).parse()
    3996. 

  3996. 		else:
    3997. 

  3997. 			try   : gui_conf = infiles_config[0][0]
    3998. 

  3998. 			except: gui_conf = {}
    3999. 

  3999. 		
    4000. 

  4000. 		# sanity is needed to set outfile and other things
    4001. 

  4001. 		gui_conf = ConfigMaster().sanity(gui_conf, gui=1)
    4002. 

  4002. 		Debug("GUI config: %s"%gui_conf,5)
    4003. 

  4003. 		
    4004. 

  4004. 		# insert config and populate the nice window!
    4005. 

  4005. 		winbox.load_config(gui_conf)
    4006. 

  4006. 		winbox.mainwindow()
    4007. 

  4007. 	
    4008. 

  4008. 	# console mode rocks forever!
    4009. 

  4009. 	else:
    4010. 

  4010. 		Message(_("We are on Command Line interface"),1)
    4011. 

  4011. 		
    4012. 

  4012. 		# called with no arguments, show error
    4013. 

  4013. 		if not infiles: Error(_('Missing input file (try --help)'))
    4014. 

  4014. 		
    4015. 

  4015. 		convert_this_files(infiles_config)
    4016. 

  4016. 	
    4017. 

  4017. 	Message(_("Txt2tags finished sucessfuly"),1)
    4018. 

  4018. 	sys.exit(0)
    4019. 

  4019. 

  4020. if __name__ == '__main__':
    4021. 

  4021. 	exec_command_line()
    4022. 

  4022. 

  4023. 

  4024. # vim: ts=8
    4025. 

  4025.