deplate 0.7.3 → 0.8

data/lib/deplate/core.rb

@@ -3,7 +3,7 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     24-Feb-2004.
-# @Last Change: 02-Nov-2005.
+# @Last Change: 07-Jun-2006.
 
 require 'uri'
 require 'optparse'
@@ -26,8 +26,11 @@ module Deplate; end
 class Deplate::Core
     extend Forwardable
 
-    Version    = '0.7.3'
-    MicroRev   = '2132'
+    Version    = '0.8'
+    # VersionSfx = 'a'
+    VersionSfx = 'final'
+    MicroRev   = '2711'
+
     if ENV['HOME']
         CfgDir = File.join(ENV['HOME'].gsub(/\\/, '/'), '.deplate')
     elsif ENV['USERPROFILE']
@@ -50,10 +53,6 @@ MESSAGE
     # FileCache  = File.join(CfgDir, 'file_list.dat')
     FileCache  = nil
 
-    # The structure containing index definitions
-    IndexEntry = Struct.new('DeplateIndexEntry', :name, :synonymes, 
-                            :label, :file, :level_as_string)
-
     # If true, don't load user configuration files.
     @vanilla = false
     
@@ -123,6 +122,7 @@ MESSAGE
         :htmlslides_next => 57,
         :html_relations  => 58,
         :css             => 60,
+        :styles          => 65,
         :javascript      => 70,
         :head_end        => 80,
         :body_beg        => 90,
@@ -131,14 +131,14 @@ MESSAGE
         :body_pre        => 105,
 
         #body
-        :body_begin      => 0,
+        :inner_body_begin => 0,
         :navbar_js       => 4,
         :navbar_top      => 5,
         :body_title      => 20,
         :body            => 50,
         :footnotes       => 75,
         :navbar_bottom   => 95,
-        :body_end        => 100,
+        :inner_body_end  => 100,
         
         #post matter
         :body_post           => 0,
@@ -156,6 +156,8 @@ MESSAGE
     # A hash of formatter names and corresponding classes
     @@formatter_classes = {}
 
+    @@bib_style         = {}
+
     # A hash of names of input formats and corresponding classes
     @@input_classes     = {}
 
@@ -195,15 +197,16 @@ MESSAGE
                     options.ask_user = bool
                 end
 
-                opts.on('-A', '--allow ALLOW', 'Allow certain things: x, X, $') do |string|
-                    options.allow += string.strip.split(/[,; ]+/)
+                opts.on('-A', '--allow ALLOW', 
+                        'Allow certain things: l, r, t, w, W, x, X, $') do |string|
+                    allow(options.allow, string)
                     log("options.allow = #{string}")
                 end
             
                 opts.on('-c', '--config FILE', String, 
                         'Alternative user cfg file') do |file|
                     log("options.cfg = #{file}")
-                    options.cfg = file
+                    options.cfg = [file]
                 end
 
                 opts.on('--[no-]clean', 'Clean up temporary files') do |b|
@@ -230,11 +233,13 @@ MESSAGE
 
                 opts.on('-d', '--dir DIR', String, 'Output directory') do |dir|
                     log("options.dir = #{dir}")
-                    if dir.kind_of?(String) and File.directory?(dir)
-                        options.dir = dir
-                    else
-                        log(["Directory doesn't exist", dir], :error)
-                    end
+                    ensure_dir_exists(dir, options)
+                    options.dir = dir
+                    # if dir.kind_of?(String) and File.directory?(dir)
+                    #     options.dir = dir
+                    # else
+                    #     log(["Directory doesn't exist", dir], :error)
+                    # end
                 end
 
                 opts.on('-D', '--define NAME=VALUE', String,
@@ -243,13 +248,8 @@ MESSAGE
                     if m
                         k = m[1]
                         v = m[3]
-                        if v
-                            v = remove_backslashes(v.gsub(/(^|[^\\])~/, '\\1 '))
-                        else
-                            v ='1'
-                        end
                         log(%{options.variables[#{k}] = "#{v}"})
-                        options.variables[k] = v
+                        canonic_args(options.variables, k, v)
                     else
                         log(["Malformed variable definition on command line", text], :error)
                     end
@@ -323,7 +323,11 @@ MESSAGE
 
                 opts.on('-o', '--out FILE', String, "Output to file or stdout ('-')") do |file|
                     log("options.out = #{file}")
-                    options.out         = file
+                    d, f = File.split(file)
+                    if d != '.'
+                        options.dir = d
+                    end
+                    options.out         = f
                     options.explicitOut = true
                 end
                 
@@ -358,12 +362,22 @@ MESSAGE
                     options.recurse_hierarchy = bool
                 end
 
+                opts.on('-s', '--skeleton NAME', String, 'Make skeleton available') do |str|
+                    log("options.skeletons << #{str}")
+                    options.skeletons << str
+                end
+                
                 opts.on('--[no-]simple-names', 'Disable simple wiki names') do |bool|
                     unless bool
                         options.disabled_particles << Deplate::HyperLink::Simple
                     end
                 end
                 
+                opts.on('--split-level LEVEL', Integer, 'Heading level for splitting') do |i|
+                    log("options.split_level = #{i}")
+                    options.split_level = i
+                end
+                
                 opts.on('--suffix SUFFIX', String, 'Suffix for output files') do |str|
                     log("options.suffix = #{str}")
                     options.suffix = str
@@ -374,7 +388,7 @@ MESSAGE
                         log("options.template = #{@@templates[str]}")
                         options.template = str
                     else
-                        log(["Template not found", str], :error)
+                        log(['Template not found', str], :error)
                         exit 5
                     end
                 end
@@ -388,10 +402,10 @@ MESSAGE
                         'Allow the execution of ruby code') do |level|
                     if level
                         options.allow_ruby = level
-                        options.allow << level
+                        allow(options.allow, level)
                     else
                         options.allow_ruby = true
-                        options.allow << 'x'
+                        allow(options.allow, 'x')
                     end
                     log("options.allow_ruby = #{options.allow_ruby}")
                 end
@@ -399,7 +413,7 @@ MESSAGE
                 opts.on('-X', '--[no-]allow-exec', '--[no-]external',
                         'Allow the execution of helper applications') do |bool|
                     options.allow_external = bool
-                    options.allow << 'X'
+                    allow(options.allow, 'X')
                     log("options.allow_external = #{bool}")
                 end
             
@@ -467,6 +481,20 @@ MESSAGE
                     exit 1
                 end
 
+                opts.on_tail('--list-modules [REGEXP]', Regexp,
+                             'List modules matching a pattern') do |rx|
+                    m = rx.nil? ? modules : modules.find_all {|n| n =~ rx}
+                    puts m.join("\n")
+                    exit 1
+                end
+
+                opts.on_tail('--list-css [REGEXP]', Regexp,
+                             'List css files matching a pattern') do |rx|
+                    m = rx.nil? ? csss : csss.find_all {|n| n =~ rx}
+                    puts m.join("\n")
+                    exit 1
+                end
+
                 opts.on_tail('--version', 'Show version') do
                     puts version
                     exit 0
@@ -479,6 +507,9 @@ MESSAGE
             end
 
             @@command_line_args = args.dup
+            if options.ini_command_line_arguments
+                args += options.ini_command_line_arguments
+            end
             options.files = opts.parse!(args)
 
             if options.list
@@ -508,7 +539,6 @@ MESSAGE
             
             if formatter_class
                 f = options.files[0]
-                options.dir ||= '.'
                 case f
                 when '-'
                     options.ext      = ''
@@ -519,7 +549,10 @@ MESSAGE
                     options.srcdir ||= File.dirname(f)
                     options.suffix ||= formatter_class.suffix
                     if options.out
-                        options.out = options.dir ? File.join(options.dir, options.out) : options.out
+                        options.out = Deplate::Core.file_join(options.dir, options.out)
+                        # if options.out != '-'
+                        #     options.out = options.dir ? Deplate::Core.file_join(options.dir, options.out) : options.out
+                        # end
                     else
                         options.out = get_out_fullname(f, options.suffix, options)
                     end
@@ -549,13 +582,57 @@ MESSAGE
             require 'deplate/mod/en' unless @@messages_last
 
             # load general user config
-            options.cfg ||= File.join(CfgDir, 'config.rb')
+            options.cfg ||= ['config.rb', CfgDir]
             unless options.vanilla
-                user_config(options, options.cfg)
+                user_config(options, *options.cfg)
                 user_setup(options) if defined?(user_setup)
             end
         end
 
+        # Set certain allow flags in array.
+        def allow(arr, ids)
+            case ids
+            when String
+                ids = ids.split(/[,; ]+/)
+                # ids = ids.scan(/[a-zA-Z.:]/)
+            when Array
+            else
+                log(['Internal error', 'allow', ids], :error)
+            end
+            ids.each do |i|
+                m = i[0..0]
+                case m
+                when '-'
+                    arr.delete(i[1..-1])
+                when '+'
+                    arr << i[1..-1]
+                else
+                    arr << i
+                end
+            end
+            arr
+        end
+
+        # Check whether a certain action is allowed
+        def is_allowed?(options, ids, args={})
+            arr = options.allow
+            case ids
+            when String
+                ids = ids.split(/[,; ]/)
+            when Array
+            else
+                log(['Internal error', 'allow', ids], :error)
+            end
+            for i in ids
+                if arr.include?(i)
+                    return true
+                end
+            end
+            logger = args[:logger]
+            logger.log(['No permission', ids.join(', ')], :anyway) if logger
+            return false
+        end
+        
         # Read CfgDir/deplate.ini
         #
         # This file knows the following commands/entries
@@ -570,85 +647,91 @@ MESSAGE
         #
         # Lines beginning with one of ';#%' are considered comments.
         def read_ini(options)
-            for inifile in [
-                File.join(Dir.pwd, "deplate.rc", 'deplate.ini'),
-                File.join(CfgDir, 'deplate.ini'),
-            ]
-                if File.exist?(inifile)
-                    ini    = File.open(inifile) {|io| io.read}
-                    mode   = :normal
-                    acc    = []
-                    endm   = nil
-                    setter = nil
-                    for line in ini
-                        line.chomp!
-                        case mode
-                        when :normal
-                            if line =~ /^\s*[;#%*]/
-                                # comment
-                                next
-                            elsif line =~ /^\s*mod\s+(\S+)/
-                                options.modules << $1
-                            elsif line =~ /^\s*fmt\s+(\S+)/
-                                options.fmt = $1
-                            elsif line =~ /^\s*clip\s+([^\s=]+)\s*=\s*(.+)/
-                                options.clips[$1] = $2
-                            elsif line =~ /^\s*wiki ([A-Z]+)(\.\w+)?\s*=\s*(.+)/
-                                Deplate::InterWiki.add($1, $3, $2)
-                            elsif line =~ /^\s*wikichars\s*(\S+)\s*(\S+)/
-                                Deplate::HyperLink.setup($1, $2)
-                            elsif line =~ /^\s*app\s*([_\w]+)\s*=\s*(.+)/
-                                Deplate::External.def_app $1, $2
-                            elsif line =~ /^\s*(option\s+|:)([_\w]+)([!~]|\s*([?%])?=\s*(.+))/
-                                case $3
-                                when '!'
-                                    val = true
-                                when '~'
-                                    val = false
-                                else
-                                    case $4
-                                    when '?'
-                                        case $5
-                                        when 'true', 'yes', 'on'
-                                            val = true
-                                        when 'false', 'no', 'off'
-                                            val = false
-                                        else
-                                            Deplate::Core.log(['Malformed configuration line', line], :error)
-                                            next
-                                        end
-                                    when '%'
-                                        val = $5.to_i
+            read_ini_file(options, File.join(CfgDir, 'deplate.ini'))
+            read_ini_file(options, File.join(Dir.pwd, "deplate.rc", 'deplate.ini')) if is_allowed?(options, 'r')
+        end
+
+        def read_ini_file(options, inifile)
+            if File.exist?(inifile)
+                ini    = File.open(inifile) {|io| io.read}
+                mode   = :normal
+                acc    = []
+                endm   = nil
+                setter = nil
+                for line in ini
+                    line.chomp!
+                    case mode
+                    when :normal
+                        if line =~ /^\s*[;#%*]/
+                            # comment
+                            next
+                        elsif line =~ /^(-\S+)(\s+(.*?)\s*)?$/
+                            options.ini_command_line_arguments ||= []
+                            options.ini_command_line_arguments << $1
+                            options.ini_command_line_arguments << $3 if $3
+                        elsif line =~ /^\s*allow\s+(.+?)\s*$/
+                            allow(options.allow, $1)
+                        elsif line =~ /^\s*mod\s+(\S+)/
+                            options.modules << $1
+                        elsif line =~ /^\s*fmt\s+(\S+)/
+                            options.fmt = $1
+                        elsif line =~ /^\s*clip\s+([^\s=]+)\s*=\s*(.+)/
+                            options.clips[$1] = $2
+                        elsif line =~ /^\s*wiki ([A-Z]+)(\.\w+)?\s*=\s*(.+)/
+                            Deplate::InterWiki.add($1, $3, $2)
+                        elsif line =~ /^\s*wikichars\s*(\S+)\s*(\S+)/
+                            Deplate::HyperLink.setup($1, $2)
+                        elsif line =~ /^\s*app\s*([_\w]+)\s*=\s*(.+)/
+                            Deplate::External.def_app $1, $2
+                        elsif line =~ /^\s*(option\s+|:)([_\w]+)([!~]|\s*([?%])?=\s*(.+))/
+                            case $3
+                            when '!'
+                                val = true
+                            when '~'
+                                val = false
+                            else
+                                case $4
+                                when '?'
+                                    case $5
+                                    when 'true', 'yes', 'on'
+                                        val = true
+                                    when 'false', 'no', 'off'
+                                        val = false
                                     else
-                                        val = $5
+                                        Deplate::Core.log(['Malformed configuration line', line], :error)
+                                        next
                                     end
+                                when '%'
+                                    val = $5.to_i
+                                else
+                                    val = $5
                                 end
-                                options.send("#$2=", val)
-                            elsif line =~ /^\s*\$(\S+)\s*=\s*(.+)/
-                                ENV[$1] = $2
-                            elsif line =~ /^\s*(\S+)\s*=<<(.+)/
-                                mode = :multiline
-                                endm = $2
-                                setter = lambda {|val| options.variables[$1] = val}
-                            elsif line =~ /^\s*(\S+)\s*=\s*(.+)/
-                                options.variables[$1] = $2
-                            end
-                        when :multiline
-                            if line == endm
-                                setter.call(acc)
-                                acc  = []
-                                mode = :normal
-                            else
-                                acc << line
                             end
+                            options.send("#$2=", val)
+                        elsif line =~ /^\s*\$(\S+)\s*=\s*(.+)/
+                            ENV[$1] = $2
+                        elsif line =~ /^\s*(\S+)\s*=<<(.+)/
+                            mode = :multiline
+                            endm = $2
+                            setter = lambda {|val| canonic_args(options.variables, $1, val)}
+                        elsif line =~ /^\s*(\S+)\s*=\s*(.+)/
+                            canonic_args(options.variables, $1, $2)
+                        end
+                    when :multiline
+                        if line == endm
+                            setter.call(acc)
+                            acc  = []
+                            mode = :normal
                         else
-                            raise "Invalid mode"
+                            acc << line
                         end
+                    else
+                        raise "Invalid mode"
                     end
                 end
             end
-       end
-        
+        end
+       
         # Load the input definition if any.
         # options:: A OpenStruct as returned by Deplate::Core.deplate_options
         def require_input(options, input_name=nil)
@@ -661,8 +744,8 @@ MESSAGE
         
         # Load the formatter named in options.fmt.
         # options:: A OpenStruct as returned by Deplate::Core.deplate_options
-        def require_formatter(options)
-            fmt = options.fmt
+        def require_formatter(options, fmt=nil)
+            fmt ||= options.fmt
             if @@formatter_classes[fmt]
                 Deplate::Core.log(['Formatter already loaded', fmt])
             else
@@ -670,8 +753,8 @@ MESSAGE
                 fmtf = @@formatters[fmt]
                 require fmtf
             end
-            user_config(options, File.join(CfgDir, 'after', 'fmt', '%s.rb' % fmt))
-            user_config(options, File.join(CfgDir, 'after', 'fmt', fmt))
+            user_config(options, File.join('after', 'fmt', '%s.rb' % fmt), CfgDir)
+            user_config(options, File.join('after', 'fmt', fmt), CfgDir)
         end
             
         # Load a module.
@@ -683,10 +766,12 @@ MESSAGE
             vsave, $VERBOSE = $VERBOSE, false
             begin
                 require mf
-                user_config(options, File.join(CfgDir, 'after', 'mod', '%s.rb' % module_name))
-                user_config(options, File.join(CfgDir, 'after', 'mod', module_name))
+                user_config(options, File.join('after', 'mod', '%s.rb' % module_name), CfgDir)
+                user_config(options, File.join('after', 'mod', module_name), CfgDir)
+                return true
             rescue Exception => e
                 Deplate::Core.log(["Loading module failed", module_name, e], :error)
+                return false
             ensure
                 $VERBOSE = vsave
             end
@@ -710,17 +795,29 @@ MESSAGE
         # options:: A OpenStruct as returned by Deplate::Core.deplate_options
         # file:: Either a file name or a directory; if it is a 
         #   directory, all ruby files in that directory will be loaded
-        def user_config(options, file)
+        def user_config(options, file, dir=nil)
             unless options.vanilla
-                if File.exist?(file)
-                    if File.stat(file).directory?
-                        for f in Dir[File.join(file, '*.rb')]
-                            user_config(options, f)
-                        end
-                    else
-                        Deplate::Core.log(["Loading", file])
-                        load(file)
+                if dir
+                    dirs = [dir]
+                    dirs << File.join(current_pwd, 'deplate.rc') if is_allowed?(options, 'r')
+                    for f in dirs
+                        load_user_config(options, File.join(f, file))
                     end
+                else
+                    load_user_config(options, file)
+                end
+            end
+        end
+
+        def load_user_config(options, file)
+            if File.exist?(file)
+                if File.stat(file).directory?
+                    for f in Dir[File.join(file, '*.rb')]
+                        user_config(options, f)
+                    end
+                else
+                    Deplate::Core.log(["Loading", file])
+                    load(file)
                 end
             end
         end
@@ -736,13 +833,43 @@ MESSAGE
             options.variables   ||= Deplate::Variables.new
             options.clips       ||= {}
             options.ext         ||= ''
-            options.dir         ||= '.'
+            # options.dir         ||= '.'
             options.allow       ||= []
+            options.skeletons   ||= []
+            options.split_level ||= 1
             options.disabled_particles ||= []
+            options.autoindexed        ||= []
+            reset_listings_and_counters(options, true)
             read_ini(options) unless inherit
             return options
         end
 
+        def reset_listings_and_counters(options, conditionally=false)
+            unless conditionally and options.counters
+                c = options.counters = Deplate::Counters.new(self)
+                c.def_counter('toc')
+                c.def_counter('lot', :parent => 'toc:1')
+                c.def_counter('lof', :parent => 'toc:1')
+            end
+            unless conditionally and options.listings
+                l = options.listings = Deplate::Listings.new(self)
+                l.def_listing('toc', nil,
+                              'prefix' => 'hd',
+                              'entity' => 'heading'
+                             )
+                l.def_listing('lot', nil,
+                              'prefix'  => 'tab',
+                              # 'counter' => :tables,
+                              'entity'  => 'table'
+                             )
+                l.def_listing('lof', nil,
+                              'prefix'  => 'fig',
+                              # 'counter' => :figures,
+                              'entity'  => 'figure'
+                             )
+            end
+        end
+
         # Return the current version number as string.
         def version
             Deplate::Core::Version
@@ -750,7 +877,12 @@ MESSAGE
 
         # Return the current micorversion number as string.
         def microversion
-            [Deplate::Core::Version, Deplate::Core::MicroRev].join('-')
+            [
+                Deplate::Core::Version, 
+                Deplate::Core::VersionSfx,
+                '-',
+                Deplate::Core::MicroRev,
+            ].join
         end
 
         # Enable colored log output
@@ -759,7 +891,7 @@ MESSAGE
             unless @@colored_output
                 unstopable_require('term/ansicolor') do
                     eval <<-EOR
-                    class Color
+                    class Deplate::Color
                         class << self
                             include Term::ANSIColor
                         end
@@ -791,10 +923,15 @@ MESSAGE
             end
             modules,    @@modules    = collect_deplate_options('modules',   'mod')
             formatters, @@formatters = collect_deplate_options('formatters','fmt')
-            csss,       @@css        = collect_deplate_options('css',       'css',       '.css')
-            templates,  @@templates  = collect_deplate_options('templates', 'templates', '')
             input_defs, @@input_defs = collect_deplate_options('input',     'input')
             meta_fmts,  @@metadata_formats = collect_deplate_options('metadata', 'metadata')
+            csss,       @@css        = collect_deplate_options('css',       'css', 
+                                                               :suffix => '.css',
+                                                               :rc => true)
+            templates,  @@templates  = collect_deplate_options('templates', 'templates',
+                                                              :suffix => '',
+                                                              :rc => true)
+                
             if FileCache
                 File.open(FileCache, 'w+') do |f|
                     data = {
@@ -828,9 +965,83 @@ MESSAGE
             end
         end
 
+        def canonic_args(hash, key, val)
+            if key[-1..-1] == '!'
+                key  = key[0..-2]
+                type = :bool
+            end
+            if key =~ /^no[A-Z]/
+                key  = key[2..2].downcase + key[3..-1]
+                val  = false
+                type = :bool
+            elsif val.nil?
+                type = :bool
+                val  = true
+            else
+                case val
+                when nil, 'true'
+                    type = :bool
+                    val  = true
+                when 'false'
+                    type = :bool
+                    val  = false
+                else
+                    type = :string
+                    if val =~ /^"(.*?)"$/
+                        val = val[1..-2]
+                    else
+                        val = val.strip
+                    end
+                    val = Deplate::Core.remove_backslashes(val)
+                end
+            end
+            case type
+            when :bool
+                hash["no#{key[0..0].upcase}#{key[1..-1]}"] = !val
+            end
+            hash[key] = val
+            hash
+        end
+
+        def query_user(options, msg, results, rv=true)
+            ok = if options and options.ask
+                     puts msg
+                     results.include?(gets.chomp)
+                 else
+                     true
+                 end
+            ok ? rv : !rv
+        end
+        
         # Remove all backslashes from +text+
         def remove_backslashes(text)
-            return text.gsub(/\\(.)/, '\\1')
+            return text.gsub(/\\(.)/, '\\1') if text
+        end
+
+        def escape_characters(text, args)
+            esc = args[:esc] || args[:escape] || args['esc'] || args['escape'] || ''
+            ebs = args[:escapebackslash] || args['escapebackslash'] || 0
+            case ebs
+            when true
+                ebs = 1
+            else
+                ebs = ebs.to_i
+            end
+            if esc.include?('\\')
+                esc = esc.delete('\\')
+                ebs ||= 1
+            end
+            if ebs > 0
+                text = text.gsub(/\\/, '\\\\' * ebs)
+            end
+            unless esc.empty?
+                text = text.gsub(/([#{esc}])/, '\\\\\\1')
+            end
+            text
+        end
+
+        def authors_split(text)
+            text.split(/\s+and\s+/) if text
         end
 
         # Clean +idx+'s (a instance of Deplate::IndexEntry) name from backslashes
@@ -861,7 +1072,7 @@ MESSAGE
         # Return the canonic file name for +name+. +maj+ and +min+ 
         # correspond to section numbers.
         def canonic_file_name(name, sfx, maj=nil, min=nil, dir=nil)
-            name = File.basename(name, File.extname(name))
+            name = File.basename(name, '.*')
             name = clean_file_name(name)
             if !name or (maj and maj != 0)
                 canonic_numbered_file_name(name, sfx, maj, min, dir)
@@ -876,18 +1087,28 @@ MESSAGE
 
         # Return a valid file name based on +text+
         def clean_file_name(text, replacement='_')
-            text.gsub(/[[:cntrl:].+*:"?<>|&\\\/]/, replacement) if text
+            rx = /[[:cntrl:].+*:"?<>|&\\\/]/
+            text.gsub(rx, replacement) if text
         end
 
         # Make sure +dir+ exists
-        def ensure_dir_exists(dir)
+        def ensure_dir_exists(dir, options=nil)
             unless File.exist?(dir) or dir.empty? or dir == '.'
-                parent = File.dirname(dir)
-                unless File.exist?(parent)
-                    ensure_dir_exists(parent)
+                if !options or 
+                    options.force or 
+                    Deplate::Core.query_user(options, 
+                                             "Create directory '#{dir}' (y/N)? ", 
+                                             'y')
+                    parent = File.dirname(dir)
+                    unless File.exist?(parent)
+                        ensure_dir_exists(parent, options)
+                    end
+                    Deplate::Core.log(["Creating directory", dir])
+                    Dir.mkdir(dir)
+                else
+                    log(["Directory doesn't exist", dir, Dir.pwd], :error)
+                    exit 5
                 end
-                Deplate::Core.log(["Creating directory", dir])
-                Dir.mkdir(dir)
             end
         end
 
@@ -904,7 +1125,7 @@ MESSAGE
         end
 
         # Purge *path and return it as sting
-        def get_path(*path)
+        def file_join(*path)
             path.compact!
             path.delete(".")
             path.delete("")
@@ -918,75 +1139,110 @@ MESSAGE
         # maj:: The major section/page number
         # maj:: The minor section/page number
         def get_out_fullname(fname, suffix, options, *args)
-            File.join(options.dir, get_out_name(fname, suffix, options, *args))
+            # File.join(options.dir, get_out_name(fname, suffix, options, *args))
+            file_join(options.dir, get_out_name(fname, suffix, options, *args))
         end
 
         def get_out_name(fname, suffix, options, maj=nil, min=nil)
             path = []
             path << get_out_name_dir(fname, options)
             if suffix
-                fn  = File.basename(fname, options.ext)
+                fn  = File.basename(fname, '.*')
                 path << canonic_file_name(fn, suffix, maj, min)
             else
                 path << fname
             end
-            get_path(*path)
+            file_join(*path)
         end
 
+        def declare_symbols(name, klass)
+            @@symbols[name] = klass
+        end
+        
         def declare_input_format(input_class, name=nil)
             @@input_classes[name || input_class.myname] = input_class
         end
         
+        def declare_bibstyle(bib_class, style)
+            @@bib_style[style] = bib_class
+        end
+
         # Make a formatter class publically known.
         def declare_formatter(formatter_class, name=nil)
             @@formatter_classes[formatter_class.myname] = formatter_class
-            name = (name || formatter_class.myname).gsub(/\W/, '_')
-            self.class_eval %{
-                def to_#{name}(text, sourcename=nil)
-                    format_with_formatter(#{formatter_class}, text, sourcename)
-                end
-            }
-            # class << self
-            #     define_method("to_#{name}") do |text, *args|
-            #         sourcename, _ = args
-            #         format_with_formatter(formatter_class, text, sourcename)
-            #     end
-            # end
+            name = (name || formatter_class.myname).gsub(/[^[:alnum:]_]/, '_')
+            self.class_eval do
+                define_method("to_#{name}") do |text, *args|
+                    sourcename, _ = args
+                    reset(true)
+                    format_with_formatter(formatter_class, text, sourcename)
+                end
+            end
         end
 
         # Collect all available modules/parts/libraries etc. Check the 
         # file system and the "builtin" modules (e.g., when using the 
         # win32 exerb distribution).
-        def collect_deplate_options(id=nil, subdir='', suffix='.rb')
-            hash  = {}
-            for d in library_directories(subdir)
+        def collect_deplate_options(id=nil, subdir='', args={})
+            suffix = args[:suffix] || '.rb'
+            use_rc = args[:rc] || false
+            hash   = {}
+            for d in library_directories(use_rc, subdir)
                 collect_deplate_options_in_hash(hash, suffix, Dir[File.join(d, '*%s' % suffix)])
             end
 
             builtin = "builtin_#{id}"
             if id and respond_to?(builtin)
-                collect_deplate_options_in_hash(hash, suffix, send(builtin), File.join('deplate', subdir))
+                files = send(builtin)
+                # files.collect! {|f| "#{f}.rb"}
+                collect_deplate_options_in_hash(hash, suffix, files, File.join('deplate', subdir))
             end
-            
+           
             return hash.keys.sort, hash
         end
 
         # Return an array of directorys that could contain deplate 
         # files.
-        def library_directories(*subdirs)
+        def library_directories(use_rc, *subdirs)
             @library_directories ||= {}
-            id = File.join(*subdirs)
-            unless @library_directories[id]
-                dirs = []
-                dirs << File.join(CfgDir, *subdirs) unless @vanilla
-                dirs << File.join(DataDir, *subdirs)
-                dirs << File.join(LibDir, *subdirs)
-                dirs.delete_if {|d| !File.exist?(d)}
-                @library_directories[id] = dirs
+            acc = []
+            dirs = [DataDir, LibDir]
+            dirs.unshift(CfgDir) unless @vanilla
+            dirs.unshift(File.join(current_pwd, 'deplate.rc')) if use_rc
+            for subdir in subdirs
+                unless @library_directories[subdir]
+                    ad = []
+                    for dir in dirs
+                        if dir
+                            fd = File.join(dir, subdir)
+                            if File.exist?(fd)
+                                ad << fd
+                            end
+                        end
+                    end
+                    @library_directories[subdir] = ad
+                end
+                acc += @library_directories[subdir]
             end
-            @library_directories[id]
+            acc
         end
  
+        def is_file?(fname)
+            return !fname.empty? && File.exists?(fname) && !File.directory?(fname)
+        end
+                
+        def current_pwd(deplate=nil)
+            if deplate and deplate.current_source
+                File.dirname(deplate.current_source)
+            else
+                Dir.pwd
+            end
+        end
+        
+        def quiet?
+            @@quiet
+        end
+        
         private
         # Return the localized text.
         def msg(text)
@@ -998,8 +1254,8 @@ MESSAGE
         end
 
         # Return the proper numbered output filename for name.
-        def canonic_numbered_file_name(name, sfx, maj, min, dir=nil)
-            name = File.basename(name, File.extname(name))
+        def canonic_numbered_file_name(name, sfx, maj=0, min=0, dir=nil)
+            name = File.basename(name, '.*')
             if min == 0
                 idx = '%05d' % maj
             else
@@ -1012,9 +1268,11 @@ MESSAGE
         # Collect files in +array+ in +hash+.
         def collect_deplate_options_in_hash(hash, suffix, array, subdir=nil)
             for m in array
-                key = File.basename(m, suffix) || m
-                hash[key] ||= subdir ? File.join(subdir, m) : m
-                hash[key] ||= subdir ? File.join(subdir, m) : m
+                unless !subdir and File.directory?(m)
+                    key = File.basename(m, suffix) || m
+                    hash[key] ||= subdir ? File.join(subdir, m) : m
+                    hash[key] ||= subdir ? File.join(subdir, m) : m
+                end
             end
         end
 
@@ -1119,32 +1377,32 @@ MESSAGE
         def log_build_colored_message(text, condition, file=nil, line_begin=nil, line_end=nil)
             msg = []
             if file
-                msg << Color.green << Color.bold(file)
-                msg << Color.yellow << ':'
+                msg << Deplate::Color.green << Deplate::Color.bold(file)
+                msg << Deplate::Color.yellow << ':'
                 if line_begin
-                    msg << Color.cyan
+                    msg << Deplate::Color.cyan
                     msg << line_begin
                     msg << '-' << line_end if line_end and line_end != line_begin
-                    msg << Color.yellow
+                    msg << Deplate::Color.yellow
                     msg << ':'
                 end
                 case condition
                 when :error, :unknown_macro
-                    msg << Color.red
+                    msg << Deplate::Color.red
                 else
-                    msg << Color.blue
+                    msg << Deplate::Color.blue
                 end
                 msg << text
             else
                 case condition
                 when :error, :unknown_macro
-                    msg << Color.red
+                    msg << Deplate::Color.red
                 else
-                    msg << Color.magenta
+                    msg << Deplate::Color.magenta
                 end
                 msg << text
             end
-            msg << Color.clear
+            msg << Deplate::Color.clear
             return msg.join
         end
        
@@ -1184,9 +1442,6 @@ MESSAGE
     # A hash that holds the current document's variables.
     attr_accessor :variables
     
-    # A hash holding all known document services (names => method).
-    attr_accessor :doc_services
-    
     # Other document specific variables.
     # A hash containing the footnotes (id => object)
     attr_accessor :footnotes
@@ -1208,8 +1463,6 @@ MESSAGE
     # A hash (label => level_string). Use of this hash should be 
     # replaced with uses of @label_aliases<+TBD+>
     attr_accessor :labels
-    # An array (unused!!!???<+TBD+>)
-    attr_accessor :labels_named
     # An array used to postpone labels until there is some regular 
     # output.
     attr_accessor :labels_floating
@@ -1241,13 +1494,12 @@ MESSAGE
     # other elements.
     attr_accessor :postponed_print
 
-    attr_accessor :current_source, :current_heading, :current_table, :current_figure
-    attr_accessor :current_source_stats, :current_top
-    attr_accessor :table_of_contents, :table_of_tables, :table_of_figures
+    attr_accessor :current_source, :current_source_stats
 
     # a stack with if/elseif status; skip input if the top-switch is true
     attr_accessor :switches
 
+
     # formatter_name:: A formatter name
     # args:: A hash
     def initialize(formatter_name='html', args={})
@@ -1256,7 +1508,6 @@ MESSAGE
         @options      = Deplate::Core.deplate_options(args[:options])
         @sources      = args[:sources] || @options.files
         @dest         = args[:dest]    || @options.out   || ''
-        @doc_services = args[:doc_services] || initialize_services
         @vanilla      = args[:vanilla] || false
 
         # set_safe
@@ -1270,33 +1521,33 @@ MESSAGE
 
         formatter_class = args[:formatter] || @@formatter_classes[formatter_name]
         if formatter_class
-            Deplate::Core.log('Initializing formatter')
+            log('Initializing formatter')
             @formatter = formatter_class.new(self, args)
             call_methods_matching(self, /^formatter_initialize_/)
             call_methods_matching(@formatter, /^formatter_initialize_/)
 
-            Deplate::Core.log('Initializing modules')
+            log('Initializing modules')
             call_methods_matching(self, /^module_initialize_/)
 
-            Deplate::Core.log('Setting up text scanner')
+            log('Setting up text scanner')
             call_methods_matching(self, /^input_initialize_/)
             call_methods_matching(self, /^hook_pre_input_initialize_/)
             initialize_input(args)
             call_methods_matching(self, /^hook_post_input_initialize_/)
 
-            Deplate::Core.log('Setting up formatter')
+            log('Setting up formatter')
             call_methods_matching(@formatter, /^hook_pre_setup_/)
             @formatter.setup
             call_methods_matching(@formatter, /^hook_post_setup_/)
 
-            Deplate::Core.log('User initialization')
+            log('User initialization')
             user_initialize if defined?(user_initialize)
             
             reset_output
             set_standard_clips
 
             if args[:now]
-                Deplate::Core.log('Here we go ...')
+                log('Here we go ...')
                 call_methods_matching(self, /^hook_pre_go_/)
                 call_methods_matching(@formatter, /^hook_pre_go_/)
                 go_now
@@ -1332,6 +1583,8 @@ MESSAGE
         end
     end
 
+    # Change the input format to +name+.
+    # name:: The name of an input format.
     def push_input_format(name)
         unless name
             return false
@@ -1351,6 +1604,9 @@ MESSAGE
         end
     end
     
+    # Restore the previously used input format. If a +name+ is given and 
+    # the name matches the previous input format, do nothing.
+    # name:: The name of an input format.
     def pop_input_format(name=nil)
         if @input_formats.empty?
             return false
@@ -1389,9 +1645,9 @@ MESSAGE
             end
             val = slot_names[slot]
             if val
-                val * modi
+                return val * modi
             else
-                nil
+                return nil
             end
         elsif slot.is_a?(String)
             pos = 0
@@ -1412,27 +1668,25 @@ MESSAGE
         end
     end
 
-    # Initialize symbol related modules.
-    def initialize_symbols
-        Deplate::Core.log("Initializing symbols")
-        call_methods_matching(self, /^initialize_symbols_/)
-    end
-  
     # Call all of obj's methods matching rx
     def call_methods_matching(obj, rx, *args)
         unless @vanilla
-            for m in obj.methods.find_all {|m| m =~ rx }
+            for m in matching_methods(obj, rx)
                 obj.send(m, *args)
             end
         end
     end
- 
+
+    def matching_methods(obj, rx)
+        obj.methods.find_all {|m| m =~ rx }
+    end
+    
     # Reset instance variables.
     # all:: reset really all variables (bool)
     def reset(all=false)
         @current_source   = nil
         @current_source_stats = nil
-        @auto_filenames   = {}
+        @auto_numbered   = {}
        
         @variables = @options.variables.dup
         @variables.deplate = self
@@ -1442,7 +1696,6 @@ MESSAGE
         @index_last_idx   = 0
         @labels           = {}
         @label_aliases    = {}
-        @labels_named     = []
         @labels_floating  = []
         @ids              = {}
         @preprocess       = []
@@ -1454,22 +1707,15 @@ MESSAGE
 
         @headings          = {}
 
-        @table_of_contents = []
-        @table_of_tables   = []
-        @table_of_figures  = []
-
-        @current_heading   = []
         @accum_elements    = []
         @switches          = []
         @metadata          = {}
         
-        @current_figure    = 0
-        @current_table     = 0
-
         set_lang(@@messages_last)
         set_standard_clips
 
         if all
+            @endmessages           = {}
             @allsources            = {}
             @input_formats         = []
             @options.citations     = []
@@ -1477,6 +1723,7 @@ MESSAGE
             @options.dont_index    = []
             @options.author        = []
             @options.heading_names = []
+            Deplate::Core.reset_listings_and_counters(@options)
         end
     end
 
@@ -1484,14 +1731,14 @@ MESSAGE
     # inherit_null_output:: The new output obj inherits the settings from the 
     # initial/anonymous output class (bool)
     def reset_output(inherit_null_output=true)
-        log("Reset output", :debug)
+        log('Reset output', :debug)
         @collected_output = []
         @output_filename  = []
         @output_headings  = []
         @output_maj_min   = [0, 0]
         @null_output      = @output.dup
         if @options.multi_file_output
-            dest = @variables["docBasename"] || @dest
+            dest = @variables['docBasename'] || @dest
             dest &&= File.basename(dest)
             # Deplate::Core.canonic_file_name(dest, @options.suffix, 0, 0)
         else
@@ -1521,8 +1768,11 @@ MESSAGE
         if msg_class
             @options.messages  = msg_class.new(self)
             @@message_object ||= @options.messages
+        elsif is_allowed?('l') and require_module(lang)
+            set_lang(lang)
         else
-            log(["Bad language definition", lang, "(#{@@messages.keys.join(', ')})"], :error)
+            log(["Bad language definition", lang, "(#{@@messages.keys.join(', ')})"],
+                :error)
         end
     end
 
@@ -1531,6 +1781,20 @@ MESSAGE
         self.class.log(*args)
     end
 
+    # Register a new message to be displayed after processing the 
+    # current document.
+    def endmessage(id, message)
+        @endmessages[id] = message
+    end
+    
+    # Print messages after having printed the current document.
+    def print_endmessages
+        @endmessages.each do |id, message|
+            log([message], :anyway)
+        end
+        @endmessages = {}
+    end
+
     # See Deplate::Core.require_module.
     def require_module(m)
         Deplate::Core.require_module(@options, m)
@@ -1587,17 +1851,9 @@ MESSAGE
         read_file
         process_document
         body_write if writeFile
+        print_endmessages
     end
 
-    # Return the index for a top heading.
-    def output_index(top=nil)
-        if top
-            top_heading_idx(top)
-        else
-            @collected_output.size - 1
-        end
-    end
-    
     # Should the file be included or not, e.g., because of a -P 
     # command line option
     def to_be_included?(file)
@@ -1627,9 +1883,18 @@ MESSAGE
     # Get the name for automatically generated auxiliary files (e.g., 
     # when no ID was provided)
     def auxiliary_auto_filename(type, idx, body=nil, suffix=nil)
-        fn = ["_#{type}_#{idx}"]
-        fn << '.' << suffix if suffix
-        return fn.join
+        if @variables['mandatoryID']
+            raise msg('No ID given')
+        else
+            prefix = @variables['prefixID']
+            if prefix.nil?
+                prefix = Deplate::Core.clean_file_name(File.basename(@dest, '.*'))
+            end
+            fn = [prefix]
+            fn << ["_#{type}_#{idx}"]
+            fn << '.' << suffix if suffix
+            return fn.join
+        end
     end
     
     # Get the proper filename for an auxiliary file, respecting 
@@ -1637,7 +1902,7 @@ MESSAGE
     def auxiliary_filename(filename, full_name=false)
         sd = auxiliary_dirname(full_name)
         if sd
-            return Deplate::Core.get_path(sd, filename)
+            return Deplate::Core.file_join(sd, filename)
         else
             return filename
         end
@@ -1648,11 +1913,16 @@ MESSAGE
     # - If auxiliaryDirSuffix isn't defined, return default if non-nil.
     # - Create dir if ensure_dir_exists is true.
     def auxiliary_dirname(full_name=false, ensure_dir_exists=false)
-        sdsfx = @variables['auxiliaryDirSuffix']
         path  = []
         path  << File.dirname(@dest) if full_name
-        path  << File.basename(@dest, '.*') + sdsfx if sdsfx
-        rv    = Deplate::Core.get_path(*path)
+        aux   = @variables['auxiliaryDir']
+        if aux
+            path << aux
+        else
+            sdsfx = @variables['auxiliaryDirSuffix']
+            path  << File.basename(@dest, '.*') + sdsfx if sdsfx
+        end
+        rv = Deplate::Core.file_join(*path)
         ensure_dir_exists(rv) if ensure_dir_exists
         rv
     end
@@ -1681,6 +1951,47 @@ MESSAGE
         return files
     end
    
+    def find_in_lib(fname, args={})
+        if args[:pwd]
+            fn = File.join(Deplate::Core.current_pwd(self), fname)
+            if Deplate::Core.is_file?(fn)
+                return fn
+            end
+        end
+        files = []
+        if @formatter
+            formatter_family_members do |myname|
+                dd = File.join('lib', myname, fname)
+                files << dd unless files.include?(dd)
+            end
+        end
+        files << File.join('lib', fname)
+        files = Deplate::Core.library_directories(true, *files)
+        for fn in files
+            if Deplate::Core.is_file?(fn)
+                return fn
+            end
+        end
+        return nil
+    end
+
+    def formatter_family_members(formatter_class=nil)
+        acc = []
+        fmt = formatter_class ||= @formatter.class
+        myname = fmt.myname
+        while myname
+            acc << myname
+            yield(myname) if block_given?
+            fmt = fmt.superclass
+            myname = fmt.myname
+        end
+        formatter_class.related.each do |myname|
+            acc << myname
+            yield(myname) if block_given?
+        end
+        acc
+    end
+    
     # Format either text or, if text is nil, the file "sourcename".  
     # This is the method called by the Deplate::Formatter's 
     # to_whatsoever methods.
@@ -1722,79 +2033,108 @@ MESSAGE
     # pair of #BEGIN, #END pseudo commands
     def include_stdin(array)
         if $stdin.eof?
-            log("No more input on STDIN", :anyway)
+            log('No more input on STDIN', :anyway)
             exit 1
         end
-        maintain_current_source("") do
-            log("Including from STDIN")
+        maintain_current_source('') do
+            log('Including from STDIN')
             acc = []
             end_tag = nil
             $stdin.each_with_index do |l, i|
                 if i == 0 and l =~ /^#BEGIN:/
-                    end_tag = "#END:" + l[7..-1]
+                    end_tag = '#END:' + l[7..-1]
                 elsif end_tag and l == end_tag
                     break
                 else
                     acc << l
                 end
             end
-            include_each(acc, array, "STDIN")
+            include_each(acc, array, 'STDIN')
         end
     end
 
     # Read a file and add the parsed elements to array
     def include_file(array, filename)
         maintain_current_source(filename) do
-            log(["Including", filename])
+            log(['Including', filename])
             filename_abs    = File.expand_path(filename)
             unless @options.included
                 filename_label  = file_label(filename_abs)
                 @labels_floating << filename_label
             end
-            File.open(filename, "r") do |io|
-                include_each(io, array, filename)
+            File.open(filename, 'r') do |io|
+                text = io.read
+                include_each(text, array, filename)
             end
         end
     end
 
-    # Execute &block while maintaining @current_top
-    def maintain_current_top(top, &block)
-        begin
-            current_top  = @current_top
-            @current_top = top
-            block.call
-        ensure
-            @current_top = current_top
-        end
-    end
-
     # Include each line in enum and accumulate parsed elements in array
     def include_each(enum, array, sourcename=nil)
-        @input.include_enum(enum, array, 0)
+        case enum
+        when Array
+            enum = enum.join("\n")
+        end
+        @input.include_string(enum, array, 0)
     end
 
     # Include strings as if read from a file and return the resulting array of parsed elements
-    def parsed_array_from_strings(strings, linenumber=nil, src="[array]")
+    def parsed_array_from_strings(strings, linenumber=nil, src='[array]')
         array = []
-        include_stringarray(strings, array, linenumber, src)
+        erx   = @variables['embeddedTextRx']
+        begin
+            include_stringarray(strings, array, linenumber, src)
+        ensure
+            @variables['embeddedTextRx'] = erx if erx
+        end
         return array
     end
 
     # Include strings as if read from a file and push parsed elements onto array
-    def include_stringarray(strings, array, linenumber=nil, src="[array]")
+    def include_stringarray(strings, array, linenumber=nil, src='[array]')
         maintain_current_source(src) do
-            @input.include_enum(strings, array, linenumber || 0)
+            include_each(strings, array, linenumber || 0)
         end
     end
 
+    def auto_numbered(base, args=nil)
+        if args
+            n = if (s = args[:set])
+                    @auto_numbered[base] = s
+                elsif (s = args[:inc])
+                    if @auto_numbered[base]
+                        @auto_numbered[base] += s
+                    else
+                        @auto_numbered[base] = 0
+                    end
+                else
+                    log(['Internal error', 'auto_numbered', base, args], :error)
+                    nil
+                end
+            if (t = args[:fmt])
+                t % n
+            elsif (t = args[:fmt0])
+                if n > 0
+                    t % n
+                else
+                    t % nil
+                end
+            else
+                n
+            end
+        else
+            return @auto_numbered[base]
+        end
+    end
+    
     # Set the current top heading.
     # heading:: Heading object
     # text:: The output filename base
     def set_top_heading(heading, text)
-        if heading.level == 1
+        if heading.level <= @options.split_level
             fname = nil
             sfx   = @options.suffix
-            dir   = @options.dir
+            # dir   = @options.dir
             if @output_headings.include?(heading)
                 maj = top_heading_idx(heading)
             else
@@ -1802,19 +2142,41 @@ MESSAGE
                 push_top_heading(heading)
                 maj = @output_headings.size - 1
                 unless text or !@options.multi_file_output
-                    if @variables["autoFileNames"]
+                    afn = @variables['autoFileNames']
+                    if afn
                         fname = Deplate::Core.clean_file_name(heading.get_text)[0..20]
-                        c = @auto_filenames[fname]
+                        c = auto_numbered(fname)
                         if c
                             fname = Deplate::Core.canonic_file_name(fname, sfx, c, 0)
-                            @auto_filenames[fname] += 1
+                            auto_numbered(fname, :inc => 1)
                         else
                             fname = Deplate::Core.canonic_file_name(fname, sfx)
-                            @auto_filenames[fname] = 0
+                            auto_numbered(fname, :set => 0)
                         end
                     else
-                        fname = File.basename(@dest, File.extname(@dest))
-                        fname = Deplate::Core.canonic_file_name(fname, sfx, maj, 0)
+                        # if @variables['autoBaseName']
+                        #     fname = File.basename(@current_source, '.*')
+                        #     fmaj  = if auto_numbered(fname)
+                        #                 auto_numbered(fname, :inc => 1)
+                        #             else
+                        #                 auto_numbered(fname, :set => 0)
+                        #             end
+                        # else
+                        #     fname = File.basename(@dest, '.*')
+                        #     fmaj  = maj
+                        # end
+                        fname = @variables['autoBaseName'] ? @current_source : @dest
+                        fname = File.basename(fname, '.*')
+                        fmaj  = if auto_numbered(fname)
+                                    auto_numbered(fname, :inc => 1)
+                                # <+TBD+>
+                                elsif @accum_elements.size == 1 and 
+                                    @accum_elements[0].kind_of?(Deplate::Element::PotentialPageBreak)
+                                    auto_numbered(fname, :set => 0)
+                                else
+                                    auto_numbered(fname, :set => 1)
+                                end
+                        fname = Deplate::Core.canonic_file_name(fname, sfx, fmaj, 0)
                     end
                 end
             end
@@ -1858,6 +2220,15 @@ MESSAGE
         @output_headings.size
     end
 
+    # Return the index for a top heading.
+    def output_index(top=nil)
+        if top
+            top_heading_idx(top)
+        else
+            @collected_output.size - 1
+        end
+    end
+
     # Return the nth output filename.
     # idx:: Top heading index (integer)
     def output_filename_by_idx(idx)
@@ -1869,6 +2240,7 @@ MESSAGE
     
     # accum format elts in pre/body|matter/post
     def printable_strings(strings, linenumber=nil, src="[array]")
+        @formatter.pre_process
         output = []
         accum_elements = []
         include_stringarray(strings, accum_elements, linenumber, src)
@@ -1885,28 +2257,23 @@ MESSAGE
         end
         return output
     end
-  
-    # Run a "service", i.e., a small, mostly autonomous function/method that 
-    # usually yields some formatted output.
-    def invoke_service(name, args={}, text="")
-        method = @doc_services[name]
-        if method
-            begin
-                return send(method, args || {}, text || "")
-            rescue Exception => e
-                puts e.backtrace[0..10].join("\n")
-                Deplate::Core.log(["Calling service failed", name, e], :error)
-            end
-        else
-            Deplate::Core.log(["Unknown service", name], :error)
-        end
+ 
+    def is_allowed?(ids, args={})
+        args = args.dup
+        args[:logger] ||= self
+        Deplate::Core.is_allowed?(@options, ids, args)
     end
-
+    
     # Return whether ruby code may be evaluated.
     def allow_ruby
-        return @options.allow_ruby
+        @options.allow_ruby || is_allowed?('x')
     end
 
+    # Return whether external applications may be run
+    def allow_external
+        @options.allow_external || is_allowed?('X')
+    end
+    
     # Caller requests calling ruby code with some args
     def eval_ruby(invoker, args, code)
         ar = allow_ruby
@@ -1996,10 +2363,14 @@ MESSAGE
     end
  
     def relative_path_by_file(file, base_file)
-        if base_file
-            relative_path(file, File.dirname(base_file))
+        if file
+            if base_file
+                relative_path(file, File.dirname(base_file))
+            else
+                File.basename(file)
+            end
         else
-            File.basename(file)
+            ''
         end
     end
     
@@ -2022,8 +2393,7 @@ MESSAGE
     # Amend +file+'s suffix.
     def file_with_suffix(file, sfx=nil, filename_only=false)
         sfx  = sfx || ""
-        sfx0 = File.extname(file)
-        fn   = File.basename(file, sfx0)
+        fn   = File.basename(file, '.*')
         if filename_only
             return fn + sfx
         else
@@ -2045,7 +2415,8 @@ MESSAGE
             else
                 las = level_as_string.to_s
             end
-            if las == ""
+            case las
+            when '', '0'
                 top = top_heading_by_idx(0)
             else
                 top = nil
@@ -2057,6 +2428,8 @@ MESSAGE
                         end
                     end
                     raise "Internal error: unknown level: #{level_as_string}"
+                    log(['Internal error: Unknown level', level_as_string], :error)
+                    return nil
                 end
             end
             return top.destination
@@ -2077,7 +2450,7 @@ MESSAGE
                 return "%s00%s" % [prefix, text.gsub(/\W/, "00")]
             end
         else
-            raise msg("No label")
+            # raise msg("No label")
             log(["No label", prefix], :error)
             return nil
         end
@@ -2112,7 +2485,7 @@ MESSAGE
             for output in @collected_output
                 rv = send(method, @dest, output)
             end
-        elsif @dest == "-"
+        elsif @dest == '-'
             sep = @variables["stdoutSeparator"]
             for output in @collected_output
                 puts(output.join("\n"))
@@ -2132,7 +2505,7 @@ MESSAGE
                     call_methods_matching(@formatter, /^hook_post_write_file_/)
                     output.merge_metadata(@metadata)
                     if @options.metadata_model and output.metadata_available?
-                        md_dest = File.join(@options.dir, output.metadata_destination)
+                        md_dest = Deplate::Core.file_join(@options.dir, output.metadata_destination)
                         log(["Saving metadata", md_dest])
                         write_metadata(md_dest, output)
                     end
@@ -2173,31 +2546,34 @@ MESSAGE
 
     # Make sure +dir+ exists (create it if it doesn't).
     def ensure_dir_exists(dir)
-        unless File.exist?(dir)
-            if @options.force
-                Deplate::Core.ensure_dir_exists(dir)
-            else
-                log(["Destination directory doesn't exist", dir, Dir.pwd], :error)
-                exit 5
-            end
-        end
+        Deplate::Core.ensure_dir_exists(dir, @options)
+        # unless File.exist?(dir)
+        #     if @options.force
+        #         Deplate::Core.ensure_dir_exists(dir, @options)
+        #     else
+        #         log(["Destination directory doesn't exist", dir, Dir.pwd], :error)
+        #         exit 5
+        #     end
+        # end
     end
     
     # Actually write something to some file.
-    def write_file(file, &block)
+    def write_file(file, mode='w', &block)
         if file
             # pwd = Dir.pwd
             begin
                 #     Dir.chdir(@options.dir)
                 ensure_dir_exists(File.dirname(file))
-                ok = if File.exist?(file) and @options.ask
-                         print "File '#{file}' already exists. Overwrite (y/N)? "
-                         gets.chomp == 'y'
+                ok = if File.exist?(file)
+                         Deplate::Core.query_user(@options, 
+                                                  "File '#{file}' already exists. Overwrite (y/N)? ", 
+                                                  'y')
                      else
                          true
                      end
                 if ok
-                    File.open(file, 'w') do |io|
+                    log(['Writing file', file], :debug)
+                    File.open(file, mode) do |io|
                         block.call(io)
                     end
                 end
@@ -2212,23 +2588,43 @@ MESSAGE
         end
     end
     
-    # Increase the heading level.
-    def increase_current_heading(level)
-        if @current_heading.size < level
-            while @current_heading.size < level
-                @current_heading << 1
-            end
+    # Copy a file.
+    def copy_file(from, to)
+        if File.directory?(to)
+            to = File.join(to, File.basename(from))
+            dir = to
+        else
+            dir = File.dirname(to)
+        end
+        if File.exist?(to)
+            log(['File already exists', to])
         else
-            while @current_heading.size > level
-                @current_heading.pop
+            ok = if @options.ask
+                     puts "File '#{file}' already exists. Overwrite (y/N)? "
+                     gets.chomp == 'y'
+                 else
+                     true
+                 end
+            if ok
+                ensure_dir_exists(dir)
+                File.copy(from, to)
+                log(['Copy file', to])
             end
-            @current_heading << (@current_heading.pop + 1)
         end
     end
-
+    
+    def current_heading
+        @options.counters.get('toc')
+    end
+    
     # Get the current section's level as string.
     def get_current_heading
-        return @current_heading.join(".")
+        @options.counters.get_s('toc')
+    end
+
+    # Increase the heading level.
+    def increase_current_heading(level)
+        @options.counters.increase('toc', :level => level)
     end
 
     # Get the current top heading object.
@@ -2236,21 +2632,33 @@ MESSAGE
         top_heading_by_idx(top_heading_idx)
     end
  
+    def get_numbering_mode(entity, default=1)
+        (@variables["#{entity}Numbering"] || default).to_i
+    end
+    
     # Register a new label.
     # invoker:: The labelled object
     # label:: The label name
     # level_as_string:: The section heading's level as string (redundant???)
     def add_label(invoker, label, level_as_string, opts={})
         if !opts[:anyway] and (@labels[label] or @label_aliases[label])
-            invoker.log(["Label already defined", label, level_as_string], :error)
+            invoker.log(['Label already defined', label, level_as_string], :error)
         else
             @labels[label]        = level_as_string
             @label_aliases[label] = opts[:container] || invoker
         end
     end
 
-    # <+TBD+>This doesn't work as intended. Elements still have to be labelled in order to 
-    # be referred to by their ID
+    def set_label_object(invoker, label, level_as_string, opts={})
+        if @label_aliases[label]
+            @label_aliases[label] = opts[:container] || invoker
+        else
+            # add_label(invoker, label, level_as_string, opts
+        end
+    end
+    
+    # <+TBD+>This doesn't work as intended. Elements still have to be 
+    # labelled in order to be referred to by their ID
     def get_label_by_id(invoker, id)
         o = @ids[id]
         if o
@@ -2263,7 +2671,7 @@ MESSAGE
                 # invoker.log(["Object has no label", id], :error)
             end
         else
-            invoker.log(["No object with that id", id], :error)
+            invoker.log(['No object with that ID', id], :error)
         end
     end
 
@@ -2274,13 +2682,13 @@ MESSAGE
             f = f.top_heading.destination
             d = invoker.top_heading.destination
             if f == d
-                return ""
+                return ''
             else
                 return relative_path(f, File.dirname(d))
             end
         else
             # puts caller
-            invoker.log(["Reference to unknown label", label], :error)
+            invoker.log(['Reference to unknown label', label], :error)
         end
     end
  
@@ -2353,18 +2761,18 @@ MESSAGE
             if @ids[id]
                 # obj.log(["ID with the same name already exists", id, @ids[id].level_as_string], :error)
             else
-                obj.log(["Register id", id, obj.class], :debug)
+                obj.log(["Register ID", id, obj.class], :debug)
                 @ids[id] = obj
             end
         end
     end
     
     # Register a new index entry.
-    def add_index(container, names, level_as_string="")
+    def add_index(container, names, level_as_string='')
         @index_last_idx += 1
-        id       = "idx00#{@index_last_idx}"
-        words    = names.split(/\s*\|\s*/)
-        lname    = Deplate::Core.remove_backslashes(words[0])
+        id    = "idx00#{@index_last_idx}"
+        words = names.split(/\s*\|\s*/)
+        lname = Deplate::Core.remove_backslashes(words[0])
         level_as_string = container ? container.level_as_string : level_as_string
         if @options.dont_index.delete(lname)
             return nil
@@ -2388,7 +2796,13 @@ MESSAGE
             else
                 f = @dest
             end
-            d = IndexEntry.new(lname, words, id, f, level_as_string)
+            d = Deplate::IndexEntry.new(container) do |idx|
+                idx.name            = lname
+                idx.synonymes       = words
+                idx.label           = id
+                idx.file            = f
+                idx.level_as_string = level_as_string
+            end
             if i
                 i << d
             else
@@ -2442,6 +2856,7 @@ MESSAGE
     def parse_and_format_without_wikinames(container, text, alt=true)
         excluded = [
             Deplate::HyperLink::Simple,
+            Deplate::HyperLink::Extended,
         ]
         return parse_and_format(container, text, alt, excluded)
     end
@@ -2453,15 +2868,16 @@ MESSAGE
             arr   = @output_headings
             depth = false
         else
-            arr = @table_of_contents
+            arr = @options.listings.get('toc')
         end
         for section in arr
             if !depth or (section and section.level <= depth)
                 unless section and section.args["noList"]
                     if section.kind_of?(Deplate::NullTop)
-                        v = section.caption
+                        v = section.caption.elt
                     else
-                        v = section.description.gsub(/<\/?[^>]*>/, "")
+                        v = section.description
+                        v = v.gsub(/<\/?[^>]*>/, "")
                         v = [section.level_as_string, v].join(" ")  unless section.plain_caption?
                     end
                     block.call(section, v)
@@ -2469,51 +2885,37 @@ MESSAGE
             end
         end
     end
-
-    # <+TBD+>
-    def serve_object_by_id(args, text)
-        if args["id"]
-            o  = @ids[args["id"]]
-            if o
-                return o
-            else
-                log(["Serving object failed because of unknown object", id], :error)
-            end
-        elsif args["array"]
-            text = args["array"]
-            sep = args["sep"]
-            if sep
-                sep  = sep ? Regexp.escape(sep) : "\\s+"
-            else
-                sep = args["rx"]
-            end
-            if sep
-                return text.split(Regexp.new(sep))
-            else
-                log("Serving array failed because no separator was defined", :error)
+    
+    def bib_styler(style)
+        styler = @@bib_style[style] || @@bib_style['default']
+        styler.new(self)
+    end
+   
+    def home_index
+        hidx = @variables['homeIndex']
+        if hidx
+            return hidx
+        else
+            @collected_output.each_with_index do |o, i|
+                unless o.body_empty?
+                    return i
+                end
             end
+            return 0
         end
     end
 
-    # <+TBD+>
-    def serve_formatted_object(args, text)
-        id = args["id"] || text
-        o  = @variables[id]
+    def object_by_id(id)
+        o = @ids[id]
         if o
-            return o.format_as_string
+            return o
         else
-            log(["Formatting object failed because of unknown variable", id], :error)
+            log(['Unknown ID', id], :error)
         end
     end
 
-    private
-    def initialize_services
-        services = {}
-        services['object'] = :serve_object_by_id
-        services['format'] = :serve_formatted_object
-        return services
-    end
 
+    private
     def set_safe
         if @options.allow_ruby and @options.allow_ruby.kind_of?(Integer)
             $SAFE = @options.allow_ruby
@@ -2532,7 +2934,7 @@ MESSAGE
         @clips = @options.clips.dup if options.clips_initialized
     end
     
-    def reset_footones
+    def reset_footnotes
         @footnote_last_idx = 0
         @footnotes_used = []
     end
@@ -2558,16 +2960,17 @@ MESSAGE
     # Set @formatter to an instance of formatter_class, call block, and 
     # restore the old @formatter
     def with_formatter(formatter_class, &block)
-        if @formatter.instance_of?(formatter_class)
-            block.call
-        else
-            formatter_orig = @formatter
-            begin
-                @formatter = formatter_class.new(self)
-                block.call
-            ensure
-                @formatter = formatter_orig
+        formatter_orig = @formatter
+        begin
+            if @formatter.instance_of?(formatter_class)
+                @formatter = @formatter.dup
+                @formatter.reset!
+            else
+                @formatter = formatter_class.new(self, @args)
             end
+            block.call
+        ensure
+            @formatter = formatter_orig
         end
     end
 
@@ -2617,13 +3020,11 @@ MESSAGE
 
         for fn in @footnotes.keys
             e = @footnotes[fn]
-            @current_top   = e.top_heading
             @footnotes[fn] = e.process
         end
 
         for clp in @clips.keys
             e = @clips[clp]
-            @current_top = e.top_heading
             @clips[clp]  = e.process
         end
     end
@@ -2633,7 +3034,6 @@ MESSAGE
         log("Processing elements")
         call_methods_matching(@formatter, /^hook_pre_process_/)
         @accum_elements.collect! do |e|
-            @current_top = e.top_heading
             e.process
         end
         @accum_elements.flatten!
@@ -2649,13 +3049,12 @@ MESSAGE
     end
 
     def print_etc
-        reset_footones
+        reset_footnotes
     end
 
     def print
         log("Formatting elements")
         for e in @accum_elements
-            @current_top = e.top_heading
             e.print
         end
         for p in @postponed_print
@@ -2686,7 +3085,6 @@ MESSAGE
     # Set heading as the current top heading.
     def push_top_heading(heading)
         @output_headings << heading
-        @current_top = heading
     end
     
     def increase_maj_min(minor=false)
@@ -2699,6 +3097,7 @@ MESSAGE
     
 end
 
+
 # vim: ff=unix
 # Local Variables:
 # revisionRx: MicroRev\s\+=\s\+\'