FooBarWidget-mizuho 0.9.1 → 0.9.2

data/asciidoc/asciidoc.py

@@ -6,10 +6,10 @@ Copyright (C) 2002-2008 Stuart Rackham. Free use of this software is granted
 under the terms of the GNU General Public License (GPL).
 """
 
-import sys, os, re, time, traceback, tempfile, popen2, codecs, locale
+import sys, os, re, time, traceback, tempfile, subprocess, codecs, locale
 from types import *
 
-VERSION = '8.2.7'   # See CHANGLOG file for version history.
+VERSION = '8.3.1'   # See CHANGLOG file for version history.
 
 #---------------------------------------------------------------------------
 # Program onstants.
@@ -20,10 +20,10 @@ DEFAULT_DOCTYPE = 'article'
 # definition subs entry.
 SUBS_OPTIONS = ('specialcharacters','quotes','specialwords',
     'replacements', 'attributes','macros','callouts','normal','verbatim',
-    'none','passthroughs','replacements2')
+    'none','replacements2')
 # Default value for unspecified subs and presubs configuration file entries.
 SUBS_NORMAL = ('specialcharacters','quotes','attributes',
-    'specialwords','replacements','macros','passthroughs')
+    'specialwords','replacements','macros')
 SUBS_VERBATIM = ('specialcharacters','callouts')
 
 NAME_RE = r'(?u)[^\W\d][-\w]*'  # Valid section or attrbibute name.
@@ -33,32 +33,29 @@ NAME_RE = r'(?u)[^\W\d][-\w]*'  # Valid section or attrbibute name.
 # Utility functions and classes.
 #---------------------------------------------------------------------------
 
-class EAsciiDoc(Exception):
-    pass
+class EAsciiDoc(Exception): pass
 
-
-from UserDict import UserDict
-
-class OrderedDict(UserDict):
+class OrderedDict(dict):
     """
     Dictionary ordered by insertion order.
     Python Cookbook: Ordered Dictionary, Submitter: David Benjamin.
     http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/107747
     """
-    def __init__(self, d=None):
+    def __init__(self, d=None, **kwargs):
         self._keys = []
-        UserDict.__init__(self, d)
+        if d is None: d = kwargs
+        dict.__init__(self, d)
     def __delitem__(self, key):
-        UserDict.__delitem__(self, key)
+        dict.__delitem__(self, key)
         self._keys.remove(key)
     def __setitem__(self, key, item):
-        UserDict.__setitem__(self, key, item)
+        dict.__setitem__(self, key, item)
         if key not in self._keys: self._keys.append(key)
     def clear(self):
-        UserDict.clear(self)
+        dict.clear(self)
         self._keys = []
     def copy(self):
-        d = UserDict.copy(self)
+        d = dict.copy(self)
         d._keys = self._keys[:]
         return d
     def items(self):
@@ -74,17 +71,38 @@ class OrderedDict(UserDict):
         del self[key]
         return (key, val)
     def setdefault(self, key, failobj = None):
-        UserDict.setdefault(self, key, failobj)
+        dict.setdefault(self, key, failobj)
         if key not in self._keys: self._keys.append(key)
     def update(self, d=None, **kwargs):
         if d is None:
             d = kwargs
-        UserDict.update(self, d)
+        dict.update(self, d)
         for key in d.keys():
             if key not in self._keys: self._keys.append(key)
     def values(self):
         return map(self.get, self._keys)
 
+class AttrDict(dict):
+    """
+    Like a dictionary except values can be accessed as attributes i.e. obj.foo
+    can be used in addition to obj['foo'].
+    If an item is not present None is returned.
+    """
+    def __getattr__(self, key):
+        try: return self[key]
+        except KeyError, k: return None
+    def __setattr__(self, key, value):
+        self[key] = value
+    def __delattr__(self, key):
+        try: del self[key]
+        except KeyError, k: raise AttributeError, k
+    def __repr__(self):
+        return '<AttrDict ' + dict.__repr__(self) + '>'
+    def __getstate__(self):
+        return dict(self)
+    def __setstate__(self,value):
+        for k,v in value.items(): self[k]=v
+
 def print_stderr(line):
     sys.stderr.write(line+os.linesep)
 
@@ -96,25 +114,35 @@ def warning(msg,linenos=True):
     console(msg,'WARNING: ',linenos)
     document.has_warnings = True
 
-def deprecated(old, new, linenos=True):
-    console('%s: %s' % (old,new), 'DEPRECATED: ', linenos)
-
-def error(msg, cursor=None):
-    """Report fatal error but don't exit application, continue in the hope of
-    reporting all fatal errors finishing with a non-zero exit code."""
-    console(msg,'ERROR: ', cursor=cursor)
-    document.has_errors = True
+def deprecated(msg, linenos=True):
+    console(msg, 'DEPRECATED: ', linenos)
 
-def console(msg, prefix='', linenos=True, cursor=None):
-    """Print message to stderr. 'offset' is added to reported line number for
-    warnings emitted when reading ahead."""
-    s = prefix
+def message(msg, prefix='', linenos=True, cursor=None):
+    """
+    Return formatted message string. 'offset' is added to reported line number
+    for warnings emitted when reading ahead.
+    """
     if linenos and reader.cursor:
         if not cursor:
             cursor = reader.cursor
-        s = s + '%s: line %d: ' % (os.path.basename(cursor[0]),cursor[1])
-    s = s + msg
-    print_stderr(s)
+        prefix += '%s: line %d: ' % (os.path.basename(cursor[0]),cursor[1])
+    return prefix + msg
+
+def error(msg, cursor=None, halt=False):
+    """
+    Report fatal error.
+    If halt=True raise EAsciiDoc exception.
+    If halt=False don't exit application, continue in the hope of reporting all
+    fatal errors finishing with a non-zero exit code.
+    """
+    if halt:
+        raise EAsciiDoc, message(msg,linenos=False,cursor=cursor)
+    else:
+        console(msg,'ERROR: ',cursor=cursor)
+        document.has_errors = True
+
+def console(msg, prefix='', linenos=True, cursor=None):
+    print_stderr(message(msg,prefix,linenos,cursor))
 
 def file_in(fname, directory):
     """Return True if file fname resides inside directory."""
@@ -124,7 +152,7 @@ def file_in(fname, directory):
         directory = os.getcwd()
     else:
         assert os.path.isdir(directory)
-        directory = os.path.abspath(directory)
+        directory = os.path.realpath(directory)
     fname = os.path.realpath(fname)
     return os.path.commonprefix((directory, fname)) == directory
 
@@ -142,9 +170,11 @@ def is_safe_file(fname, directory=None):
         directory = '.'
     return not safe() or file_in(fname, directory)
 
-# Return file name which must reside in the parent file directory.
-# Return None if file is not found or not safe.
 def safe_filename(fname, parentdir):
+    """
+    Return file name which must reside in the parent file directory.
+    Return None if file is not found or not safe.
+    """
     if not os.path.isabs(fname):
         # Include files are relative to parent document
         # directory.
@@ -160,16 +190,6 @@ def safe_filename(fname, parentdir):
 def unsafe_error(msg):
     error('unsafe: '+msg)
 
-def syseval(cmd):
-    # Run shell command and return stdout.
-    child = os.popen(cmd)
-    data = child.read()
-    err = child.close()
-    if not err:
-        return data
-    else:
-        return ''
-
 def assign(dst,src):
     """Assign all attributes from 'src' object to 'dst' object."""
     for a,v in src.__dict__.items():
@@ -212,33 +232,50 @@ def validate(value,rule,errmsg):
         raise EAsciiDoc,errmsg
     return value
 
-def join_lines(lines):
-    """Return a list in which lines terminated with the backslash line
-    continuation character are joined."""
-    result = []
-    s = ''
-    continuation = False
-    for line in lines:
-        if line and line[-1] == '\\':
-            s = s + line[:-1]
-            continuation = True
-            continue
-        if continuation:
-            result.append(s+line)
-            s = ''
-            continuation = False
-        else:
-            result.append(line)
-    if continuation:
-        result.append(s)
-    return result
+def lstrip_list(s):
+    """
+    Return list with empty items from start of list removed.
+    """
+    for i in range(len(s)):
+        if s[i]: break
+    else:
+        return []
+    return s[i:]
+
+def rstrip_list(s):
+    """
+    Return list with empty items from end of list removed.
+    """
+    for i in range(len(s)-1,-1,-1):
+        if s[i]: break
+    else:
+        return []
+    return s[:i+1]
+
+def strip_list(s):
+    """
+    Return list with empty items from start and end of list removed.
+    """
+    s = lstrip_list(s)
+    s = rstrip_list(s)
+    return s
+
+def is_array(obj):
+    """
+    Return True if object is list or tuple type.
+    """
+    return isinstance(obj,list) or isinstance(obj,tuple)
 
 def dovetail(lines1, lines2):
-    """Append list or tuple of strings 'lines2' to list 'lines1'.  Join the
-    last string in 'lines1' with the first string in 'lines2' into a single
-    string."""
-    assert isinstance(lines1,list) or isinstance(lines1,tuple)
-    assert isinstance(lines2,list) or isinstance(lines2,tuple)
+    """
+    Append list or tuple of strings 'lines2' to list 'lines1'.  Join the last
+    non-blank item in 'lines1' with the first non-blank item in 'lines2' into a
+    single string.
+    """
+    assert is_array(lines1)
+    assert is_array(lines2)
+    lines1 = strip_list(lines1)
+    lines2 = strip_list(lines2)
     if not lines1 or not lines2:
         return list(lines1) + list(lines2)
     result = list(lines1[:-1])
@@ -286,10 +323,8 @@ def parse_attributes(attrs,dict):
         for v in d.values():
             if not (isinstance(v,str) or isinstance(v,int) or isinstance(v,float) or v is None):
                 raise
-        dict.update(d)
     except:
-        # Try quoting the attrs.
-        s = s.replace('"',r'\"') # Escape double-quotes.
+        s = s.replace('"','\\"')
         s = s.split(',')
         s = map(lambda x: '"' + x.strip() + '"', s)
         s = ','.join(s)
@@ -299,7 +334,7 @@ def parse_attributes(attrs,dict):
             return  # If there's a syntax error leave with {0}=attrs.
         for k in d.keys():  # Drop any empty positional arguments.
             if d[k] == '': del d[k]
-        dict.update(d)
+    dict.update(d)
     assert len(d) > 0
 
 def parse_named_attributes(s,attrs):
@@ -335,7 +370,7 @@ def parse_options(options,allowed,errmsg):
     result = []
     if options:
         for s in re.split(r'\s*,\s*',options):
-            if (allowed and s not in allowed) or (s == '' or not is_name(s)):
+            if (allowed and s not in allowed) or not is_name(s):
                 raise EAsciiDoc,'%s: %s' % (errmsg,s)
             result.append(s)
     return tuple(result)
@@ -347,16 +382,12 @@ def symbolize(s):
 def is_name(s):
     """Return True if s is valid attribute, macro or tag name
     (starts with alpha containing alphanumeric and dashes only)."""
-    return re.match(NAME_RE,s) is not None
+    return re.match(r'^'+NAME_RE+r'$',s) is not None
 
 def subs_quotes(text):
     """Quoted text is marked up and the resulting text is
     returned."""
-    # The quote patterns are iterated in reverse sort order to avoid ambiguity.
-    # So, for example, __ is processed before _.
     keys = config.quotes.keys()
-    keys.sort()
-    keys.reverse()
     for q in keys:
         i = q.find('|')
         if i != -1 and q != '|' and q != '||':
@@ -369,41 +400,42 @@ def subs_quotes(text):
         if tag[0] == '#':
             tag = tag[1:]
             # Unconstrained quotes can appear anywhere.
-            reo = re.compile(r'(?msu)(^|.)(\[(?P<attrs>[^[]+?)\])?' \
+            reo = re.compile(r'(?msu)(^|.)(\[(?P<attrlist>[^[]+?)\])?' \
                     + r'(?:' + re.escape(lq) + r')' \
                     + r'(?P<content>.+?)(?:'+re.escape(rq)+r')')
         else:
             # The text within constrained quotes must be bounded by white space.
             # Non-word (\W) characters are allowed at boundaries to accomodate
             # enveloping quotes.
-            reo = re.compile(r'(?msu)(^|\W)(\[(?P<attrs>[^[]+?)\])?' \
+            reo = re.compile(r'(?msu)(^|\W)(\[(?P<attrlist>[^[]+?)\])?' \
                 + r'(?:' + re.escape(lq) + r')' \
-                + r'(?P<content>.+?)(?:'+re.escape(rq)+r')(?=\W|$)')
+                + r'(?P<content>.*?\S)(?:'+re.escape(rq)+r')(?=\W|$)')
         pos = 0
         while True:
             mo = reo.search(text,pos)
             if not mo: break
             if text[mo.start()] == '\\':
-                pos = mo.end()
+                # Delete leading backslash.
+                text = text[:mo.start()] + text[mo.start()+1:]
+                # Skip past start of match.
+                pos = mo.start() + 1
             else:
-                attrs = {}
-                parse_attributes(mo.group('attrs'), attrs)
-                stag,etag = config.tag(tag, attrs)
+                attrlist = {}
+                parse_attributes(mo.group('attrlist'), attrlist)
+                stag,etag = config.tag(tag, attrlist)
                 s = mo.group(1) + stag + mo.group('content') + etag
                 text = text[:mo.start()] + s + text[mo.end():]
                 pos = mo.start() + len(s)
-        # Unescape escaped quotes.
-        text = text.replace('\\'+lq, lq)
-        if lq != rq:
-            text = text.replace('\\'+rq, rq)
     return text
 
 def subs_tag(tag,dict={}):
     """Perform attribute substitution and split tag string returning start, end
     tag tuple (c.f. Config.tag())."""
+    if not tag:
+        return [None,None]
     s = subs_attrs(tag,dict)
     if not s:
-        warning('tag "%s" dropped: contains undefined attribute' % tag)
+        warning('tag \'%s\' dropped: contains undefined attribute' % tag)
         return [None,None]
     result = s.split('|')
     if len(result) == 1:
@@ -422,7 +454,7 @@ def parse_entry(entry, dict=None, unquote=False, unique_values=False,
     If name! and allow_name_only=True then value is set to None.
     Leading and trailing white space is striped from 'name' and 'value'.
     'name' can contain any printable characters.
-    If the '=' delimiter character is allowed in  the 'name' then 
+    If the '=' delimiter character is allowed in  the 'name' then
     it must be escaped with a backslash and escape_delimiter must be True.
     If 'unquote' is True leading and trailing double-quotes are stripped from
     'name' and 'value'.
@@ -533,18 +565,26 @@ def filter_lines(filter_cmd, lines, dict={}):
     Run 'lines' through the 'filter_cmd' shell command and return the result.
     The 'dict' dictionary contains additional filter attributes.
     """
-    # BUG: Has problems finding filters with spaces in command name.
-    if not filter_cmd:
+    # Return input lines if there's not filter.
+    if not filter_cmd or not filter_cmd.strip():
         return lines
     # Perform attributes substitution on the filter command.
     s = subs_attrs(filter_cmd, dict)
     if not s:
-        raise EAsciiDoc,'missing filter attribute: %s' % filter_cmd
-    filter_cmd = s
+        raise EAsciiDoc,'undefined filter attribute in command: %s' % filter_cmd
+    filter_cmd = s.strip()
+    # Parse for quoted and unquoted command and command tail.
+    # Double quoted.
+    mo = re.match(r'^"(?P<cmd>[^"]+)"(?P<tail>.*)$', filter_cmd)
+    if not mo:
+        # Single quoted.
+        mo = re.match(r"^'(?P<cmd>[^']+)'(?P<tail>.*)$", filter_cmd)
+        if not mo:
+            # Unquoted catch all.
+            mo = re.match(r'^(?P<cmd>\S+)(?P<tail>.*)$', filter_cmd)
+    cmd = mo.group('cmd').strip()
     # Search for the filter command in  both user and application 'filters'
     # sub-directories.
-    mo = re.match(r'^(?P<cmd>\S+)(?P<tail>.*)$', filter_cmd)
-    cmd = mo.group('cmd')
     found = False
     if not os.path.dirname(cmd):
         # Check in asciidoc user and application directories for unqualified
@@ -564,73 +604,36 @@ def filter_lines(filter_cmd, lines, dict={}):
         if found:
             cmd = cmd2
     else:
-        if os.__dict__.has_key('uname') and os.uname()[0][:6] == 'CYGWIN':
-            # popen2() does not like non-drive letter path names under
-            # Cygwin.
-            s = syseval('cygpath -m ' + cmd).strip()
-            if s:
-                cmd = s
         if os.path.isfile(cmd):
             found = True
         else:
             warning('filter not found: %s' % cmd)
     if found:
         filter_cmd = '"' + cmd + '"' + mo.group('tail')
-    verbose('filtering: ' + filter_cmd)
     if sys.platform == 'win32':
-        # Paul Melis's <p.e.c.melis@rug.nl> patch for filters on Win32
-        # This workaround is necessary because Windows select() doesn't
-        # work with regular files.
-        fd,tmp = tempfile.mkstemp()
-        os.close(fd)
-        try:
-            try:
-                # Windows doesn't like running scripts directly so explicitly
-                # specify interpreter.
-                if found:
-                    if cmd[-3:] == '.py':
-                        filter_cmd = 'python ' + filter_cmd
-                    elif cmd[-3:] == '.rb':
-                        filter_cmd = 'ruby ' + filter_cmd
-                w = os.popen(filter_cmd + ' > "%s"' % tmp, 'w')
-                i = 0
-                while i < len(lines):
-                    line = lines[i]
-                    w.write(line + os.linesep)
-                    i = i + 1
-                w.close()
-                result = []
-                for s in open(tmp, 'rt'):
-                    result.append(s.rstrip())
-            except:
-                raise EAsciiDoc,'filter error: %s' % filter_cmd
-        finally:
-            os.unlink(tmp)
+        # Windows doesn't like running scripts directly so explicitly
+        # specify interpreter.
+        if found:
+            if cmd.endswith('.py'):
+                filter_cmd = 'python ' + filter_cmd
+            elif cmd.endswith('.rb'):
+                filter_cmd = 'ruby ' + filter_cmd
+    verbose('filtering: ' + filter_cmd)
+    input = os.linesep.join(lines)
+    try:
+        p = subprocess.Popen(filter_cmd, shell=True,
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+        output = p.communicate(input)[0]
+    except:
+        raise EAsciiDoc,'filter error: %s: %s' % (filter_cmd, sys.exc_info()[1])
+    if output:
+        result = [s.rstrip() for s in output.split(os.linesep)]
     else:
-        try:
-            import select
-            result = []
-            r,w = popen2.popen2(filter_cmd)
-            # Polled I/O loop to alleviate full buffer deadlocks.
-            i = 0
-            while i < len(lines):
-                line = lines[i]
-                if select.select([],[w.fileno()],[],0)[1]:
-                    w.write(line+os.linesep)    # Use platform line terminator.
-                    i = i+1
-                if select.select([r.fileno()],[],[],0)[0]:
-                    s = r.readline()
-                    if not s: break             # Exit if filter output closes.
-                    result.append(s.rstrip())
-            w.close()
-            for s in r:
-                result.append(s.rstrip())
-            r.close()
-        except:
-            raise EAsciiDoc,'filter error: %s' % filter_cmd
-    # There's no easy way to guage whether popen2() found and executed the
-    # filter, so guess that if it produced no output there is probably a
-    # problem.
+        result = []
+    filter_status = p.wait()
+    if filter_status:
+        warning('filter non-zero exit code: %s: returned %d' %
+               (filter_cmd, filter_status))
     if lines and not result:
         warning('no output from filter: %s' % filter_cmd)
     return result
@@ -715,7 +718,7 @@ def system(name, args, is_macro=False):
 
 def subs_attrs(lines, dictionary=None):
     """Substitute 'lines' of text with attributes from the global
-    document.attributes dictionary and from t'dictionary' ('dictionary'
+    document.attributes dictionary and from 'dictionary' ('dictionary'
     entries take precedence). Return a tuple of the substituted lines.  'lines'
     containing undefined attributes are deleted. If 'lines' is a string then
     return a string.
@@ -938,6 +941,12 @@ class Lex:
         if Lex.prev_element and Lex.prev_cursor == reader.cursor:
             return Lex.prev_element
         result = None
+        # Check for AttributeEntry.
+        if not result and AttributeEntry.isnext():
+            result = AttributeEntry
+        # Check for AttributeList.
+        if not result and AttributeList.isnext():
+            result = AttributeList
         # Check for Title.
         if not result and Title.isnext():
             result = Title
@@ -956,14 +965,10 @@ class Lex:
             else:
                 result = blocks.current
         # Check for Table.
+        if not result and tables_OLD.isnext():
+            result = tables_OLD.current
         if not result and tables.isnext():
             result = tables.current
-        # Check for AttributeEntry.
-        if not result and AttributeEntry.isnext():
-            result = AttributeEntry
-        # Check for AttributeList.
-        if not result and AttributeList.isnext():
-            result = AttributeList
         # Check for BlockTitle.
         if not result and BlockTitle.isnext():
             result = BlockTitle
@@ -978,86 +983,33 @@ class Lex:
         return result
     next = staticmethod(next)
 
-    # Extract the passthrough text and replace with temporary placeholders.
-    def extract_passthroughs(text, passthroughs):
-        # +++ passthrough.
-        lq1 = r'(?P<lq>\+{3})'
-        rq1 = r'\+{3}'
-        reo1 = re.compile(r'(?msu)(^|[^\w+])(' + lq1 + r')' \
-            + r'(?P<content>.+?)(' + rq1 + r')(?=[^\w+]|$)')
-        # $$ passthrough.
-        lq2 = r'(\[(?P<attrs>[^[]+?)\])?(?P<lq>\${2})'
-        rq2 = r'\${2}'
-        reo2 = re.compile(r'(?msu)(^|[^\w$\]])(' + lq2 + r')' \
-            + r'(?P<content>.+?)(' + rq2 + r')(?=[^\w$]|$)')
-        reo = reo1
-        pos = 0
-        while True:
-            mo = reo.search(text,pos)
-            if not mo:
-                if reo == reo1:
-                    reo = reo2
-                    pos = 0
-                    continue
-                else:
-                    break
-            if text[mo.start()] == '\\':
-                pos = mo.end()
-            else:
-                content = mo.group('content')
-                if mo.group('lq') == '$$':
-                    content = config.subs_specialchars(content)
-                    attrs = {}
-                    parse_attributes(mo.group('attrs'), attrs)
-                    stag,etag = config.tag('$$passthrough', attrs)
-                    if not stag:
-                        etag = ''   # Drop end tag if start tag has been.
-                    content = stag + content + etag
-                passthroughs.append(content)
-                # Tabs are expanded when the source is read so using them here
-                # guarantees the placeholders are unambiguous.
-                s = mo.group(1) + '\t' + str(len(passthroughs)-1) + '\t'
-                text = text[:mo.start()] + s + text[mo.end():]
-                pos = mo.start() + len(s)
-        # Unescape escaped passthroughs.
-        text = text.replace('\\+++', '+++')
-        text = text.replace('\\$$', '$$')
-        return text
-    extract_passthroughs = staticmethod(extract_passthroughs)
-
-    # Replace passthough placeholders with the original passthrough text.
-    def restore_passthroughs(text, passthroughs):
-        for i,v in enumerate(passthroughs):
-            text = text.replace('\t'+str(i)+'\t', passthroughs[i], 1)
-        return text
-    restore_passthroughs = staticmethod(restore_passthroughs)
-
     def subs_1(s,options):
         """Perform substitution specified in 'options' (in 'options' order) on
-        a single line 's' of text.  Returns the substituted string.
-        Does not process 'attributes' or 'passthroughs' substitutions."""
+        Does not process 'attributes' substitutions."""
         if not s:
             return s
         result = s
         for o in options:
-            if o == 'specialcharacters':
+            if o == 'none':
+                return s
+            elif o == 'specialcharacters':
                 result = config.subs_specialchars(result)
-            # Quoted text.
+            elif o == 'attributes':
+                result = subs_attrs(result)
             elif o == 'quotes':
                 result = subs_quotes(result)
-            # Special words.
             elif o == 'specialwords':
                 result = config.subs_specialwords(result)
-            # Replacements.
             elif o in ('replacements','replacements2'):
                 result = config.subs_replacements(result,o)
-            # Inline macros.
             elif o == 'macros':
                 result = macros.subs(result)
             elif o == 'callouts':
                 result = macros.subs(result,callouts=True)
             else:
                 raise EAsciiDoc,'illegal substitution option: %s' % o
+            if not result:
+                break
         return result
     subs_1 = staticmethod(subs_1)
 
@@ -1075,19 +1027,18 @@ class Lex:
             return lines
         # Join lines so quoting can span multiple lines.
         para = '\n'.join(lines)
-        if 'passthroughs' in options:
-            passthroughs = []
-            para = Lex.extract_passthroughs(para,passthroughs)
+        if 'macros' in options:
+            para = macros.extract_passthroughs(para)
         for o in options:
             if o == 'attributes':
                 # If we don't substitute attributes line-by-line then a single
                 # undefined attribute will drop the entire paragraph.
                 lines = subs_attrs(para.split('\n'))
                 para = '\n'.join(lines)
-            elif o != 'passthroughs':
+            else:
                 para = Lex.subs_1(para,(o,))
-        if 'passthroughs' in options:
-            para = Lex.restore_passthroughs(para,passthroughs)
+        if 'macros' in options:
+            para = macros.restore_passthroughs(para)
         return para.splitlines()
     subs = staticmethod(subs)
 
@@ -1145,6 +1096,7 @@ class Document:
         self.attributes['backend-'+document.backend] = ''
         self.attributes['doctype-'+document.doctype] = ''
         self.attributes[document.backend+'-'+document.doctype] = ''
+        self.attributes['asciidoc-file'] = APP_FILE
         self.attributes['asciidoc-dir'] = APP_DIR
         self.attributes['user-dir'] = USER_DIR
         if self.infile != '<stdin>':
@@ -1215,12 +1167,12 @@ class Document:
                     error('SYNOPSIS section expected')
                 else:
                     Title.translate()
-                    if Title.dict['title'].upper() <> 'SYNOPSIS':
+                    if Title.attributes['title'].upper() <> 'SYNOPSIS':
                         error('second section must be named SYNOPSIS')
                     if Title.level != 1:
                         error('SYNOPSIS section title must be at level 1')
                     d = {}
-                    d.update(Title.dict)
+                    d.update(Title.attributes)
                     AttributeList.consume(d)
                     stag,etag = config.section2tags('sect-synopsis',d)
                     writer.write(stag)
@@ -1324,7 +1276,7 @@ class Header:
         assert Lex.next() is Title and Title.level == 0
         Title.translate()
         attrs = document.attributes # Alias for readability.
-        attrs['doctitle'] = Title.dict['title']
+        attrs['doctitle'] = Title.attributes['title']
         if document.doctype == 'manpage':
             # manpage title formatted like mantitle(manvolnum).
             mo = re.match(r'^(?P<mantitle>.*)\((?P<manvolnum>.*)\)$',
@@ -1372,7 +1324,7 @@ class Header:
                 error('NAME section expected')
             else:
                 Title.translate()
-                if Title.dict['title'].upper() <> 'NAME':
+                if Title.attributes['title'].upper() <> 'NAME':
                     error('first section must be named NAME')
                 if Title.level != 1:
                     error('NAME section title must be at level 1')
@@ -1395,6 +1347,7 @@ class AttributeEntry:
     pattern = None
     subs = None
     name = None
+    name2 = None
     value = None
     def __init__(self):
         raise AssertionError,'no class instances allowed'
@@ -1415,36 +1368,49 @@ class AttributeEntry:
             AttributeEntry.subs = subs
         line = reader.read_next()
         if line:
+            # Attribute entry formatted like :<name>[.<name2>]:[ <value>]
             mo = re.match(AttributeEntry.pattern,line)
             if mo:
-                name = mo.group('attrname').strip()
-                if name[-1] == '!':     # Names like name! are None.
-                    name = name[:-1]
-                    value = None
-                else:
-                    value = mo.group('attrvalue').strip()
-                # Strip white space and illegal name chars.
-                name = re.sub(r'(?u)[^\w\-_]', '', name).lower()
-                AttributeEntry.name = name
-                AttributeEntry.value = value
+                AttributeEntry.name = mo.group('attrname')
+                AttributeEntry.name2 = mo.group('attrname2')
+                AttributeEntry.value = mo.group('attrvalue') or ''
+                AttributeEntry.value = AttributeEntry.value.strip()
                 result = True
         return result
     isnext = staticmethod(isnext)
     def translate():
         assert Lex.next() is AttributeEntry
         attr = AttributeEntry   # Alias for brevity.
-        reader.read()   # Discard attribute from reader.
-        # Don't override command-line attributes.
-        if config.cmd_attrs.has_key(attr.name):
-            return
-        # Update document.attributes from previously parsed attribute.
-        if attr.value:
-            attr.value = Lex.subs((attr.value,), attr.subs)
-            attr.value = writer.newline.join(attr.value)
-        if attr.value is not None:
-            document.attributes[attr.name] = attr.value
-        elif document.attributes.has_key(attr.name):
-            del document.attributes[attr.name]
+        reader.read()   # Discard attribute entry from reader.
+        if AttributeEntry.name2: # The entry is a conf file entry.
+            section = {}
+            # [attributes] and [miscellaneous] entries can have name! syntax.
+            if attr.name in ('attributes','miscellaneous') and attr.name2[-1] == '!':
+                section[attr.name] = [attr.name2]
+            else:
+               section[attr.name] = ['%s=%s' % (attr.name2,attr.value)]
+            config.load_sections(section)
+            config.validate()
+        else: # The entry is an attribute.
+            if attr.name[-1] == '!':
+                # Names like name! undefine the attribute.
+                attr.name = attr.name[:-1]
+                attr.value = None
+            # Strip white space and illegal name chars.
+            attr.name = re.sub(r'(?u)[^\w\-_]', '', attr.name).lower()
+            # Don't override command-line attributes.
+            if attr.name in config.cmd_attrs:
+                return
+            # Update document.attributes from previously parsed attribute.
+            if attr.name == 'attributeentry-subs':
+                AttributeEntry.subs = None  # Force update in isnext().
+            elif attr.value:
+                attr.value = Lex.subs((attr.value,), attr.subs)
+                attr.value = writer.newline.join(attr.value)
+            if attr.value is not None:
+                document.attributes[attr.name] = attr.value
+            elif attr.name in document.attributes:
+                del document.attributes[attr.name]
     translate = staticmethod(translate)
     def translate_all():
         """ Process all contiguous attribute lines on reader."""
@@ -1492,6 +1458,11 @@ class AttributeList:
         if AttributeList.attrs:
             d.update(AttributeList.attrs)
             AttributeList.attrs = {}
+            # Generate option attributes.
+            if 'options' in d:
+                options = parse_options(d['options'], (), 'illegal option name')
+                for option in options:
+                    d[option+'-option'] = ''
     consume = staticmethod(consume)
 
 class BlockTitle:
@@ -1537,7 +1508,7 @@ class Title:
     subs = ()
     pattern = None
     level = 0
-    dict = {}
+    attributes = {}
     sectname = None
     section_numbers = [0]*len(underlines)
     dump_dict = {}
@@ -1545,7 +1516,7 @@ class Title:
     def __init__(self):
         raise AssertionError,'no class instances allowed'
     def translate():
-        """Parse the Title.dict and Title.level from the reader. The
+        """Parse the Title.attributes and Title.level from the reader. The
         real work has already been done by parse()."""
         assert Lex.next() is Title
         # Discard title from reader.
@@ -1555,11 +1526,11 @@ class Title:
         # Perform title substitutions.
         if not Title.subs:
             Title.subs = config.subsnormal
-        s = Lex.subs((Title.dict['title'],), Title.subs)
+        s = Lex.subs((Title.attributes['title'],), Title.subs)
         s = writer.newline.join(s)
         if not s:
             warning('blank section title')
-        Title.dict['title'] = s
+        Title.attributes['title'] = s
     translate = staticmethod(translate)
     def isnext():
         lines = reader.read_ahead(2)
@@ -1576,7 +1547,7 @@ class Title:
             if Title.dump_dict.has_key(k):
                 mo = re.match(Title.dump_dict[k], lines[0])
                 if mo:
-                    Title.dict = mo.groupdict()
+                    Title.attributes = mo.groupdict()
                     Title.level = level
                     Title.linecount = 1
                     result = True
@@ -1601,25 +1572,25 @@ class Title:
             if not re.search(r'(?u)\w',title): return False
             mo = re.match(Title.pattern, title)
             if mo:
-                Title.dict = mo.groupdict()
+                Title.attributes = mo.groupdict()
                 Title.level = list(Title.underlines).index(ul[:2])
                 Title.linecount = 2
                 result = True
         # Check for expected pattern match groups.
         if result:
-            if not Title.dict.has_key('title'):
+            if not Title.attributes.has_key('title'):
                 warning('[titles] entry has no <title> group')
-                Title.dict['title'] = lines[0]
-            for k,v in Title.dict.items():
-                if v is None: del Title.dict[k]
+                Title.attributes['title'] = lines[0]
+            for k,v in Title.attributes.items():
+                if v is None: del Title.attributes[k]
         return result
     parse = staticmethod(parse)
-    def load(dict):
-        """Load and validate [titles] section entries from dict."""
-        if dict.has_key('underlines'):
+    def load(entries):
+        """Load and validate [titles] section entries dictionary."""
+        if entries.has_key('underlines'):
             errmsg = 'malformed [titles] underlines entry'
             try:
-                underlines = parse_list(dict['underlines'])
+                underlines = parse_list(entries['underlines'])
             except:
                 raise EAsciiDoc,errmsg
             if len(underlines) != len(Title.underlines):
@@ -1628,27 +1599,27 @@ class Title:
                 if len(s) !=2:
                     raise EAsciiDoc,errmsg
             Title.underlines = tuple(underlines)
-            Title.dump_dict['underlines'] = dict['underlines']
-        if dict.has_key('subs'):
-            Title.subs = parse_options(dict['subs'], SUBS_OPTIONS,
+            Title.dump_dict['underlines'] = entries['underlines']
+        if entries.has_key('subs'):
+            Title.subs = parse_options(entries['subs'], SUBS_OPTIONS,
                 'illegal [titles] subs entry')
-            Title.dump_dict['subs'] = dict['subs']
-        if dict.has_key('sectiontitle'):
-            pat = dict['sectiontitle']
+            Title.dump_dict['subs'] = entries['subs']
+        if entries.has_key('sectiontitle'):
+            pat = entries['sectiontitle']
             if not pat or not is_regexp(pat):
                 raise EAsciiDoc,'malformed [titles] sectiontitle entry'
             Title.pattern = pat
             Title.dump_dict['sectiontitle'] = pat
-        if dict.has_key('blocktitle'):
-            pat = dict['blocktitle']
+        if entries.has_key('blocktitle'):
+            pat = entries['blocktitle']
             if not pat or not is_regexp(pat):
                 raise EAsciiDoc,'malformed [titles] blocktitle entry'
             BlockTitle.pattern = pat
             Title.dump_dict['blocktitle'] = pat
         # Load single-line title patterns.
         for k in ('sect0','sect1','sect2','sect3','sect4'):
-            if dict.has_key(k):
-                pat = dict[k]
+            if entries.has_key(k):
+                pat = entries[k]
                 if not pat or not is_regexp(pat):
                     raise EAsciiDoc,'malformed [titles] %s entry' % k
                 Title.dump_dict[k] = pat
@@ -1663,13 +1634,13 @@ class Title:
         """Set Title section name. First search for section title in
         [specialsections], if not found use default 'sect<level>' name."""
         for pat,sect in config.specialsections.items():
-            mo = re.match(pat,Title.dict['title'])
+            mo = re.match(pat,Title.attributes['title'])
             if mo:
                 title = mo.groupdict().get('title')
                 if title is not None:
-                    Title.dict['title'] = title.strip()
+                    Title.attributes['title'] = title.strip()
                 else:
-                    Title.dict['title'] = mo.group().strip()
+                    Title.attributes['title'] = mo.group().strip()
                 Title.sectname = sect
                 break
         else:
@@ -1721,9 +1692,10 @@ class Section:
         NameChar        ::=     Letter | Digit | '.' | '-' | '_' | ':'
         """
         base_ident = re.sub(r'[^a-zA-Z0-9]+', '_', title).strip('_').lower()
-        # Prefix with underscore to ensure a valid id start character and to
-        # ensure the id does not clash with existing document id's.
-        base_ident = '_' + base_ident
+        # Prefix the ID name with idprefix attribute or underscore if not
+        # defined. Prefix ensures the ID does not clash with existing IDs.
+        idprefix = document.attributes.get('idprefix','_')
+        base_ident = idprefix + base_ident
         i = 1
         while True:
             if i == 1:
@@ -1763,11 +1735,11 @@ class Section:
         if not document.attributes.get('sectids') is None \
                 and 'id' not in AttributeList.attrs:
             # Generate ids for sections.
-            AttributeList.attrs['id'] = Section.gen_id(Title.dict['title'])
+            AttributeList.attrs['id'] = Section.gen_id(Title.attributes['title'])
         Section.setlevel(Title.level)
-        Title.dict['sectnum'] = Title.getnumber(document.level)
-        AttributeList.consume(Title.dict)
-        stag,etag = config.section2tags(Title.sectname,Title.dict)
+        Title.attributes['sectnum'] = Title.getnumber(document.level)
+        AttributeList.consume(Title.attributes)
+        stag,etag = config.section2tags(Title.sectname,Title.attributes)
         Section.savetag(Title.level,etag)
         writer.write(stag)
         Section.translate_body()
@@ -1796,12 +1768,12 @@ class Section:
 
 class AbstractBlock:
     def __init__(self):
-        self.OPTIONS = ()   # The set of allowed options values
         # Configuration parameter names common to all blocks.
-        self.CONF_ENTRIES = ('options','subs','presubs','postsubs',
-                             'posattrs','style','.*-style')
-        # Configuration parameters.
+        self.CONF_ENTRIES = ('delimiter','options','subs','presubs','postsubs',
+                             'posattrs','style','.*-style','template','filter')
+        self.start = None   # File reader cursor at start delimiter.
         self.name=None      # Configuration file section name.
+        # Configuration parameters.
         self.delimiter=None # Regular expression matching block delimiter.
         self.template=None  # template section entry.
         self.options=()     # options entry list.
@@ -1810,18 +1782,27 @@ class AbstractBlock:
         self.filter=None    # filter entry.
         self.posattrs=()    # posattrs entry list.
         self.style=None     # Default style.
-        self.styles=OrderedDict()   # Styles dictionary.
+        self.styles=OrderedDict() # Each entry is a styles dictionary.
         # Before a block is processed it's attributes (from it's
         # attributes list) are merged with the block configuration parameters
-        # (by self.process_attributes()) resulting in the template substitution
+        # (by self.merge_attributes()) resulting in the template substitution
         # dictionary (self.attributes) and the block's procssing parameters
         # (self.parameters).
         self.attributes={}
         # The names of block parameters.
         self.PARAM_NAMES=('template','options','presubs','postsubs','filter')
-        self.parameters={}
+        self.parameters=None
         # Leading delimiter match object.
         self.mo=None
+    def short_name(self):
+        """ Return the text following the last dash in the section namem """
+        i = self.name.rfind('-')
+        if i == -1:
+            return self.name
+        else:
+            return self.name[i+1:]
+    def error(self, msg, cursor=None, halt=False):
+        error('[%s] %s' % (self.name,msg), cursor, halt)
     def is_conf_entry(self,param):
         """Return True if param matches an allowed configuration file entry
         name."""
@@ -1831,53 +1812,89 @@ class AbstractBlock:
         return False
     def load(self,name,entries):
         """Update block definition from section 'entries' dictionary."""
-        for k in entries.keys():
-            if not self.is_conf_entry(k):
-                raise EAsciiDoc,'illegal [%s] entry name: %s' % (name,k)
         self.name = name
-        for k,v in entries.items():
-            if not is_name(k):
-                raise EAsciiDoc, \
-                    'malformed [%s] entry name: %s' % (name,k)
-            if k == 'delimiter':
+        self.update_parameters(entries, self, all=True)
+    def update_parameters(self, src, dst=None, all=False):
+        """
+        Parse processing parameters from src dictionary to dst object.
+        dst defaults to self.parameters.
+        If all is True then copy src entries that aren't parameter names.
+        """
+        dst = dst or self.parameters
+        msg = '[%s] malformed entry %%s: %%s' % self.name
+        def copy(obj,k,v):
+            if isinstance(obj,dict):
+                obj[k] = v
+            else:
+                setattr(obj,k,v)
+        for k,v in src.items():
+            if not re.match(r'\d+',k) and not is_name(k):
+                raise EAsciiDoc, msg % (k,v)
+            if k == 'template':
+                if not is_name(v):
+                    raise EAsciiDoc, msg % (k,v)
+                copy(dst,k,v)
+            elif k == 'filter':
+                copy(dst,k,v)
+            elif k == 'options':
+                if isinstance(v,str):
+                    v = parse_options(v, (), msg % (k,v))
+                copy(dst,k,v)
+            elif k in ('subs','presubs','postsubs'):
+                # Subs is an alias for presubs.
+                if k == 'subs': k = 'presubs'
+                if isinstance(v,str):
+                    v = parse_options(v, SUBS_OPTIONS, msg % (k,v))
+                copy(dst,k,v)
+            elif k == 'delimiter':
                 if v and is_regexp(v):
-                    self.delimiter = v
+                    copy(dst,k,v)
                 else:
-                    raise EAsciiDoc,'malformed [%s] regexp: %s' % (name,v)
-            elif k == 'template':
-                if not is_name(v):
-                    raise EAsciiDoc, \
-                        'malformed [%s] template name: %s' % (name,v)
-                self.template = v
+                    raise EAsciiDoc, msg % (k,v)
             elif k == 'style':
-                if not is_name(v):
-                    raise EAsciiDoc, \
-                        'malformed [%s] style name: %s' % (name,v)
-                self.style = v
+                if is_name(v):
+                    copy(dst,k,v)
+                else:
+                    raise EAsciiDoc, msg % (k,v)
             elif k == 'posattrs':
-                self.posattrs = parse_options(v, (),
-                    'illegal [%s] %s: %s' % (name,k,v))
-            elif k == 'options':
-                self.options = parse_options(v,self.OPTIONS,
-                    'illegal [%s] %s: %s' % (name,k,v))
-            elif k == 'presubs' or k == 'subs':
-                self.presubs = parse_options(v,SUBS_OPTIONS,
-                    'illegal [%s] %s: %s' % (name,k,v))
-            elif k == 'postsubs':
-                self.postsubs = parse_options(v,SUBS_OPTIONS,
-                    'illegal [%s] %s: %s' % (name,k,v))
-            elif k == 'filter':
-                self.filter = v
+                v = parse_options(v, (), msg % (k,v))
+                copy(dst,k,v)
             else:
                 mo = re.match(r'^(?P<style>.*)-style$',k)
                 if mo:
                     if not v:
-                        raise EAsciiDoc, 'empty [%s] style: %s' % (name,k)
+                        raise EAsciiDoc, msg % (k,v)
                     style = mo.group('style')
+                    if not is_name(style):
+                        raise EAsciiDoc, msg % (k,v)
                     d = {}
                     if not parse_named_attributes(v,d):
-                        raise EAsciiDoc,'malformed [%s] style: %s' % (name,v)
+                        raise EAsciiDoc, msg % (k,v)
+                    if 'subs' in d:
+                        # Subs is an alias for presubs.
+                        d['presubs'] = d['subs']
+                        del d['subs']
                     self.styles[style] = d
+                elif all or k in self.PARAM_NAMES:
+                    copy(dst,k,v) # Derived class specific entries.
+    def get_param(self,name,params=None):
+        """
+        Return named processing parameter from params dictionary.
+        If the parameter is not in params look in self.parameters.
+        """
+        if params and name in params:
+            return params[name]
+        elif name in self.parameters:
+            return self.parameters[name]
+        else:
+            return None
+    def get_subs(self,params=None):
+        """
+        Return (presubs,postsubs) tuple.
+        """
+        presubs = self.get_param('presubs',params)
+        postsubs = self.get_param('postsubs',params)
+        return (presubs,postsubs)
     def dump(self):
         """Write block definition to stdout."""
         write = lambda s: sys.stdout.write('%s%s' % (s,writer.newline))
@@ -1911,8 +1928,12 @@ class AbstractBlock:
         if self.is_conf_entry('delimiter') and not self.delimiter:
             raise EAsciiDoc,'[%s] missing delimiter' % self.name
         if self.style:
+            if not is_name(self.style):
+                raise EAsciiDoc, 'illegal style name: %s' % self.style
             if not self.styles.has_key(self.style):
-                warning(' missing [%s] %s-style entry' % (self.name,self.style))
+                if not isinstance(self,List):   # Lists don't have templates.
+                    warning('[%s] \'%s\' style not in %s' % (
+                        self.name,self.style,self.styles.keys()))
         # Check all styles for missing templates.
         all_styles_have_template = True
         for k,v in self.styles.items():
@@ -1928,7 +1949,8 @@ class AbstractBlock:
                 if not config.sections.has_key(self.template):
                     warning('[%s] missing template section' % self.template)
             elif not all_styles_have_template:
-                warning('[%s] styles missing templates' % self.name)
+                if not isinstance(self,List): # Lists don't have templates.
+                    warning('[%s] styles missing templates' % self.name)
     def isnext(self):
         """Check if this block is next in document reader."""
         result = False
@@ -1943,34 +1965,50 @@ class AbstractBlock:
         """Translate block from document reader."""
         if not self.presubs:
             self.presubs = config.subsnormal
-    def update_params(self,src,dst):
-        """Copy block processing parameters from src to dst dictionaries."""
-        for k,v in src.items():
-            if k in ('template','filter'):
-                dst[k] = v
-            elif k == 'options':
-                dst[k] = parse_options(v,self.OPTIONS,
-                    'illegal [%s] %s: %s' % (self.name,k,v))
-            elif k in  ('subs','presubs','postsubs'):
-                subs = parse_options(v,SUBS_OPTIONS,
-                    'illegal [%s] %s: %s' % (self.name,k,v))
-                if k == 'subs':
-                    dst['presubs'] = subs
-                else:
-                    dst[k] = subs
-    def merge_attributes(self,attrs):
-        """Merge block attributes 'attrs' dictionary with the block
-        configuration parameters setting self.attributes (template substitution
-        attributes) and self.parameters (block processing parameters)."""
+        if reader.cursor:
+            self.start = reader.cursor[:]
+    def merge_attributes(self,attrs,params=[]):
+        """
+        Use the current blocks attribute list (attrs dictionary) to build a
+        dictionary of block processing parameters (self.parameters) and tag
+        substitution attributes (self.attributes).
+
+        1. Copy the default parameters (self.*) to self.parameters.
+        self.parameters are used internally to render the current block.
+        Optional params array of addtional parameters.
+
+        2. Copy attrs to self.attributes. self.attributes are used for template
+        and tag substitution in the current block.
+
+        3. If a style attribute was specified update self.parameters with the
+        corresponding style parameters; if there are any style parameters
+        remaining add them to self.attributes (existing attribute list entries
+        take precedence).
+
+        4. Set named positional attributes in self.attributes if self.posattrs
+        was specified.
+
+        5. Finally self.parameters is updated with any corresponding parameters
+        specified in attrs.
+
+        """
+
+        def check_array_parameter(param):
+            # Check the parameter is a sequence type.
+            if not is_array(self.parameters[param]):
+                error('malformed presubs attribute: %s' %
+                        self.parameters[param])
+                # Revert to default value.
+                self.parameters[param] = getattr(self,param)
+
+        params = list(self.PARAM_NAMES) + params
         self.attributes = {}
         self.attributes.update(attrs)
         # Calculate dynamic block parameters.
         # Start with configuration file defaults.
-        self.parameters['template'] = self.template
-        self.parameters['options'] = self.options
-        self.parameters['presubs'] = self.presubs
-        self.parameters['postsubs'] = self.postsubs
-        self.parameters['filter'] = self.filter
+        self.parameters = AttrDict()
+        for name in params:
+            self.parameters[name] = getattr(self,name)
         # Load the selected style attributes.
         posattrs = self.posattrs
         if posattrs and posattrs[0] == 'style':
@@ -1979,15 +2017,15 @@ class AbstractBlock:
             style = None
         if not style:
             style = self.attributes.get('style',self.style)
-        if style is not None:
-            if not self.styles.has_key(style):
-                warning('missing [%s] %s-style entry' % (self.name,style))
-            else:
+        if style:
+            if not is_name(style):
+                raise EAsciiDoc, 'illegal style name: %s' % style
+            if self.styles.has_key(style):
                 self.attributes['style'] = style
                 for k,v in self.styles[style].items():
                     if k == 'posattrs':
                         posattrs = v
-                    elif k in self.PARAM_NAMES:
+                    elif k in params:
                         self.parameters[k] = v
                     elif not self.attributes.has_key(k):
                         # Style attributes don't take precedence over explicit.
@@ -1996,19 +2034,11 @@ class AbstractBlock:
         for i,v in enumerate(posattrs):
             if self.attributes.has_key(str(i+1)):
                 self.attributes[v] = self.attributes[str(i+1)]
-        # Override config and style attributes with document attributes.
-        self.update_params(self.attributes,self.parameters)
-        assert isinstance(self.parameters['options'],tuple)
-        assert isinstance(self.parameters['presubs'],tuple)
-        assert isinstance(self.parameters['postsubs'],tuple)
-    def get_options(self):
-        return self.parameters['options']
-    def get_subs(self):
-        return (self.parameters['presubs'], self.parameters['postsubs'])
-    def get_template(self):
-        return self.parameters['template']
-    def get_filter(self):
-        return self.parameters['filter']
+        # Override config and style attributes with attribute list attributes.
+        self.update_parameters(attrs)
+        check_array_parameter('options')
+        check_array_parameter('presubs')
+        check_array_parameter('postsubs')
 
 class AbstractBlocks:
     """List of block definitions."""
@@ -2058,8 +2088,6 @@ class AbstractBlocks:
 class Paragraph(AbstractBlock):
     def __init__(self):
         AbstractBlock.__init__(self)
-        self.CONF_ENTRIES += ('delimiter','template','filter')
-        self.OPTIONS = ('listelement',)
         self.text=None      # Text in first line of paragraph.
     def load(self,name,entries):
         AbstractBlock.load(self,name,entries)
@@ -2080,18 +2108,20 @@ class Paragraph(AbstractBlock):
         AttributeList.consume(attrs)
         self.merge_attributes(attrs)
         reader.read()   # Discard (already parsed item first line).
-        body = reader.read_until(r'^\+$|^$|'+blocks.delimiter+r'|'+tables.delimiter)
+        body = reader.read_until(r'^\+$|^$|' + blocks.delimiter
+                + r'|' + tables.delimiter
+                + r'|' + tables_OLD.delimiter
+                + r'|' + AttributeList.pattern
+        )
         body = [self.text] + list(body)
-        presubs,postsubs = self.get_subs()
-        # Don't join verbatim paragraphs.
-        if 'verbatim' not in (presubs + postsubs):
-            body = join_lines(body)
+        presubs = self.parameters.presubs
+        postsubs = self.parameters.postsubs
         body = Lex.set_margin(body) # Move body to left margin.
         body = Lex.subs(body,presubs)
-        if self.get_filter():
-            body = filter_lines(self.get_filter(),body,self.attributes)
+        if self.parameters.filter:
+            body = filter_lines(self.parameters.filter,body,self.attributes)
         body = Lex.subs(body,postsubs)
-        template = self.get_template()
+        template = self.parameters.template
         stag,etag = config.section2tags(template, self.attributes)
         # Write start tag, content, end tag.
         writer.write(dovetail_tags(stag,body,etag))
@@ -2117,16 +2147,15 @@ class Paragraphs(AbstractBlocks):
             raise EAsciiDoc,'missing [paradef-default] section'
 
 class List(AbstractBlock):
-    TAGS = ('listtag','itemtag','texttag','entrytag','labeltag')
-    TYPES = ('bulleted','numbered','labeled','callout')
     def __init__(self):
         AbstractBlock.__init__(self)
-        self.CONF_ENTRIES += ('delimiter','type') + self.TAGS
-        self.listtag=None
-        self.itemtag=None
-        self.texttag=None   # Tag for list item text.
-        self.labeltag=None  # Variable lists only.
-        self.entrytag=None  # Variable lists only.
+        self.CONF_ENTRIES += ('type','tags')
+        self.PARAM_NAMES += ('tags',)
+        # tabledef conf file parameters.
+        self.type=None
+        self.tags=None          # Name of listtags-<tags> conf section.
+        # Calculated parameters.
+        self.tag=None       # Current tags AttrDict.
         self.label=None     # List item label (labeled lists).
         self.text=None      # Text in first line of list item.
         self.index=None     # Matched delimiter 'index' group (numbered lists).
@@ -2134,28 +2163,19 @@ class List(AbstractBlock):
         self.listindex=None # Current list index (1..)
     def load(self,name,entries):
         AbstractBlock.load(self,name,entries)
-        for k,v in entries.items():
-            if k == 'type':
-                if v in self.TYPES:
-                    self.type = v
-                else:
-                    raise EAsciiDoc,'illegal list type: %s' % v
-            elif k in self.TAGS:
-                if is_name(v):
-                    setattr(self,k,v)
-                else:
-                    raise EAsciiDoc,'illegal list %s name: %s' % (k,v)
     def dump(self):
         AbstractBlock.dump(self)
         write = lambda s: sys.stdout.write('%s%s' % (s,writer.newline))
         write('type='+self.type)
-        write('listtag='+self.listtag)
-        write('itemtag='+self.itemtag)
-        write('texttag='+self.texttag)
-        if self.type == 'labeled':
-            write('entrytag='+self.entrytag)
-            write('labeltag='+self.labeltag)
+        write('tags='+self.tags)
         write('')
+    def validate(self):
+        AbstractBlock.validate(self)
+        tags = [self.tags]
+        tags += [s['tags'] for s in self.styles.values() if 'tags' in s]
+        for t in tags:
+            if t not in lists.tags:
+                self.error('missing section: [listtags-%s]' % t,halt=True)
     def isnext(self):
         result = AbstractBlock.isnext(self)
         if result:
@@ -2165,24 +2185,20 @@ class List(AbstractBlock):
         return result
     def translate_entry(self):
         assert self.type == 'labeled'
-        stag,etag = config.tag(self.entrytag, self.attributes)
-        if stag:
-            writer.write(stag)
-        if self.listtag == 'hlist':
-            # Horizontal label list.
+        entrytag = subs_tag(self.tag.entry, self.attributes)
+        labeltag = subs_tag(self.tag.label, self.attributes)
+        writer.write(entrytag[0])
+        writer.write(labeltag[0])
+        # Write labels.
+        while Lex.next() is self:
             reader.read()   # Discard (already parsed item first line).
-            writer.write_tag(self.labeltag, [self.label],
+            writer.write_tag(self.tag.term, [self.label],
                              self.presubs, self.attributes)
-        else:
-            # Write multiple labels (vertical label list).
-            while Lex.next() is self:
-                reader.read()   # Discard (already parsed item first line).
-                writer.write_tag(self.labeltag, [self.label],
-                                 self.presubs, self.attributes)
+            if self.text: break
+        writer.write(labeltag[1])
         # Write item text.
         self.translate_item()
-        if etag:
-            writer.write(etag)
+        writer.write(entrytag[1])
     def iscontinued(self):
         if reader.read_next() == '+':
             reader.read()   # Discard.
@@ -2201,26 +2217,27 @@ class List(AbstractBlock):
         """Translation for '+' style list continuation."""
         if self.type == 'callout':
             self.attributes['coids'] = calloutmap.calloutids(self.listindex)
-        stag,etag = config.tag(self.itemtag, self.attributes)
-        if stag:
-            writer.write(stag)
+        itemtag = subs_tag(self.tag.item, self.attributes)
+        writer.write(itemtag[0])
         if self.text and self.text == '+':
-            # Pathalogical case: continued Horizontal Labeled List with no
+            # Pathological case: continued Horizontal Labeled List with no
             # item text.
             continued = True
         elif not self.text and self.iscontinued():
-            # Pathalogical case: continued Vertical Labeled List with no
+            # Pathological case: continued Vertical Labeled List with no
             # item text.
             continued = True
         else:
             # Write ItemText.
-            text = reader.read_until(lists.delimiter + r'|^\+$|^$|' +
-                                    blocks.delimiter + r'|' + tables.delimiter)
+            text = reader.read_until(
+                    lists.delimiter + r'|^\+$|^$|' + blocks.delimiter
+                    + r'|' + tables.delimiter
+                    + r'|' + tables_OLD.delimiter
+            )
             if self.text is not None:
                 text = [self.text] + list(text)
-            text = join_lines(text)
             if text:
-                writer.write_tag(self.texttag, text, self.presubs, self.attributes)
+                writer.write_tag(self.tag.text, text, self.presubs, self.attributes)
             continued = self.iscontinued()
         while True:
             next = Lex.next()
@@ -2237,23 +2254,23 @@ class List(AbstractBlock):
             else:
                 break
             continued = self.iscontinued()
-        if etag:
-            writer.write(etag)
+        writer.write(itemtag[1])
     def translate_item_2(self):
         """Translation for List block style lists."""
         if self.type == 'callout':
             self.attributes['coids'] = calloutmap.calloutids(self.listindex)
-        stag,etag = config.tag(self.itemtag, self.attributes)
-        if stag:
-            writer.write(stag)
+        itemtag = subs_tag(self.tag.item, self.attributes)
+        writer.write(itemtag[0])
         if self.text or reader.read_next():
             # Write ItemText.
-            text = reader.read_until(lists.delimiter + r'|^$|' +
-                                    blocks.delimiter + r'|' + tables.delimiter)
+            text = reader.read_until(
+                    lists.delimiter + r'|^$|' + blocks.delimiter
+                    + r'|' + tables.delimiter
+                    + r'|' + tables_OLD.delimiter
+            )
             if self.text is not None:
                 text = [self.text] + list(text)
-            text = join_lines(text)
-            writer.write_tag(self.texttag, text, self.presubs, self.attributes)
+            writer.write_tag(self.tag.text, text, self.presubs, self.attributes)
         while True:
             next = Lex.next()
             if next in lists.open:
@@ -2270,8 +2287,7 @@ class List(AbstractBlock):
                 next.translate()
             else:
                 break
-        if etag:
-            writer.write(etag)
+        writer.write(itemtag[1])
     def check_index(self):
         """ Check calculated listindex (1,2,...) against the item index in the
         document (self.index)."""
@@ -2287,15 +2303,37 @@ class List(AbstractBlock):
             if matched and i != self.listindex:
                 print 'type: ',self.type,': expected ',self.listindex,' got ',i
                 warning('list item %s out of sequence' % self.index)
+    def check_tags(self):
+        """ Check that all necessary tags are present. """
+        tags = set(Lists.TAGS)
+        if self.type != 'labeled':
+            tags = tags.difference(['entry','label','term'])
+        missing = tags.difference(self.tag.keys())
+        if missing:
+            self.error('missing tag(s): %s' % ','.join(missing), halt=True)
     def translate(self):
         AbstractBlock.translate(self)
+        if self.short_name() in ('bibliography','glossary','qanda'):
+            deprecated('old %s list syntax' % self.short_name())
         lists.open.append(self)
         attrs = {}
         attrs.update(self.mo.groupdict())
         BlockTitle.consume(attrs)
         AttributeList.consume(attrs)
-        self.merge_attributes(attrs)
-        stag,etag = config.tag(self.listtag, self.attributes)
+        self.merge_attributes(attrs,['tags'])
+        self.tag = lists.tags[self.parameters.tags]
+        self.check_tags()
+        if 'width' in self.attributes:
+            # Set horizontal list 'labelwidth' and 'itemwidth' attributes.
+            v = str(self.attributes['width'])
+            mo = re.match(r'^(\d{1,2})%?$',v)
+            if mo:
+                labelwidth = int(mo.group(1))
+                self.attributes['labelwidth'] = str(labelwidth)
+                self.attributes['itemwidth'] = str(100-labelwidth)
+            else:
+                self.error('illegal attribute value: label="%s"' % v)
+        stag,etag = subs_tag(self.tag.list, self.attributes)
         if stag:
             writer.write(stag)
         self.listindex = 0
@@ -2324,37 +2362,50 @@ class Lists(AbstractBlocks):
     """List of List objects."""
     BLOCK_TYPE = List
     PREFIX = 'listdef-'
+    TYPES = ('bulleted','numbered','labeled','callout')
+    TAGS = ('list', 'entry','item','text', 'label','term')
     def __init__(self):
         AbstractBlocks.__init__(self)
         self.open = []           # A stack of the current and parent lists.
         self.listblock = None    # Current list is in list block.
+        self.tags={}    # List tags dictionary. Each entry is a tags AttrDict.
     def load(self,sections):
         AbstractBlocks.load(self,sections)
+        self.load_tags(sections)
+    def load_tags(self,sections):
+        """
+        Load listtags-* conf file sections to self.tags.
+        """
+        for section in sections.keys():
+            mo = re.match(r'^listtags-(?P<name>\w+)$',section)
+            if mo:
+                name = mo.group('name')
+                if self.tags.has_key(name):
+                    d = self.tags[name]
+                else:
+                    d = AttrDict()
+                parse_entries(sections.get(section,()),d)
+                for k in d.keys():
+                    if k not in self.TAGS:
+                        warning('[%s] contains illegal list tag: %s' %
+                                (section,k))
+                self.tags[name] = d
     def validate(self):
         AbstractBlocks.validate(self)
         for b in self.blocks:
             # Check list has valid type.
-            if not b.type in b.TYPES:
+            if not b.type in Lists.TYPES:
                 raise EAsciiDoc,'[%s] illegal type' % b.name
-            # Check all list tags.
-            if not b.listtag or not config.tags.has_key(b.listtag):
-                warning('[%s] missing listtag' % b.name)
-            if not b.itemtag or not config.tags.has_key(b.itemtag):
-                warning('[%s] missing tag itemtag' % b.name)
-            if not b.texttag or not config.tags.has_key(b.texttag):
-                warning('[%s] missing tag texttag' % b.name)
-            if b.type == 'labeled':
-                if not b.entrytag or not config.tags.has_key(b.entrytag):
-                    warning('[%s] missing entrytag' % b.name)
-                if not b.labeltag or not config.tags.has_key(b.labeltag):
-                    warning('[%s] missing labeltag' % b.name)
+            b.validate()
+    def dump(self):
+        AbstractBlocks.dump(self)
+        for k,v in self.tags.items():
+            dump_section('listtags-'+k, v)
+
 
 class DelimitedBlock(AbstractBlock):
     def __init__(self):
         AbstractBlock.__init__(self)
-        self.CONF_ENTRIES += ('delimiter','template','filter')
-        self.OPTIONS = ('skip','sectionbody','list')
-        self.start = None   # File reader cursor at start delimiter.
     def load(self,name,entries):
         AbstractBlock.load(self,name,entries)
     def dump(self):
@@ -2368,14 +2419,13 @@ class DelimitedBlock(AbstractBlock):
         if 'list' in self.options:
             lists.listblock = self
         reader.read()   # Discard delimiter.
-        self.start = reader.cursor[:]
         attrs = {}
         # Leave list block attributes for the list element.
         if lists.listblock is not self:
             BlockTitle.consume(attrs)
             AttributeList.consume(attrs)
         self.merge_attributes(attrs)
-        options = self.get_options()
+        options = self.parameters.options
         if safe() and self.name == 'blockdef-backend':
             unsafe_error('Backend Block')
             # Discard block body.
@@ -2384,7 +2434,7 @@ class DelimitedBlock(AbstractBlock):
             # Discard block body.
             reader.read_until(self.delimiter,same_file=True)
         else:
-            template = self.get_template()
+            template = self.parameters.template
             stag,etag = config.section2tags(template,self.attributes)
             if 'sectionbody' in options or 'list' in options:
                 # The body is treated like a SimpleSection.
@@ -2393,18 +2443,18 @@ class DelimitedBlock(AbstractBlock):
                 writer.write(etag)
             else:
                 body = reader.read_until(self.delimiter,same_file=True)
-                presubs,postsubs = self.get_subs()
+                presubs = self.parameters.presubs
+                postsubs = self.parameters.postsubs
                 body = Lex.subs(body,presubs)
-                if self.get_filter():
-                    body = filter_lines(self.get_filter(),body,self.attributes)
+                if self.parameters.filter:
+                    body = filter_lines(self.parameters.filter,body,self.attributes)
                 body = Lex.subs(body,postsubs)
                 # Write start tag, content, end tag.
                 writer.write(dovetail_tags(stag,body,etag))
         if 'list' in options:
             lists.listblock = None
         if reader.eof():
-            error('missing %s block closing delimiter' % self.name.split('-')[-1],
-                  cursor=self.start)
+            self.error('missing closing delimiter',self.start)
         else:
             delimiter = reader.read()   # Discard delimiter line.
             assert re.match(self.delimiter,delimiter)
@@ -2423,372 +2473,384 @@ class DelimitedBlocks(AbstractBlocks):
 
 class Column:
     """Table column."""
-    def __init__(self):
-        self.colalign = None    # 'left','right','center'
-        self.rulerwidth = None
-        self.colwidth = None    # Output width in page units.
+    def __init__(self, width=None, align=None, style=None):
+        self.width=width or '1'
+        self.align=align or '<'
+        self.style=style      # Style name or None.
+        # Calculated attribute values.
+        self.colalign=None    # 'left','center','right'.
+        self.abswidth=None    # 1..   (page units).
+        self.pcwidth=None     # 1..99 (percentage).
 
 class Table(AbstractBlock):
-    COL_STOP = r"(`|'|\.)"  # RE.
-    ALIGNMENTS = {'`':'left', "'":'right', '.':'center'}
-    FORMATS = ('fixed','csv','dsv')
+    ALIGNMENTS = {'<':'left', '>':'right', '^':'center'}
+    FORMATS = ('psv','csv','dsv')
+    SEPARATORS = dict(
+                    csv=',',
+                    dsv=r':|\n',
+                    psv=r'((?P<cellcount>\d+)\*)?\|',
+                )
     def __init__(self):
         AbstractBlock.__init__(self)
-        self.CONF_ENTRIES += ('template','fillchar','format','colspec',
-                              'headrow','footrow','bodyrow','headdata',
-                              'footdata', 'bodydata')
-        # Configuration parameters.
-        self.fillchar=None
-        self.format=None    # 'fixed','csv','dsv'
-        self.colspec=None
-        self.headrow=None
-        self.footrow=None
-        self.bodyrow=None
-        self.headdata=None
-        self.footdata=None
-        self.bodydata=None
+        self.CONF_ENTRIES += ('format','tags','separator')
+        # tabledef conf file parameters.
+        self.format='psv'
+        self.separator=None
+        self.tags=None          # Name of tabletags-<tags> conf section.
         # Calculated parameters.
-        self.underline=None     # RE matching current table underline.
-        self.isnumeric=False    # True if numeric ruler.
-        self.tablewidth=None    # Optional table width scale factor.
+        self.abswidth=None      # 1..   (page units).
+        self.pcwidth = None     # 1..99 (percentage).
+        self.rows=[]            # Parsed rows, each row is a list of cell data.
         self.columns=[]         # List of Columns.
-        # Other.
-        self.check_msg=''       # Message set by previous self.validate() call.
     def load(self,name,entries):
         AbstractBlock.load(self,name,entries)
-        """Update table definition from section entries in 'entries'."""
-        for k,v in entries.items():
-            if k == 'fillchar':
-                if v and len(v) == 1:
-                    self.fillchar = v
-                else:
-                    raise EAsciiDoc,'malformed table fillchar: %s' % v
-            elif k == 'format':
-                if v in Table.FORMATS:
-                    self.format = v
-                else:
-                    raise EAsciiDoc,'illegal table format: %s' % v
-            elif k == 'colspec':
-                self.colspec = v
-            elif k == 'headrow':
-                self.headrow = v
-            elif k == 'footrow':
-                self.footrow = v
-            elif k == 'bodyrow':
-                self.bodyrow = v
-            elif k == 'headdata':
-                self.headdata = v
-            elif k == 'footdata':
-                self.footdata = v
-            elif k == 'bodydata':
-                self.bodydata = v
     def dump(self):
         AbstractBlock.dump(self)
         write = lambda s: sys.stdout.write('%s%s' % (s,writer.newline))
-        write('fillchar='+self.fillchar)
         write('format='+self.format)
-        if self.colspec:
-            write('colspec='+self.colspec)
-        if self.headrow:
-            write('headrow='+self.headrow)
-        if self.footrow:
-            write('footrow='+self.footrow)
-        write('bodyrow='+self.bodyrow)
-        if self.headdata:
-            write('headdata='+self.headdata)
-        if self.footdata:
-            write('footdata='+self.footdata)
-        write('bodydata='+self.bodydata)
         write('')
     def validate(self):
         AbstractBlock.validate(self)
-        """Check table definition and set self.check_msg if invalid else set
-        self.check_msg to blank string."""
+        if self.format not in Table.FORMATS:
+            self.error('illegal format=%s' % self.format,halt=True)
+        self.tags = self.tags or 'default'
+        tags = [self.tags]
+        tags += [s['tags'] for s in self.styles.values() if 'tags' in s]
+        for t in tags:
+            if t not in tables.tags:
+                self.error('missing section: [tabletags-%s]' % t,halt=True)
+        if self.separator:
+            # Evaluate escape characters.
+            self.separator = eval('"'+self.separator+'"')
+        #TODO: Move to class Tables
         # Check global table parameters.
-        if config.textwidth is None:
-            self.check_msg = 'missing [miscellaneous] textwidth entry'
         elif config.pagewidth is None:
-            self.check_msg = 'missing [miscellaneous] pagewidth entry'
+            self.error('missing [miscellaneous] entry: pagewidth')
         elif config.pageunits is None:
-            self.check_msg = 'missing [miscellaneous] pageunits entry'
-        elif self.headrow is None:
-            self.check_msg = 'missing headrow entry'
-        elif self.footrow is None:
-            self.check_msg = 'missing footrow entry'
-        elif self.bodyrow is None:
-            self.check_msg = 'missing bodyrow entry'
-        elif self.headdata is None:
-            self.check_msg = 'missing headdata entry'
-        elif self.footdata is None:
-            self.check_msg = 'missing footdata entry'
-        elif self.bodydata is None:
-            self.check_msg = 'missing bodydata entry'
+            self.error('missing [miscellaneous] entry: pageunits')
+    def validate_attributes(self):
+        """Validate and parse table attributes."""
+        # Set defaults.
+        format = self.format
+        tags = self.tags
+        separator = self.separator
+        abswidth = float(config.pagewidth)
+        pcwidth = 100.0
+        for k,v in self.attributes.items():
+            if k == 'format':
+                if v not in self.FORMATS:
+                    self.error('illegal %s=%s' % (k,v))
+                else:
+                    format = v
+            elif k == 'tags':
+                if v not in tables.tags:
+                    self.error('illegal %s=%s' % (k,v))
+                else:
+                    tags = v
+            elif k == 'separator':
+                separator = v
+            elif k == 'width':
+                if not re.match(r'^\d{1,3}%$',v) or int(v[:-1]) > 100:
+                    self.error('illegal %s=%s' % (k,v))
+                else:
+                    abswidth = float(v[:-1])/100 * config.pagewidth
+                    pcwidth = float(v[:-1])
+        # Calculate separator if it has not been specified.
+        if not separator:
+            separator = Table.SEPARATORS[format]
+        if format == 'csv':
+            if len(separator) > 1:
+                self.error('illegal csv separator=%s' % separator)
+                separator = ','
         else:
-            # No errors.
-            self.check_msg = ''
-    def isnext(self):
-        return AbstractBlock.isnext(self)
-    def parse_ruler(self,ruler):
-        """Parse ruler calculating underline and ruler column widths."""
-        fc = re.escape(self.fillchar)
-        # Strip and save optional tablewidth from end of ruler.
-        mo = re.match(r'^(.*'+fc+r'+)([\d\.]+)$',ruler)
-        if mo:
-            ruler = mo.group(1)
-            self.tablewidth = float(mo.group(2))
-            self.attributes['tablewidth'] = str(float(self.tablewidth))
+            if not is_regexp(separator):
+                self.error('illegal regular expression: separator=%s' %
+                        separator)
+        self.parameters.format = format
+        self.parameters.tags = tags
+        self.parameters.separator = separator
+        self.abswidth = abswidth
+        self.pcwidth = pcwidth
+    def get_tags(self,params):
+        tags = self.get_param('tags',params)
+        assert(tags and tags in tables.tags)
+        return tables.tags[tags]
+    def get_style(self,prefix):
+        """
+        Return the style dictionary whose name starts with 'prefix'.
+        """
+        if prefix is None:
+            return None
+        names = self.styles.keys()
+        names.sort()
+        for name in names:
+            if name.startswith(prefix):
+                return self.styles[name]
         else:
-            self.tablewidth = None
-            self.attributes['tablewidth'] = '100.0'
-        # Guess whether column widths are specified numerically or not.
-        if ruler[1] != self.fillchar:
-            # If the first column does not start with a fillchar then numeric.
-            self.isnumeric = True
-        elif ruler[1:] == self.fillchar*len(ruler[1:]):
-            # The case of one column followed by fillchars is numeric.
-            self.isnumeric = True
+            self.error('missing style: %s*' % prefix)
+            return None
+    def parse_cols(self,cols):
+        """
+        Build list of column objects from table 'cols' attribute.
+        """
+        # [<multiplier>*][<align>][<width>][<style>]
+        COLS_RE1 = r'^((?P<count>\d+)\*)?(?P<align>[<\^>])?(?P<width>\d+%?)?(?P<style>[a-zA-Z]\w*)?$'
+        # [<multiplier>*][<width>][<align>][<style>]
+        COLS_RE2 = r'^((?P<count>\d+)\*)?(?P<width>\d+%?)?(?P<align>[<\^>])?(?P<style>[a-zA-Z]\w*)?$'
+        reo1 = re.compile(COLS_RE1)
+        reo2 = re.compile(COLS_RE2)
+        cols = str(cols)
+        if re.match(r'^\d+$',cols):
+            for i in range(int(cols)):
+                self.columns.append(Column())
         else:
-            self.isnumeric = False
-        # Underlines must be 3 or more fillchars.
-        self.underline = r'^' + fc + r'{3,}$'
-        splits = re.split(self.COL_STOP,ruler)[1:]
-        # Build self.columns.
-        for i in range(0,len(splits),2):
-            c = Column()
-            c.colalign = self.ALIGNMENTS[splits[i]]
-            s = splits[i+1]
-            if self.isnumeric:
-                # Strip trailing fillchars.
-                s = re.sub(fc+r'+$','',s)
-                if s == '':
-                    c.rulerwidth = None
-                else:
-                    c.rulerwidth = int(validate(s,'int($)>0',
-                        'malformed ruler: bad width'))
-            else:   # Calculate column width from inter-fillchar intervals.
-                if not re.match(r'^'+fc+r'+$',s):
-                    raise EAsciiDoc,'malformed ruler: illegal fillchars'
-                c.rulerwidth = len(s)+1
-            self.columns.append(c)
-        # Fill in unspecified ruler widths.
-        if self.isnumeric:
-            if self.columns[0].rulerwidth is None:
-                prevwidth = 1
-            for c in self.columns:
-                if c.rulerwidth is None:
-                    c.rulerwidth = prevwidth
-                prevwidth = c.rulerwidth
-    def build_colspecs(self):
-        """Generate colwidths and colspecs. This can only be done after the
-        table arguments have been parsed since we use the table format."""
-        self.attributes['cols'] = len(self.columns)
-        # Calculate total ruler width.
-        totalwidth = 0
-        for c in self.columns:
-            totalwidth = totalwidth + c.rulerwidth
-        if totalwidth <= 0:
-            raise EAsciiDoc,'zero width table'
-        # Calculate marked up colwidths from rulerwidths.
-        for c in self.columns:
-            # Convert ruler width to output page width.
-            width = float(c.rulerwidth)
-            if self.format == 'fixed':
-                if self.tablewidth is None:
-                    # Size proportional to ruler width.
-                    colfraction = width/config.textwidth
+            for col in re.split(r'\s*,\s*',cols):
+                mo = reo1.match(col)
+                if not mo:
+                    mo = reo2.match(col)
+                if mo:
+                    count = int(mo.groupdict().get('count') or 1)
+                    for i in range(count):
+                        self.columns.append(
+                            Column(mo.group('width'), mo.group('align'),
+                                   self.get_style(mo.group('style')))
+                        )
                 else:
-                    # Size proportional to page width.
-                    colfraction = width/totalwidth
+                    self.error('illegal column spec: %s' % col,self.start)
+        # Validate widths and calculate missing widths.
+        n = 0; percents = 0; props = 0
+        for col in self.columns:
+            if col.width:
+                if col.width[-1] == '%': percents += int(col.width[:-1])
+                else: props += int(col.width)
+                n += 1
+        if percents > 0 and props > 0:
+            self.error('mixed percent and proportional widths: %s'
+                    % cols,self.start)
+        pcunits = percents > 0
+        # Fill in missing widths.
+        if n < len(self.columns) and percents < 100:
+            if pcunits:
+                width = float(100 - percents)/float(len(self.columns) - n)
             else:
-                    # Size proportional to page width.
-                colfraction = width/totalwidth
-            c.colwidth = colfraction * config.pagewidth # To page units.
-            if self.tablewidth is not None:
-                c.colwidth = c.colwidth * self.tablewidth   # Scale factor.
-                if self.tablewidth > 1:
-                    c.colwidth = c.colwidth/100 # tablewidth is in percent.
-        # Build colspecs.
-        if self.colspec:
-            cols = []
-            i = 0
-            for c in self.columns:
-                i += 1
-                self.attributes['colalign'] = c.colalign
-                self.attributes['colwidth'] = str(int(c.colwidth))
-                self.attributes['colnumber'] = str(i + 1)
-                s = subs_attrs(self.colspec,self.attributes)
+                width = 1
+            for col in self.columns:
+                if not col.width:
+                    if pcunits:
+                        col.width = str(int(width))+'%'
+                        percents += width
+                    else:
+                        col.width = str(width)
+                        props += width
+        # Calculate column alignment and absolute and percent width values.
+        percents = 0
+        for col in self.columns:
+            col.colalign = Table.ALIGNMENTS[col.align]
+            if pcunits:
+                col.pcwidth = float(col.width[:-1])
+            else:
+                col.pcwidth = (float(col.width)/props)*100
+            col.abswidth = int(self.abswidth * (col.pcwidth/100))
+            percents += col.pcwidth
+            col.pcwidth = int(col.pcwidth)
+        if round(percents) > 100:
+            self.error('total width exceeds 100%%: %s' % cols,self.start)
+        elif round(percents) < 100:
+            self.error('total width less than 100%%: %s' % cols,self.start)
+    def build_colspecs(self):
+        """
+        Generate column related substitution attributes.
+        """
+        cols = []
+        i = 0
+        for col in self.columns:
+            i += 1
+            colspec = self.get_tags(col.style).colspec
+            if colspec:
+                self.attributes['colalign'] = col.colalign
+                self.attributes['colabswidth'] = col.abswidth
+                self.attributes['colpcwidth'] = col.pcwidth
+                self.attributes['colnumber'] = str(i+1)
+                s = subs_attrs(colspec, self.attributes)
                 if not s:
                     warning('colspec dropped: contains undefined attribute')
                 else:
                     cols.append(s)
+        if cols:
             self.attributes['colspecs'] = writer.newline.join(cols)
-    def split_rows(self,rows):
-        """Return a two item tuple containing a list of lines up to but not
-        including the next underline (continued lines are joined ) and the
-        tuple of all lines after the underline."""
-        reo = re.compile(self.underline)
-        i = 0
-        while not reo.match(rows[i]):
-            i = i+1
-        if i == 0:
-            raise EAsciiDoc,'missing table rows'
-        if i >= len(rows):
-            raise EAsciiDoc,'closing [%s] underline expected' % self.name
-        return (join_lines(rows[:i]), rows[i+1:])
-    def parse_rows(self, rows, rtag, dtag):
-        """Parse rows list using the row and data tags. Returns a substituted
-        list of output lines."""
-        result = []
-        # Source rows are parsed as single block, rather than line by line, to
-        # allow the CSV reader to handle multi-line rows.
-        if self.format == 'fixed':
-            rows = self.parse_fixed(rows)
-        elif self.format == 'csv':
-            rows = self.parse_csv(rows)
-        elif self.format == 'dsv':
-            rows = self.parse_dsv(rows)
+    def parse_rows(self, text):
+        """
+        Parse the table source text into self.rows (a list of rows, each row
+        is a list of raw cell text.
+        """
+        if self.parameters.format in ('psv','dsv'):
+            cells = self.parse_psv_dsv(text)
+            colcount = len(self.columns)
+            for i in range(0, len(cells), colcount):
+                self.rows.append(cells[i:i+colcount])
+        elif self.parameters.format == 'csv':
+            self.parse_csv(text)
         else:
             assert True,'illegal table format'
-        # Substitute and indent all data in all rows.
+    def subs_rows(self, rows, rowtype='body'):
+        """
+        Return a string of output markup from a list of rows, each row
+        is a list of raw cell text.
+        """
+        tags = tables.tags[self.parameters.tags]
+        if rowtype == 'header':
+            rtag = tags.headrow
+        elif rowtype == 'footer':
+            rtag = tags.footrow
+        else:
+            rtag = tags.bodyrow
+        result = []
         stag,etag = subs_tag(rtag,self.attributes)
         for row in rows:
-            result.append('  '+stag)
-            for data in self.subs_row(row,dtag):
-                result.append('    '+data)
-            result.append('  '+etag)
-        return result
-    def subs_row(self, data, dtag):
-        """Substitute the list of source row data elements using the data tag.
-        Returns a substituted list of output table data items."""
-        result = []
-        if len(data) < len(self.columns):
-            warning('fewer row data items then table columns')
-        if len(data) > len(self.columns):
+            result.append(stag)
+            result += self.subs_row(row,rowtype)
+            result.append(etag)
+        return writer.newline.join(result)
+    def subs_row(self, row, rowtype):
+        """
+        Substitute the list of cells using the cell data tag.
+        Returns a list of marked up table cell elements.
+        """
+        if len(row) < len(self.columns):
+            warning('fewer row data items than table columns')
+        if len(row) > len(self.columns):
             warning('more row data items than table columns')
+        result = []
         for i in range(len(self.columns)):
-            if i > len(data) - 1:
-                d = ''  # Fill missing column data with blanks.
+            col = self.columns[i]
+            tags = self.get_tags(col.style)
+            self.attributes['colalign'] = col.colalign
+            self.attributes['colabswidth'] = col.abswidth
+            self.attributes['colpcwidth'] = col.pcwidth
+            self.attributes['colnumber'] = str(i+1)
+            if rowtype == 'header':
+                dtag = tags.headdata
+            elif rowtype == 'footer':
+                dtag = tags.footdata
             else:
-                d = data[i]
-            c = self.columns[i]
-            self.attributes['colalign'] = c.colalign
-            self.attributes['colwidth'] = str(int(c.colwidth))
-            self.attributes['colnumber'] = str(i + 1)
-            stag,etag = subs_tag(dtag,self.attributes)
-            # Insert AsciiDoc line break (' +') where row data has newlines
-            # ('\n').  This is really only useful when the table format is csv
-            # and the output markup is HTML. It's also a bit dubious in that it
-            # assumes the user has not modified the shipped line break pattern.
-            subs = self.get_subs()[0]
-            if 'replacements' in subs:
-                # Insert line breaks in cell data.
-                d = re.sub(r'(?m)\n',r' +\n',d)
-                d = d.split('\n')    # So writer.newline is written.
+                dtag = tags.bodydata
+            # Fill missing column data with blanks.
+            if i > len(row) - 1:
+                data = ''
             else:
-                d = [d]
-            result = result + [stag] + Lex.subs(d,subs) + [etag]
-        return result
-    def parse_fixed(self,rows):
-        """Parse the list of source table rows. Each row item in the returned
-        list contains a list of cell data elements."""
-        result = []
-        for row in rows:
-            data = []
-            start = 0
-            # build an encoded representation
-            row = char_decode(row)
-            for c in self.columns:
-                end = start + c.rulerwidth
-                if c is self.columns[-1]:
-                    # Text in last column can continue forever.
-                    # Use the encoded string to slice, but convert back
-                    # to plain string before further processing
-                    data.append(char_encode(row[start:]).strip())
-                else:
-                    data.append(char_encode(row[start:end]).strip())
-                start = end
-            result.append(data)
+                data = row[i]
+            # Format header cells with the table style not column style.
+            if rowtype == 'header':
+                colstyle = None
+            else:
+                colstyle = col.style
+            presubs,postsubs = self.get_subs(colstyle)
+            data = [data]
+            data = Lex.subs(data, presubs)
+            data = filter_lines(self.get_param('filter',colstyle),
+                                data, self.attributes)
+            data = Lex.subs(data, postsubs)
+            if rowtype != 'header':
+                ptag = tags.paragraph
+                if ptag:
+                    stag,etag = subs_tag(ptag,self.attributes)
+                    text = '\n'.join(data).strip()
+                    data = []
+                    for para in re.split(r'\n{2,}',text):
+                        data += dovetail_tags([stag],para.split('\n'),[etag])
+            stag,etag = subs_tag(dtag,self.attributes)
+            result = result + dovetail_tags([stag],data,[etag])
         return result
-    def parse_csv(self,rows):
-        """Parse the list of source table rows. Each row item in the returned
-        list contains a list of cell data elements."""
+    def parse_csv(self,text):
+        """
+        Parse the table source text and return a list of rows, each row
+        is a list of raw cell text.
+        """
         import StringIO
         import csv
-        result = []
-        rdr = csv.reader(StringIO.StringIO('\r\n'.join(rows)),
-            skipinitialspace=True)
+        self.rows = []
+        rdr = csv.reader(StringIO.StringIO('\r\n'.join(text)),
+                     delimiter=self.parameters.separator, skipinitialspace=True)
         try:
             for row in rdr:
-                result.append(row)
+                self.rows.append(row)
         except:
-            raise EAsciiDoc,'csv parse error: %s' % row
-        return result
-    def parse_dsv(self,rows):
-        """Parse the list of source table rows. Each row item in the returned
-        list contains a list of cell data elements."""
-        separator = self.attributes.get('separator',':')
-        separator = eval('"'+separator+'"')
-        if len(separator) != 1:
-            raise EAsciiDoc,'malformed dsv separator: %s' % separator
-        # TODO If separator is preceeded by an odd number of backslashes then
-        # it is escaped and should not delimit.
-        result = []
-        for row in rows:
-            # Skip blank lines
-            if row == '': continue
-            # Unescape escaped characters.
-            row = eval('"'+row.replace('"','\\"')+'"')
-            data = row.split(separator)
-            data = [s.strip() for s in data]
-            result.append(data)
-        return result
+            self.error('csv parse error: %s' % row)
+    def parse_psv_dsv(self,text):
+        """
+        Parse list of PSV or DSV table source text lines and return a list of
+        cells.
+        """
+        text = '\n'.join(text)
+        separator = '(?msu)'+self.parameters.separator
+        format = self.parameters.format
+        start = 0
+        cellcount = 1
+        cells = []
+        cell = ''
+        for mo in re.finditer(separator,text):
+            cell += text[start:mo.start()]
+            if cell.endswith('\\'):
+                cell = cell[:-1]+mo.group() # Reinstate escaped separators.
+            else:
+                for i in range(cellcount):
+                    cells.append(cell)
+                cellcount = int(mo.groupdict().get('cellcount') or '1')
+                cell = ''
+            start = mo.end()
+        # Last cell follows final separator.
+        cell += text[start:]
+        for i in range(cellcount):
+            cells.append(cell)
+        # We expect a dummy blank item preceeding first PSV cell.
+        if format == 'psv':
+            if cells[0] != '':
+                self.error('missing leading separator: %s' % separator,
+                        self.start)
+            else:
+                cells.pop(0)
+        return cells
     def translate(self):
         AbstractBlock.translate(self)
+        reader.read()   # Discard delimiter.
         # Reset instance specific properties.
-        self.underline = None
         self.columns = []
+        self.rows = []
         attrs = {}
         BlockTitle.consume(attrs)
-        # Add relevant globals to table substitutions.
-        attrs['pagewidth'] = str(config.pagewidth)
-        attrs['pageunits'] = config.pageunits
         # Mix in document attribute list.
         AttributeList.consume(attrs)
-        # Validate overridable attributes.
-        for k,v in attrs.items():
-            if k == 'format':
-                if v not in self.FORMATS:
-                    raise EAsciiDoc, 'illegal [%s] %s: %s' % (self.name,k,v)
-                self.format = v
-            elif k == 'tablewidth':
-                try:
-                    self.tablewidth = float(attrs['tablewidth'])
-                except:
-                    raise EAsciiDoc, 'illegal [%s] %s: %s' % (self.name,k,v)
         self.merge_attributes(attrs)
-        # Parse table ruler.
-        ruler = reader.read()
-        assert re.match(self.delimiter,ruler)
-        self.parse_ruler(ruler)
+        self.validate_attributes()
+        # Add global and calculated configuration parameters.
+        self.attributes['pagewidth'] = config.pagewidth
+        self.attributes['pageunits'] = config.pageunits
+        self.attributes['tableabswidth'] = int(self.abswidth)
+        self.attributes['tablepcwidth'] = int(self.pcwidth)
         # Read the entire table.
-        table = []
-        while True:
-            line = reader.read_next()
-            # Table terminated by underline followed by a blank line or EOF.
-            if len(table) > 0 and re.match(self.underline,table[-1]):
-                if line in ('',None):
-                    break;
-            if line is None:
-                raise EAsciiDoc,'closing [%s] underline expected' % self.name
-            table.append(reader.read())
-        # EXPERIMENTAL: The number of lines in the table, requested by Benjamin Klum.
-        self.attributes['rows'] = str(len(table))
-        #TODO: Inherited validate() doesn't set check_msg, needs checking.
-        if self.check_msg:  # Skip if table definition was marked invalid.
-            warning('skipping %s table: %s' % (self.name,self.check_msg))
+        text = reader.read_until(self.delimiter)
+        if reader.eof():
+            self.error('missing closing delimiter',self.start)
+        else:
+            delimiter = reader.read()   # Discard closing delimiter.
+            assert re.match(self.delimiter,delimiter)
+        if len(text) == 0:
+            warning('[%s] table is empty' % self.name)
             return
-        # Generate colwidths and colspecs.
+        cols = attrs.get('cols')
+        if not cols:
+            # Calculate column count from number of items in first line.
+            if self.parameters.format == 'csv':
+                cols = text[0].count(self.parameters.separator)
+            else:
+                cols = len(self.parse_psv_dsv(text[:1]))
+        self.parse_cols(cols)
+        # Set calculated attributes.
+        self.attributes['colcount'] = len(self.columns)
         self.build_colspecs()
+        self.parse_rows(text)
+        # The 'rowcount' attribute is used by the experimental LaTeX backend.
+        self.attributes['rowcount'] = str(len(self.rows))
         # Generate headrows, footrows, bodyrows.
         # Headrow, footrow and bodyrow data replaces same named attributes in
         # the table markup template. In order to ensure this data does not get
@@ -2796,25 +2858,20 @@ class Table(AbstractBlock):
         # already substituted inline passthroughs) unique placeholders are used
         # (the tab character does not appear elsewhere since it is expanded on
         # input) which are replaced after template attribute substitution.
-        headrows = footrows = []
-        bodyrows,table = self.split_rows(table)
-        if table:
-            headrows = bodyrows
-            bodyrows,table = self.split_rows(table)
-            if table:
-                footrows,table = self.split_rows(table)
-        if headrows:
-            headrows = self.parse_rows(headrows, self.headrow, self.headdata)
-            headrows = writer.newline.join(headrows)
+        headrows = footrows = bodyrows = None
+        if self.rows and 'header' in self.parameters.options:
+            headrows = self.subs_rows(self.rows[0:1],'header')
             self.attributes['headrows'] = '\theadrows\t'
-        if footrows:
-            footrows = self.parse_rows(footrows, self.footrow, self.footdata)
-            footrows = writer.newline.join(footrows)
+            self.rows = self.rows[1:]
+        if self.rows and 'footer' in self.parameters.options:
+            footrows = self.subs_rows( self.rows[-1:], 'footer')
             self.attributes['footrows'] = '\tfootrows\t'
-        bodyrows = self.parse_rows(bodyrows, self.bodyrow, self.bodydata)
-        bodyrows = writer.newline.join(bodyrows)
-        self.attributes['bodyrows'] = '\tbodyrows\t'
-        table = subs_attrs(config.sections[self.template],self.attributes)
+            self.rows = self.rows[:-1]
+        if self.rows:
+            bodyrows = self.subs_rows(self.rows)
+            self.attributes['bodyrows'] = '\tbodyrows\t'
+        table = subs_attrs(config.sections[self.parameters.template],
+                           self.attributes)
         table = writer.newline.join(table)
         # Before we finish replace the table head, foot and body place holders
         # with the real data.
@@ -2822,72 +2879,85 @@ class Table(AbstractBlock):
             table = table.replace('\theadrows\t', headrows, 1)
         if footrows:
             table = table.replace('\tfootrows\t', footrows, 1)
-        table = table.replace('\tbodyrows\t', bodyrows, 1)
+        if bodyrows:
+            table = table.replace('\tbodyrows\t', bodyrows, 1)
         writer.write(table)
 
 class Tables(AbstractBlocks):
     """List of tables."""
     BLOCK_TYPE = Table
     PREFIX = 'tabledef-'
+    TAGS = ('colspec', 'headrow','footrow','bodyrow',
+            'headdata','footdata', 'bodydata','paragraph')
     def __init__(self):
         AbstractBlocks.__init__(self)
+        # Table tags dictionary. Each entry is a tags dictionary.
+        self.tags={}
     def load(self,sections):
         AbstractBlocks.load(self,sections)
-        """Update tables defined in 'sections' dictionary."""
+        self.load_tags(sections)
+    def load_tags(self,sections):
+        """
+        Load tabletags-* conf file sections to self.tags.
+        """
+        for section in sections.keys():
+            mo = re.match(r'^tabletags-(?P<name>\w+)$',section)
+            if mo:
+                name = mo.group('name')
+                if self.tags.has_key(name):
+                    d = self.tags[name]
+                else:
+                    d = AttrDict()
+                parse_entries(sections.get(section,()),d)
+                for k in d.keys():
+                    if k not in self.TAGS:
+                        warning('[%s] contains illegal table tag: %s' %
+                                (section,k))
+                self.tags[name] = d
     def validate(self):
-        # Does not call AbstractBlocks.validate().
+        AbstractBlocks.validate(self)
         # Check we have a default table definition,
         for i in range(len(self.blocks)):
             if self.blocks[i].name == 'tabledef-default':
                 default = self.blocks[i]
                 break
         else:
-            raise EAsciiDoc,'missing [table-default] section'
-        # Set default table defaults.
-        if default.format is None: default.subs = 'fixed'
+            raise EAsciiDoc,'missing [tabledef-default] section'
         # Propagate defaults to unspecified table parameters.
         for b in self.blocks:
             if b is not default:
-                if b.fillchar is None: b.fillchar = default.fillchar
                 if b.format is None: b.format = default.format
                 if b.template is None: b.template = default.template
-                if b.colspec is None: b.colspec = default.colspec
-                if b.headrow is None: b.headrow = default.headrow
-                if b.footrow is None: b.footrow = default.footrow
-                if b.bodyrow is None: b.bodyrow = default.bodyrow
-                if b.headdata is None: b.headdata = default.headdata
-                if b.footdata is None: b.footdata = default.footdata
-                if b.bodydata is None: b.bodydata = default.bodydata
-        # Check all tables have valid fill character.
-        for b in self.blocks:
-            if not b.fillchar or len(b.fillchar) != 1:
-                raise EAsciiDoc,'[%s] missing or illegal fillchar' % b.name
-        # Build combined tables delimiter patterns and assign defaults.
-        delimiters = []
-        for b in self.blocks:
-            # Ruler is:
-            #   (ColStop,(ColWidth,FillChar+)?)+, FillChar+, TableWidth?
-            b.delimiter = r'^(' + Table.COL_STOP \
-                + r'(\d*|' + re.escape(b.fillchar) + r'*)' \
-                + r')+' \
-                + re.escape(b.fillchar) + r'+' \
-                + '([\d\.]*)$'
-            delimiters.append(b.delimiter)
-            if not b.headrow:
-                b.headrow = b.bodyrow
-            if not b.footrow:
-                b.footrow = b.bodyrow
-            if not b.headdata:
-                b.headdata = b.bodydata
-            if not b.footdata:
-                b.footdata = b.bodydata
-        self.delimiter = join_regexp(delimiters)
+        # Check tags and propagate default tags.
+        if not 'default' in self.tags:
+            raise EAsciiDoc,'missing [tabletags-default] section'
+        default = self.tags['default']
+        for tag in ('bodyrow','bodydata','paragraph'): # Mandatory default tags.
+            if tag not in default:
+                raise EAsciiDoc,'missing [tabletags-default] entry: %s' % tag
+        for t in self.tags.values():
+            if t is not default:
+                if t.colspec is None: t.colspec = default.colspec
+                if t.headrow is None: t.headrow = default.headrow
+                if t.footrow is None: t.footrow = default.footrow
+                if t.bodyrow is None: t.bodyrow = default.bodyrow
+                if t.headdata is None: t.headdata = default.headdata
+                if t.footdata is None: t.footdata = default.footdata
+                if t.bodydata is None: t.bodydata = default.bodydata
+                if t.paragraph is None: t.paragraph = default.paragraph
+        # Use body tags if header and footer tags are not specified.
+        for t in self.tags.values():
+            if not t.headrow: t.headrow = t.bodyrow
+            if not t.footrow: t.footrow = t.bodyrow
+            if not t.headdata: t.headdata = t.bodydata
+            if not t.footdata: t.footdata = t.bodydata
         # Check table definitions are valid.
         for b in self.blocks:
             b.validate()
-            if config.verbose:
-                if b.check_msg:
-                    warning('[%s] table definition: %s' % (b.name,b.check_msg))
+    def dump(self):
+        AbstractBlocks.dump(self)
+        for k,v in self.tags.items():
+            dump_section('tabletags-'+k, v)
 
 class Macros:
     # Default system macro syntax.
@@ -2896,6 +2966,7 @@ class Macros:
     def __init__(self):
         self.macros = []        # List of Macros.
         self.current = None     # The last matched block macro.
+        self.passthroughs = []
         # Initialize default system macro.
         m = Macro()
         m.pattern = self.SYS_DEFAULT
@@ -2924,7 +2995,11 @@ class Macros:
         write('[macros]')
         # Dump all macros except the first (built-in system) macro.
         for m in self.macros[1:]:
-            write('%s=%s%s' % (m.pattern,m.prefix,m.name))
+            # Escape = in pattern.
+            macro = '%s=%s%s' % (m.pattern.replace('=',r'\='), m.prefix, m.name)
+            if m.subslist is not None:
+                macro += '[' + ','.join(m.subslist) + ']'
+            write(macro)
         write('')
     def validate(self):
         # Check all named sections exist.
@@ -2964,72 +3039,20 @@ class Macros:
                     if re.match(name,mo.group('name')):
                         return mo
         return None
-
-# Macro set just prior to calling _subs_macro(). Ugly but there's no way
-# to pass optional arguments with _subs_macro().
-_macro = None
-
-def _subs_macro(mo):
-    """Function called to perform inline macro substitution. Uses matched macro
-    regular expression object and returns string containing the substituted
-    macro body. Called by Macros().subs()."""
-    # Check if macro reference is escaped.
-    if mo.group()[0] == '\\':
-        return mo.group()[1:]   # Strip leading backslash.
-    d = mo.groupdict()
-    # Delete groups that didn't participate in match.
-    for k,v in d.items():
-        if v is None: del d[k]
-    if _macro.name:
-        name = _macro.name
-    else:
-        if not d.has_key('name'):
-            warning('missing macro name group: %s' % mo.re.pattern)
-            return ''
-        name = d['name']
-    section_name = _macro.section_name(name)
-    if not section_name:
-        return ''
-    # If we're dealing with a block macro get optional block ID and block title.
-    if _macro.prefix == '#':
-        AttributeList.consume(d)
-        BlockTitle.consume(d)
-    # Parse macro attributes.
-    if d.has_key('attrlist'):
-        if d['attrlist'] in (None,''):
-            del d['attrlist']
-        else:
-            parse_attributes(d['attrlist'],d)
-    if name == 'callout':
-        listindex =int(d['index'])
-        d['coid'] = calloutmap.add(listindex)
-    # Unescape special characters in LaTeX target file names.
-    if document.backend == 'latex' and d.has_key('target') and d['target']:
-        if not d.has_key('0'):
-            d['0'] = d['target']
-        d['target']= config.subs_specialchars_reverse(d['target'])
-    # BUG: We've already done attribute substitution on the macro which means
-    # that any escaped attribute references are now unescaped and will be
-    # substituted by config.subs_section() below. As a partial fix have withheld
-    # {0} from substitution but this kludge doesn't fix it for other attributes
-    # containing unescaped references.
-    a0 = d.get('0')
-    if a0:
-        d['0'] = chr(0)  # Replace temporarily with unused character.
-    body = config.subs_section(section_name,d)
-    if len(body) == 0:
-        result = ''
-    elif len(body) == 1:
-        result = body[0]
-    else:
-        if _macro.prefix == '#':
-            result = writer.newline.join(body)
-        else:
-            # Internally processed inline macros use UNIX line separator.
-            result = '\n'.join(body)
-    if a0:
-        result = result.replace(chr(0), a0)
-    return result
+    def extract_passthroughs(self,text,prefix=''):
+        """ Extract the passthrough text and replace with temporary
+        placeholders."""
+        self.passthroughs = []
+        for m in self.macros:
+            if m.has_passthrough() and m.prefix == prefix:
+                text = m.subs_passthroughs(text, self.passthroughs)
+        return text
+    def restore_passthroughs(self,text):
+        """ Replace passthough placeholders with the original passthrough
+        text."""
+        for i,v in enumerate(self.passthroughs):
+            text = text.replace('\t'+str(i)+'\t', self.passthroughs[i], 1)
+        return text
 
 class Macro:
     def __init__(self):
@@ -3037,6 +3060,9 @@ class Macro:
         self.name = ''          # Conf file macro name (None if implicit).
         self.prefix = ''        # '' if inline, '+' if system, '#' if block.
         self.reo = None         # Compiled pattern re object.
+        self.subslist = None    # Default subs for macros passtext group.
+    def has_passthrough(self):
+        return self.pattern.find(r'(?P<passtext>') >= 0
     def section_name(self,name=None):
         """Return macro markup template section name based on macro name and
         prefix.  Return None section not found."""
@@ -3051,7 +3077,7 @@ class Macro:
         if config.sections.has_key(name+suffix):
             return name+suffix
         else:
-            warning('missing macro section: [%s]' % name+suffix)
+            warning('missing macro section: [%s]' % (name+suffix))
             return None
     def equals(self,m):
         if self.pattern != m.pattern:
@@ -3066,29 +3092,161 @@ class Macro:
         if not e:
             raise EAsciiDoc,'malformed macro entry: %s' % entry
         if not is_regexp(e[0]):
-            raise EAsciiDoc,'illegal %s macro regular expression: %s' \
-                % (e[1],e[0])
-        self.pattern, self.name = e
-        self.reo = re.compile(self.pattern)
-        if self.name:
-            if self.name[0] in ('+','#'):
-                self.prefix, self.name = self.name[0], self.name[1:]
-        if self.name and not is_name(self.name):
+            raise EAsciiDoc,'illegal macro regular expression: %s' % e[0]
+        pattern, name = e
+        if name and name[0] in ('+','#'):
+            prefix, name = name[0], name[1:]
+        else:
+            prefix = ''
+        # Parse passthrough subslist.
+        mo = re.match(r'^(?P<name>[^[]*)(\[(?P<subslist>.*)\])?$', name)
+        name = mo.group('name')
+        if name and not is_name(name):
             raise EAsciiDoc,'illegal section name in macro entry: %s' % entry
+        subslist = mo.group('subslist')
+        if subslist is not None:
+            # Parse and validate passthrough subs.
+            subslist = parse_options(subslist, SUBS_OPTIONS,
+                                 'illegal subs in macro entry: %s' % entry)
+        self.pattern = pattern
+        self.reo = re.compile(pattern)
+        self.prefix = prefix
+        self.name = name
+        self.subslist = subslist
+
     def subs(self,text):
-        global _macro
-        _macro = self           # Pass the macro to _subs_macro().
-        return self.reo.sub(_subs_macro,text)
+        def subs_func(mo):
+            """Function called to perform inline macro substitution.
+            Uses matched macro regular expression object and returns string
+            containing the substituted macro body."""
+            # Check if macro reference is escaped.
+            if mo.group()[0] == '\\':
+                return mo.group()[1:]   # Strip leading backslash.
+            d = mo.groupdict()
+            # Delete groups that didn't participate in match.
+            for k,v in d.items():
+                if v is None: del d[k]
+            if self.name:
+                name = self.name
+            else:
+                if not d.has_key('name'):
+                    warning('missing macro name group: %s' % mo.re.pattern)
+                    return ''
+                name = d['name']
+            section_name = self.section_name(name)
+            if not section_name:
+                return ''
+            # If we're dealing with a block macro get optional block ID and
+            # block title.
+            if self.prefix == '#':
+                AttributeList.consume(d)
+                BlockTitle.consume(d)
+            # Parse macro attributes.
+            if d.has_key('attrlist'):
+                if d['attrlist'] in (None,''):
+                    del d['attrlist']
+                else:
+                    if self.prefix == '':
+                        # Unescape ] characters in inline macros.
+                        d['attrlist'] = d['attrlist'].replace('\\]',']')
+                    parse_attributes(d['attrlist'],d)
+                    # Generate option attributes.
+                    if 'options' in d:
+                        options = parse_options(d['options'], (),
+                                '%s: illegal option name' % name)
+                        for option in options:
+                            d[option+'-option'] = ''
+            if name == 'callout':
+                listindex =int(d['index'])
+                d['coid'] = calloutmap.add(listindex)
+            # Unescape special characters in LaTeX target file names.
+            if document.backend == 'latex' and d.has_key('target') and d['target']:
+                if not d.has_key('0'):
+                    d['0'] = d['target']
+                d['target']= config.subs_specialchars_reverse(d['target'])
+            # BUG: We've already done attribute substitution on the macro which
+            # means that any escaped attribute references are now unescaped and
+            # will be substituted by config.subs_section() below. As a partial
+            # fix have withheld {0} from substitution but this kludge doesn't
+            # fix it for other attributes containing unescaped references.
+            # Passthrough macros don't have this problem.
+            a0 = d.get('0')
+            if a0:
+                d['0'] = chr(0)  # Replace temporarily with unused character.
+            body = config.subs_section(section_name,d)
+            if len(body) == 0:
+                result = ''
+            elif len(body) == 1:
+                result = body[0]
+            else:
+                if self.prefix == '#':
+                    result = writer.newline.join(body)
+                else:
+                    # Internally processed inline macros use UNIX line
+                    # separator.
+                    result = '\n'.join(body)
+            if a0:
+                result = result.replace(chr(0), a0)
+            return result
+
+        return self.reo.sub(subs_func, text)
+
     def translate(self):
         """ Block macro translation."""
         assert self.prefix == '#'
         s = reader.read()
-        s = subs_attrs(s)       # Substitute global attributes.
+        if self.has_passthrough():
+            s = macros.extract_passthroughs(s,'#')
+        s = subs_attrs(s)
         if s:
             s = self.subs(s)
+            if self.has_passthrough():
+                s = macros.restore_passthroughs(s)
             if s:
                 writer.write(s)
 
+    def subs_passthroughs(self, text, passthroughs):
+        """ Replace macro attribute lists in text with placeholders.
+        Substitute and append the passthrough attribute lists to the
+        passthroughs list."""
+        def subs_func(mo):
+            """Function called to perform inline macro substitution.
+            Uses matched macro regular expression object and returns string
+            containing the substituted macro body."""
+            # Don't process escaped macro references.
+            if mo.group()[0] == '\\':
+                return mo.group()
+            d = mo.groupdict()
+            if not d.has_key('passtext'):
+                warning('passthrough macro %s: missing passtext group' %
+                        d.get('name',''))
+                return mo.group()
+            passtext = d['passtext']
+            if d.get('subslist'):
+                if d['subslist'].startswith(':'):
+                    error('block macro cannot occur here: %s' % mo.group(),
+                          halt=True)
+                subslist = parse_options(d['subslist'], SUBS_OPTIONS,
+                          'illegal passthrough macro subs option')
+            else:
+                subslist = self.subslist
+            passtext = Lex.subs_1(passtext,subslist)
+            if passtext is None: passtext = ''
+            if self.prefix == '':
+                # Unescape ] characters in inline macros.
+                passtext = passtext.replace('\\]',']')
+            passthroughs.append(passtext)
+            # Tabs guarantee the placeholders are unambiguous.
+            result = (
+                text[mo.start():mo.start('passtext')] +
+                '\t' + str(len(passthroughs)-1) + '\t' +
+                text[mo.end('passtext'):mo.end()]
+            )
+            return result
+
+        return self.reo.sub(subs_func, text)
+
+
 class CalloutMap:
     def __init__(self):
         self.comap = {}         # key = list index, value = callouts list.
@@ -3119,7 +3277,7 @@ class CalloutMap:
                 result += ' ' + self.calloutid(self.listnumber,coindex)
             return result.strip()
         else:
-            error('no callouts refer to list item '+str(listindex))
+            warning('no callouts refer to list item '+str(listindex))
             return ''
     def validate(self,maxlistindex):
         # Check that all list indexes referenced by callouts exist.
@@ -3147,8 +3305,8 @@ class Reader1:
         self.tabsize = 8        # Tab expansion number of spaces.
         self.parent = None      # Included reader's parent reader.
         self._lineno = 0        # The last line read from file object f.
-        self.include_depth = 0  # Current include depth.
-        self.include_max = 5    # Maxiumum allowed include depth.
+        self.current_depth = 0  # Current include depth.
+        self.max_depth = 5      # Initial maxiumum allowed include depth.
     def open(self,fname):
         self.fname = fname
         verbose('reading: '+fname)
@@ -3196,12 +3354,13 @@ class Reader1:
             # Check for include macro.
             mo = macros.match('+',r'include[1]?',result)
             if mo and not skip:
-                # Perform attribute substitution on inlcude macro file name.
+                # Don't process include macro once the maximum depth is reached.
+                if self.current_depth >= self.max_depth:
+                    return result
+                # Perform attribute substitution on include macro file name.
                 fname = subs_attrs(mo.group('target'))
                 if not fname:
                     return Reader1.read(self)   # Return next input line.
-                if self.include_depth >= self.include_max:
-                    raise EAsciiDoc,'maxiumum inlcude depth exceeded'
                 if self.fname != '<stdin>':
                     fname = os.path.expandvars(os.path.expanduser(fname))
                     fname = safe_filename(fname, os.path.dirname(self.fname))
@@ -3211,8 +3370,8 @@ class Reader1:
                         if not config.dumping:
                             # Store the include file in memory for later
                             # retrieval by the {include1:} system attribute.
-                            config.include1[fname] = \
-                                [s.rstrip() for s in open(fname)]
+                            config.include1[fname] = [
+                                s.rstrip() for s in open(fname)]
                             return '{include1:%s}' % fname
                         else:
                             # This is a configuration dump, just pass the macro
@@ -3225,11 +3384,21 @@ class Reader1:
                 parent = Reader1()
                 assign(parent,self)
                 self.parent = parent
+                # Set attributes in child.
                 if attrs.has_key('tabsize'):
-                    self.tabsize = int(validate(attrs['tabsize'],'int($)>=0', \
+                    self.tabsize = int(validate(attrs['tabsize'],
+                        'int($)>=0',
                         'illegal include macro tabsize argument'))
+                else:
+                    self.tabsize = config.tabsize
+                if attrs.has_key('depth'):
+                    attrs['depth'] = int(validate(attrs['depth'],
+                        'int($)>=1',
+                        'illegal include macro depth argument'))
+                    self.max_depth = self.current_depth + attrs['depth']
+                # Process included file.
                 self.open(fname)
-                self.include_depth = self.include_depth + 1
+                self.current_depth = self.current_depth + 1
                 result = Reader1.read(self)
         else:
             if not Reader1.eof(self):
@@ -3453,18 +3622,18 @@ class Writer:
             self.lines_out = self.lines_out + 1
         else:
             for arg in args:
-                if isinstance(arg,list) or isinstance(arg,tuple):
+                if is_array(arg):
                     for s in arg:
                         self.write_line(s)
                 elif arg is not None:
                     self.write_line(arg)
-    def write_tag(self,tagname,content,subs=None,d=None):
-        """Write content enveloped by configuration file tag tagname.
+    def write_tag(self,tag,content,subs=None,d=None):
+        """Write content enveloped by tag.
         Substitutions specified in the 'subs' list are perform on the
         'content'."""
         if subs is None:
             subs = config.subsnormal
-        stag,etag = config.tag(tagname,d)
+        stag,etag = subs_tag(tag,d)
         if stag:
             self.write(stag)
         if content:
@@ -3501,11 +3670,12 @@ def _subs_specialwords(mo):
 
 class Config:
     """Methods to process configuration files."""
-    # Predefined section name regexp's.
-    SPECIAL_SECTIONS= ('tags','miscellaneous','attributes','specialcharacters',
+    # Non-template section name regexp's.
+    ENTRIES_SECTIONS= ('tags','miscellaneous','attributes','specialcharacters',
             'specialwords','macros','replacements','quotes','titles',
-            r'paradef.+',r'listdef.+',r'blockdef.+',r'tabledef.*',
-            'replacements2')
+            r'paradef-.+',r'listdef-.+',r'blockdef-.+',r'tabledef-.+',
+            r'tabletags-.+',r'listtags-.+','replacements2',
+            r'old_tabledef-.+')
     def __init__(self):
         self.sections = OrderedDict()   # Keyed by section name containing
                                         # lists of section lines.
@@ -3514,7 +3684,7 @@ class Config:
         self.header_footer = True       # -s, --no-header-footer option.
         # [miscellaneous] section.
         self.tabsize = 8
-        self.textwidth = 70
+        self.textwidth = 70             # DEPRECATED: Old tables only.
         self.newline = '\r\n'
         self.pagewidth = None
         self.pageunits = None
@@ -3530,7 +3700,7 @@ class Config:
         self.replacements2 = OrderedDict()
         self.specialsections = {} # Name is special section name pattern, value
                                   # is corresponding section name.
-        self.quotes = {}        # Values contain corresponding tag name.
+        self.quotes = OrderedDict()    # Values contain corresponding tag name.
         self.fname = ''         # Most recently loaded configuration file name.
         self.conf_attrs = {}    # Glossary entries from conf files.
         self.cmd_attrs = {}     # Attributes from command-line -a options.
@@ -3538,7 +3708,7 @@ class Config:
         self.include1 = {}      # Holds include1::[] files for {include1:}.
         self.dumping = False    # True if asciidoc -c option specified.
 
-    def load(self,fname,dir=None):
+    def load_file(self,fname,dir=None):
         """Loads sections dictionary with sections from file fname.
         Existing sections are overlaid. Silently skips missing configuration
         files."""
@@ -3568,12 +3738,11 @@ class Config:
             if found:
                 if section:             # Store previous section.
                     if sections.has_key(section) \
-                        and self.is_special_section(section):
+                        and self.entries_section(section):
                         if ''.join(contents):
-                            # Merge special sections.
+                            # Merge entries.
                             sections[section] = sections[section] + contents
                         else:
-                            print 'blank section'
                             del sections[section]
                     else:
                         sections[section] = contents
@@ -3583,22 +3752,29 @@ class Config:
                 contents.append(s)
         if section and contents:        # Store last section.
             if sections.has_key(section) \
-                and self.is_special_section(section):
+                and self.entries_section(section):
                 if ''.join(contents):
-                    # Merge special sections.
+                    # Merge entries.
                     sections[section] = sections[section] + contents
                 else:
                     del sections[section]
             else:
                 sections[section] = contents
         rdr.close()
-        # Delete blank lines from sections.
+        self.load_sections(sections)
+        self.loaded.append(os.path.realpath(fname))
+
+    def load_sections(self,sections):
+        '''Loads sections dictionary. Each dictionary entry contains a
+        list of lines.
+        '''
+        # Delete trailing blank lines from sections.
         for k in sections.keys():
             for i in range(len(sections[k])-1,-1,-1):
                 if not sections[k][i]:
                     del sections[k][i]
-                elif not self.is_special_section(k):
-                    break   # Only trailing blanks from non-special sections.
+                elif not self.entries_section(k):
+                    break
         # Add/overwrite new sections.
         self.sections.update(sections)
         self.parse_tags()
@@ -3625,27 +3801,27 @@ class Config:
         paragraphs.load(sections)
         lists.load(sections)
         blocks.load(sections)
+        tables_OLD.load(sections)
         tables.load(sections)
         macros.load(sections.get('macros',()))
-        self.loaded.append(os.path.realpath(fname))
 
     def load_all(self,dir):
         """Load the standard configuration files from directory 'dir'."""
-        self.load('asciidoc.conf',dir)
+        self.load_file('asciidoc.conf',dir)
         conf = document.backend + '.conf'
-        self.load(conf,dir)
+        self.load_file(conf,dir)
         conf = document.backend + '-' + document.doctype + '.conf'
-        self.load(conf,dir)
+        self.load_file(conf,dir)
         lang = document.attributes.get('lang')
         if lang:
             conf = 'lang-' + lang + '.conf'
-            self.load(conf,dir)
+            self.load_file(conf,dir)
         # Load ./filters/*.conf files if they exist.
         filters = os.path.join(dir,'filters')
         if os.path.isdir(filters):
             for f in os.listdir(filters):
                 if re.match(r'^.+\.conf$',f):
-                    self.load(f,filters)
+                    self.load_file(f,filters)
 
     def load_miscellaneous(self,d):
         """Set miscellaneous configuration entries from dictionary 'd'."""
@@ -3657,7 +3833,7 @@ class Config:
                 else:
                     setattr(self, name, validate(d[name],rule,errmsg))
         set_misc('tabsize','int($)>0',intval=True)
-        set_misc('textwidth','int($)>0',intval=True)
+        set_misc('textwidth','int($)>0',intval=True) # DEPRECATED: Old tables only.
         set_misc('pagewidth','int($)>0',intval=True)
         set_misc('pageunits')
         set_misc('outfilesuffix')
@@ -3707,11 +3883,16 @@ class Config:
         paragraphs.validate()
         lists.validate()
         blocks.validate()
+        tables_OLD.validate()
         tables.validate()
         macros.validate()
 
-    def is_special_section(self,section_name):
-        for name in self.SPECIAL_SECTIONS:
+    def entries_section(self,section_name):
+        """
+        Return True if conf file section contains entries, not a markup
+        template.
+        """
+        for name in self.ENTRIES_SECTIONS:
             if re.match(name,section_name):
                 return True
         return False
@@ -3754,11 +3935,12 @@ class Config:
         paragraphs.dump()
         lists.dump()
         blocks.dump()
+        tables_OLD.dump()
         tables.dump()
         macros.dump()
         # Dump remaining sections.
         for k in self.sections.keys():
-            if not self.is_special_section(k):
+            if not self.entries_section(k):
                 sys.stdout.write('[%s]%s' % (k,writer.newline))
                 for line in self.sections[k]:
                     sys.stdout.write('%s%s' % (line,writer.newline))
@@ -3782,7 +3964,7 @@ class Config:
             if v is None:
                 if self.tags.has_key(k):
                     del self.tags[k]
-            elif v == 'none':
+            elif v == '':
                 self.tags[k] = (None,None)
             else:
                 mo = re.match(r'(?P<stag>.*)\|(?P<etag>.*)',v)
@@ -3836,19 +4018,25 @@ class Config:
 
     def parse_replacements(self,sect='replacements'):
         """Parse replacements section into self.replacements dictionary."""
-        replacements = getattr(self,sect)
         d = OrderedDict()
         parse_entries(self.sections.get(sect,()), d, unquote=True)
         for pat,rep in d.items():
-            pat = strip_quotes(pat)
-            if not is_regexp(pat):
+            if not self.set_replacement(pat, rep, getattr(self,sect)):
                 raise EAsciiDoc,'[%s] entry in %s is not a valid' \
                     ' regular expression: %s' % (sect,self.fname,pat)
-            if rep is None:
-                if replacements.has_key(pat):
-                    del replacements[pat]
-            else:
-                replacements[pat] = strip_quotes(rep)
+
+    def set_replacement(pat, rep, replacements):
+        """Add pattern and replacement to replacements dictionary."""
+        pat = strip_quotes(pat)
+        if not is_regexp(pat):
+            return False
+        if rep is None:
+            if replacements.has_key(pat):
+                del replacements[pat]
+        else:
+            replacements[pat] = strip_quotes(rep)
+        return True
+    set_replacement = staticmethod(set_replacement)
 
     def subs_replacements(self,s,sect='replacements'):
         """Substitute patterns from self.replacements in 's'."""
@@ -3970,14 +4158,514 @@ class Config:
         return (stag,etag)
 
 
+#---------------------------------------------------------------------------
+# Deprecated old table classes follow.
+# Naming convention is an _OLD name suffix.
+# These will be removed from future versions of AsciiDoc
+#
+
+def join_lines_OLD(lines):
+    """Return a list in which lines terminated with the backslash line
+    continuation character are joined."""
+    result = []
+    s = ''
+    continuation = False
+    for line in lines:
+        if line and line[-1] == '\\':
+            s = s + line[:-1]
+            continuation = True
+            continue
+        if continuation:
+            result.append(s+line)
+            s = ''
+            continuation = False
+        else:
+            result.append(line)
+    if continuation:
+        result.append(s)
+    return result
+
+class Column_OLD:
+    """Table column."""
+    def __init__(self):
+        self.colalign = None    # 'left','right','center'
+        self.rulerwidth = None
+        self.colwidth = None    # Output width in page units.
+
+class Table_OLD(AbstractBlock):
+    COL_STOP = r"(`|'|\.)"  # RE.
+    ALIGNMENTS = {'`':'left', "'":'right', '.':'center'}
+    FORMATS = ('fixed','csv','dsv')
+    def __init__(self):
+        AbstractBlock.__init__(self)
+        self.CONF_ENTRIES += ('template','fillchar','format','colspec',
+                              'headrow','footrow','bodyrow','headdata',
+                              'footdata', 'bodydata')
+        # Configuration parameters.
+        self.fillchar=None
+        self.format=None    # 'fixed','csv','dsv'
+        self.colspec=None
+        self.headrow=None
+        self.footrow=None
+        self.bodyrow=None
+        self.headdata=None
+        self.footdata=None
+        self.bodydata=None
+        # Calculated parameters.
+        self.underline=None     # RE matching current table underline.
+        self.isnumeric=False    # True if numeric ruler.
+        self.tablewidth=None    # Optional table width scale factor.
+        self.columns=[]         # List of Columns.
+        # Other.
+        self.check_msg=''       # Message set by previous self.validate() call.
+    def load(self,name,entries):
+        AbstractBlock.load(self,name,entries)
+        """Update table definition from section entries in 'entries'."""
+        for k,v in entries.items():
+            if k == 'fillchar':
+                if v and len(v) == 1:
+                    self.fillchar = v
+                else:
+                    raise EAsciiDoc,'malformed table fillchar: %s' % v
+            elif k == 'format':
+                if v in Table_OLD.FORMATS:
+                    self.format = v
+                else:
+                    raise EAsciiDoc,'illegal table format: %s' % v
+            elif k == 'colspec':
+                self.colspec = v
+            elif k == 'headrow':
+                self.headrow = v
+            elif k == 'footrow':
+                self.footrow = v
+            elif k == 'bodyrow':
+                self.bodyrow = v
+            elif k == 'headdata':
+                self.headdata = v
+            elif k == 'footdata':
+                self.footdata = v
+            elif k == 'bodydata':
+                self.bodydata = v
+    def dump(self):
+        AbstractBlock.dump(self)
+        write = lambda s: sys.stdout.write('%s%s' % (s,writer.newline))
+        write('fillchar='+self.fillchar)
+        write('format='+self.format)
+        if self.colspec:
+            write('colspec='+self.colspec)
+        if self.headrow:
+            write('headrow='+self.headrow)
+        if self.footrow:
+            write('footrow='+self.footrow)
+        write('bodyrow='+self.bodyrow)
+        if self.headdata:
+            write('headdata='+self.headdata)
+        if self.footdata:
+            write('footdata='+self.footdata)
+        write('bodydata='+self.bodydata)
+        write('')
+    def validate(self):
+        AbstractBlock.validate(self)
+        """Check table definition and set self.check_msg if invalid else set
+        self.check_msg to blank string."""
+        # Check global table parameters.
+        if config.textwidth is None:
+            self.check_msg = 'missing [miscellaneous] textwidth entry'
+        elif config.pagewidth is None:
+            self.check_msg = 'missing [miscellaneous] pagewidth entry'
+        elif config.pageunits is None:
+            self.check_msg = 'missing [miscellaneous] pageunits entry'
+        elif self.headrow is None:
+            self.check_msg = 'missing headrow entry'
+        elif self.footrow is None:
+            self.check_msg = 'missing footrow entry'
+        elif self.bodyrow is None:
+            self.check_msg = 'missing bodyrow entry'
+        elif self.headdata is None:
+            self.check_msg = 'missing headdata entry'
+        elif self.footdata is None:
+            self.check_msg = 'missing footdata entry'
+        elif self.bodydata is None:
+            self.check_msg = 'missing bodydata entry'
+        else:
+            # No errors.
+            self.check_msg = ''
+    def isnext(self):
+        return AbstractBlock.isnext(self)
+    def parse_ruler(self,ruler):
+        """Parse ruler calculating underline and ruler column widths."""
+        fc = re.escape(self.fillchar)
+        # Strip and save optional tablewidth from end of ruler.
+        mo = re.match(r'^(.*'+fc+r'+)([\d\.]+)$',ruler)
+        if mo:
+            ruler = mo.group(1)
+            self.tablewidth = float(mo.group(2))
+            self.attributes['tablewidth'] = str(float(self.tablewidth))
+        else:
+            self.tablewidth = None
+            self.attributes['tablewidth'] = '100.0'
+        # Guess whether column widths are specified numerically or not.
+        if ruler[1] != self.fillchar:
+            # If the first column does not start with a fillchar then numeric.
+            self.isnumeric = True
+        elif ruler[1:] == self.fillchar*len(ruler[1:]):
+            # The case of one column followed by fillchars is numeric.
+            self.isnumeric = True
+        else:
+            self.isnumeric = False
+        # Underlines must be 3 or more fillchars.
+        self.underline = r'^' + fc + r'{3,}$'
+        splits = re.split(self.COL_STOP,ruler)[1:]
+        # Build self.columns.
+        for i in range(0,len(splits),2):
+            c = Column_OLD()
+            c.colalign = self.ALIGNMENTS[splits[i]]
+            s = splits[i+1]
+            if self.isnumeric:
+                # Strip trailing fillchars.
+                s = re.sub(fc+r'+$','',s)
+                if s == '':
+                    c.rulerwidth = None
+                else:
+                    c.rulerwidth = int(validate(s,'int($)>0',
+                        'malformed ruler: bad width'))
+            else:   # Calculate column width from inter-fillchar intervals.
+                if not re.match(r'^'+fc+r'+$',s):
+                    raise EAsciiDoc,'malformed ruler: illegal fillchars'
+                c.rulerwidth = len(s)+1
+            self.columns.append(c)
+        # Fill in unspecified ruler widths.
+        if self.isnumeric:
+            if self.columns[0].rulerwidth is None:
+                prevwidth = 1
+            for c in self.columns:
+                if c.rulerwidth is None:
+                    c.rulerwidth = prevwidth
+                prevwidth = c.rulerwidth
+    def build_colspecs(self):
+        """Generate colwidths and colspecs. This can only be done after the
+        table arguments have been parsed since we use the table format."""
+        self.attributes['cols'] = len(self.columns)
+        # Calculate total ruler width.
+        totalwidth = 0
+        for c in self.columns:
+            totalwidth = totalwidth + c.rulerwidth
+        if totalwidth <= 0:
+            raise EAsciiDoc,'zero width table'
+        # Calculate marked up colwidths from rulerwidths.
+        for c in self.columns:
+            # Convert ruler width to output page width.
+            width = float(c.rulerwidth)
+            if self.format == 'fixed':
+                if self.tablewidth is None:
+                    # Size proportional to ruler width.
+                    colfraction = width/config.textwidth
+                else:
+                    # Size proportional to page width.
+                    colfraction = width/totalwidth
+            else:
+                    # Size proportional to page width.
+                colfraction = width/totalwidth
+            c.colwidth = colfraction * config.pagewidth # To page units.
+            if self.tablewidth is not None:
+                c.colwidth = c.colwidth * self.tablewidth   # Scale factor.
+                if self.tablewidth > 1:
+                    c.colwidth = c.colwidth/100 # tablewidth is in percent.
+        # Build colspecs.
+        if self.colspec:
+            cols = []
+            i = 0
+            for c in self.columns:
+                i += 1
+                self.attributes['colalign'] = c.colalign
+                self.attributes['colwidth'] = str(int(c.colwidth))
+                self.attributes['colnumber'] = str(i + 1)
+                s = subs_attrs(self.colspec,self.attributes)
+                if not s:
+                    warning('colspec dropped: contains undefined attribute')
+                else:
+                    cols.append(s)
+            self.attributes['colspecs'] = writer.newline.join(cols)
+    def split_rows(self,rows):
+        """Return a two item tuple containing a list of lines up to but not
+        including the next underline (continued lines are joined ) and the
+        tuple of all lines after the underline."""
+        reo = re.compile(self.underline)
+        i = 0
+        while not reo.match(rows[i]):
+            i = i+1
+        if i == 0:
+            raise EAsciiDoc,'missing table rows'
+        if i >= len(rows):
+            raise EAsciiDoc,'closing [%s] underline expected' % self.name
+        return (join_lines_OLD(rows[:i]), rows[i+1:])
+    def parse_rows(self, rows, rtag, dtag):
+        """Parse rows list using the row and data tags. Returns a substituted
+        list of output lines."""
+        result = []
+        # Source rows are parsed as single block, rather than line by line, to
+        # allow the CSV reader to handle multi-line rows.
+        if self.format == 'fixed':
+            rows = self.parse_fixed(rows)
+        elif self.format == 'csv':
+            rows = self.parse_csv(rows)
+        elif self.format == 'dsv':
+            rows = self.parse_dsv(rows)
+        else:
+            assert True,'illegal table format'
+        # Substitute and indent all data in all rows.
+        stag,etag = subs_tag(rtag,self.attributes)
+        for row in rows:
+            result.append('  '+stag)
+            for data in self.subs_row(row,dtag):
+                result.append('    '+data)
+            result.append('  '+etag)
+        return result
+    def subs_row(self, data, dtag):
+        """Substitute the list of source row data elements using the data tag.
+        Returns a substituted list of output table data items."""
+        result = []
+        if len(data) < len(self.columns):
+            warning('fewer row data items then table columns')
+        if len(data) > len(self.columns):
+            warning('more row data items than table columns')
+        for i in range(len(self.columns)):
+            if i > len(data) - 1:
+                d = ''  # Fill missing column data with blanks.
+            else:
+                d = data[i]
+            c = self.columns[i]
+            self.attributes['colalign'] = c.colalign
+            self.attributes['colwidth'] = str(int(c.colwidth))
+            self.attributes['colnumber'] = str(i + 1)
+            stag,etag = subs_tag(dtag,self.attributes)
+            # Insert AsciiDoc line break (' +') where row data has newlines
+            # ('\n').  This is really only useful when the table format is csv
+            # and the output markup is HTML. It's also a bit dubious in that it
+            # assumes the user has not modified the shipped line break pattern.
+            subs = self.get_subs()[0]
+            if 'replacements' in subs:
+                # Insert line breaks in cell data.
+                d = re.sub(r'(?m)\n',r' +\n',d)
+                d = d.split('\n')    # So writer.newline is written.
+            else:
+                d = [d]
+            result = result + [stag] + Lex.subs(d,subs) + [etag]
+        return result
+    def parse_fixed(self,rows):
+        """Parse the list of source table rows. Each row item in the returned
+        list contains a list of cell data elements."""
+        result = []
+        for row in rows:
+            data = []
+            start = 0
+            # build an encoded representation
+            row = char_decode(row)
+            for c in self.columns:
+                end = start + c.rulerwidth
+                if c is self.columns[-1]:
+                    # Text in last column can continue forever.
+                    # Use the encoded string to slice, but convert back
+                    # to plain string before further processing
+                    data.append(char_encode(row[start:]).strip())
+                else:
+                    data.append(char_encode(row[start:end]).strip())
+                start = end
+            result.append(data)
+        return result
+    def parse_csv(self,rows):
+        """Parse the list of source table rows. Each row item in the returned
+        list contains a list of cell data elements."""
+        import StringIO
+        import csv
+        result = []
+        rdr = csv.reader(StringIO.StringIO('\r\n'.join(rows)),
+            skipinitialspace=True)
+        try:
+            for row in rdr:
+                result.append(row)
+        except:
+            raise EAsciiDoc,'csv parse error: %s' % row
+        return result
+    def parse_dsv(self,rows):
+        """Parse the list of source table rows. Each row item in the returned
+        list contains a list of cell data elements."""
+        separator = self.attributes.get('separator',':')
+        separator = eval('"'+separator+'"')
+        if len(separator) != 1:
+            raise EAsciiDoc,'malformed dsv separator: %s' % separator
+        # TODO If separator is preceeded by an odd number of backslashes then
+        # it is escaped and should not delimit.
+        result = []
+        for row in rows:
+            # Skip blank lines
+            if row == '': continue
+            # Unescape escaped characters.
+            row = eval('"'+row.replace('"','\\"')+'"')
+            data = row.split(separator)
+            data = [s.strip() for s in data]
+            result.append(data)
+        return result
+    def translate(self):
+        deprecated('old tables syntax')
+        AbstractBlock.translate(self)
+        # Reset instance specific properties.
+        self.underline = None
+        self.columns = []
+        attrs = {}
+        BlockTitle.consume(attrs)
+        # Add relevant globals to table substitutions.
+        attrs['pagewidth'] = str(config.pagewidth)
+        attrs['pageunits'] = config.pageunits
+        # Mix in document attribute list.
+        AttributeList.consume(attrs)
+        # Validate overridable attributes.
+        for k,v in attrs.items():
+            if k == 'format':
+                if v not in self.FORMATS:
+                    raise EAsciiDoc, 'illegal [%s] %s: %s' % (self.name,k,v)
+                self.format = v
+            elif k == 'tablewidth':
+                try:
+                    self.tablewidth = float(attrs['tablewidth'])
+                except:
+                    raise EAsciiDoc, 'illegal [%s] %s: %s' % (self.name,k,v)
+        self.merge_attributes(attrs)
+        # Parse table ruler.
+        ruler = reader.read()
+        assert re.match(self.delimiter,ruler)
+        self.parse_ruler(ruler)
+        # Read the entire table.
+        table = []
+        while True:
+            line = reader.read_next()
+            # Table terminated by underline followed by a blank line or EOF.
+            if len(table) > 0 and re.match(self.underline,table[-1]):
+                if line in ('',None):
+                    break;
+            if line is None:
+                raise EAsciiDoc,'closing [%s] underline expected' % self.name
+            table.append(reader.read())
+        # EXPERIMENTAL: The number of lines in the table, requested by Benjamin Klum.
+        self.attributes['rows'] = str(len(table))
+        #TODO: Inherited validate() doesn't set check_msg, needs checking.
+        if self.check_msg:  # Skip if table definition was marked invalid.
+            warning('skipping %s table: %s' % (self.name,self.check_msg))
+            return
+        # Generate colwidths and colspecs.
+        self.build_colspecs()
+        # Generate headrows, footrows, bodyrows.
+        # Headrow, footrow and bodyrow data replaces same named attributes in
+        # the table markup template. In order to ensure this data does not get
+        # a second attribute substitution (which would interfere with any
+        # already substituted inline passthroughs) unique placeholders are used
+        # (the tab character does not appear elsewhere since it is expanded on
+        # input) which are replaced after template attribute substitution.
+        headrows = footrows = []
+        bodyrows,table = self.split_rows(table)
+        if table:
+            headrows = bodyrows
+            bodyrows,table = self.split_rows(table)
+            if table:
+                footrows,table = self.split_rows(table)
+        if headrows:
+            headrows = self.parse_rows(headrows, self.headrow, self.headdata)
+            headrows = writer.newline.join(headrows)
+            self.attributes['headrows'] = '\theadrows\t'
+        if footrows:
+            footrows = self.parse_rows(footrows, self.footrow, self.footdata)
+            footrows = writer.newline.join(footrows)
+            self.attributes['footrows'] = '\tfootrows\t'
+        bodyrows = self.parse_rows(bodyrows, self.bodyrow, self.bodydata)
+        bodyrows = writer.newline.join(bodyrows)
+        self.attributes['bodyrows'] = '\tbodyrows\t'
+        table = subs_attrs(config.sections[self.template],self.attributes)
+        table = writer.newline.join(table)
+        # Before we finish replace the table head, foot and body place holders
+        # with the real data.
+        if headrows:
+            table = table.replace('\theadrows\t', headrows, 1)
+        if footrows:
+            table = table.replace('\tfootrows\t', footrows, 1)
+        table = table.replace('\tbodyrows\t', bodyrows, 1)
+        writer.write(table)
+
+class Tables_OLD(AbstractBlocks):
+    """List of tables."""
+    BLOCK_TYPE = Table_OLD
+    PREFIX = 'old_tabledef-'
+    def __init__(self):
+        AbstractBlocks.__init__(self)
+    def load(self,sections):
+        AbstractBlocks.load(self,sections)
+    def validate(self):
+        # Does not call AbstractBlocks.validate().
+        # Check we have a default table definition,
+        for i in range(len(self.blocks)):
+            if self.blocks[i].name == 'old_tabledef-default':
+                default = self.blocks[i]
+                break
+        else:
+            raise EAsciiDoc,'missing [OLD_tabledef-default] section'
+        # Set default table defaults.
+        if default.format is None: default.subs = 'fixed'
+        # Propagate defaults to unspecified table parameters.
+        for b in self.blocks:
+            if b is not default:
+                if b.fillchar is None: b.fillchar = default.fillchar
+                if b.format is None: b.format = default.format
+                if b.template is None: b.template = default.template
+                if b.colspec is None: b.colspec = default.colspec
+                if b.headrow is None: b.headrow = default.headrow
+                if b.footrow is None: b.footrow = default.footrow
+                if b.bodyrow is None: b.bodyrow = default.bodyrow
+                if b.headdata is None: b.headdata = default.headdata
+                if b.footdata is None: b.footdata = default.footdata
+                if b.bodydata is None: b.bodydata = default.bodydata
+        # Check all tables have valid fill character.
+        for b in self.blocks:
+            if not b.fillchar or len(b.fillchar) != 1:
+                raise EAsciiDoc,'[%s] missing or illegal fillchar' % b.name
+        # Build combined tables delimiter patterns and assign defaults.
+        delimiters = []
+        for b in self.blocks:
+            # Ruler is:
+            #   (ColStop,(ColWidth,FillChar+)?)+, FillChar+, TableWidth?
+            b.delimiter = r'^(' + Table_OLD.COL_STOP \
+                + r'(\d*|' + re.escape(b.fillchar) + r'*)' \
+                + r')+' \
+                + re.escape(b.fillchar) + r'+' \
+                + '([\d\.]*)$'
+            delimiters.append(b.delimiter)
+            if not b.headrow:
+                b.headrow = b.bodyrow
+            if not b.footrow:
+                b.footrow = b.bodyrow
+            if not b.headdata:
+                b.headdata = b.bodydata
+            if not b.footdata:
+                b.footdata = b.bodydata
+        self.delimiter = join_regexp(delimiters)
+        # Check table definitions are valid.
+        for b in self.blocks:
+            b.validate()
+            if config.verbose:
+                if b.check_msg:
+                    warning('[%s] table definition: %s' % (b.name,b.check_msg))
+
+# End of deprecated old table classes.
+#---------------------------------------------------------------------------
+
 #---------------------------------------------------------------------------
 # Application code.
 #---------------------------------------------------------------------------
 # Constants
 # ---------
+APP_FILE = None             # This file's full path.
 APP_DIR = None              # This file's directory.
 USER_DIR = None             # ~/.asciidoc
-CONF_DIR = '/etc/asciidoc'  # Global configuration files directory.
+# Global configuration files directory (set by Makefile build target).
+CONF_DIR = '/etc/asciidoc'
 HELP_FILE = 'help.conf'     # Default (English) help file.
 
 # Globals
@@ -3989,6 +4677,7 @@ writer = Writer()           # Output stream line writer.
 paragraphs = Paragraphs()   # Paragraph definitions.
 lists = Lists()             # List definitions.
 blocks = DelimitedBlocks()  # DelimitedBlock definitions.
+tables_OLD = Tables_OLD()   # Table_OLD definitions.
 tables = Tables()           # Table definitions.
 macros = Macros()           # Macro definitions.
 calloutmap = CalloutMap()   # Coordinates callouts and callout list.
@@ -4031,13 +4720,13 @@ def asciidoc(backend, doctype, confiles, infile, outfile, options):
                 config.load_all(os.path.dirname(infile))
         if infile != '<stdin>':
             # Load implicit document specific configuration files if they exist.
-            config.load(os.path.splitext(infile)[0] + '.conf')
-            config.load(os.path.splitext(infile)[0] + '-' + backend + '.conf')
+            config.load_file(os.path.splitext(infile)[0] + '.conf')
+            config.load_file(os.path.splitext(infile)[0] + '-' + backend + '.conf')
         # If user specified configuration file(s) overlay the defaults.
         if confiles:
             for conf in confiles:
                 if os.path.isfile(conf):
-                    config.load(conf)
+                    config.load_file(conf)
                 else:
                     raise EAsciiDoc,'configuration file %s missing' % conf
         document.init_attrs()   # Add conf files.
@@ -4131,8 +4820,9 @@ def main():
         print_stderr('FAILED: Python 2.3 or better required.')
         sys.exit(1)
     # Locate the executable and configuration files directory.
-    global APP_DIR,USER_DIR
-    APP_DIR = os.path.dirname(os.path.realpath(sys.argv[0]))
+    global APP_FILE,APP_DIR,USER_DIR
+    APP_FILE = os.path.realpath(sys.argv[0])
+    APP_DIR = os.path.dirname(APP_FILE)
     USER_DIR = os.environ.get('HOME')
     if USER_DIR is not None:
         USER_DIR = os.path.join(USER_DIR,'.asciidoc')