# vim:sw=4 sta et showmatch

# db2x_manxml - convert Man-XML to Texinfo

#               (See docbook2X documentation for details)

#

# (C) 2000-2004 Steve Cheng <stevecheng@users.sourceforge.net>

#

# See the COPYING file in the docbook2X distribution 

# for the copyright status of this software.

#      

# Note: db2x_manxml.pl does not run by itself!

#       It must be configured by including a config.pl file

#       which is done when building docbook2X.

#       In addition, the non-standard module 

#       XML::Handler::SGMLSpl must be explicitly loaded

#       when docbook2X is not installed.

package main;

use strict;

##################################################

#

# Option parsing

#

##################################################

use Getopt::Long;

Getopt::Long::Configure('gnu_getopt');

my $cmdoptions = { 

    'encoding' => 'us-ascii',

    'list-files' => 0,

    'to-stdout' => 0,

    'output-dir' => '',

    'symlinks' => 0,

    'solinks' => 0,

    'no-links' => 0,

    'utf8trans-program' => $db2x_config{'utf8trans-program'},

    'utf8trans-map' => $db2x_config{'utf8trans-map-roff'},

    'iconv-program' => $db2x_config{'iconv-program'},

};

sub options_help {

    print "Usage: $0 [OPTION]... [FILE]...\n";

    print <<'end';

Make man pages from Man-XML

  --encoding=ENCODING   Character encoding for man pages

                        Default is US-ASCII

  --list-files          Write list of output files to stdout

  --to-stdout           Write output to stdout instead of to files

  --output-dir          Directory to write the output files

                        Default is current working directory

  Some man pages are made available under multiple names. Use one of 

  the following to select how should these names be made available:

  --symlinks            Symbolic links to principal man page

  --solinks             Stub pages with .so requests to principal man page

  --no-links            Make man page available only under principal name

  These options set the location of auxiliary programs:

  --utf8trans-program=PATH, --utf8trans-map=PATH, --iconv-program=PATH

  --help                Show this help and exit

  --version             Show version and exit

See the db2x_manxml(1) manual page and the docbook2X documentation for

more details.

end

    exit 0;

}

sub options_version

{

    print "db2x_manxml (part of docbook2X " . 

            $db2x_config{'docbook2X-version'} . ")\n";

    print <<'end';

$Revision: 1.62 $ $Date: 2006/04/22 15:21:32 $

<URL:http://docbook2x.sourceforge.net/>

Copyright (C) 2000-2004 Steve Cheng

This is free software; see the source for copying conditions.  There is NO

warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

end

    exit 0;

}

$SIG{__WARN__} = sub { print STDERR "$0: " . $_[0]; };

if(!GetOptions($cmdoptions,

    'encoding=s',

    'list-files',

    'to-stdout',

    'output-dir=s',

    'symlinks|sym-links',

    'solinks|so-links',

    'no-links|nolinks',

    'utf8trans-program=s',

    'utf8trans-map=s',

    'iconv-program=s',

    'help', \&options_help,

    'version', \&options_version))

{

    print STDERR "Try \"$0 --help\" for more information.\n";

    exit 1;

}

$SIG{__WARN__} = undef;

if($cmdoptions->{'symlinks'} +

   $cmdoptions->{'solinks'} +

   $cmdoptions->{'no-links'} > 1)

{

    print STDERR "$0: Only one of --symlinks, --solinks or --no-links options is allowed!\n";

    exit 1;

} elsif($cmdoptions->{'symlinks'} +

   $cmdoptions->{'solinks'} +

   $cmdoptions->{'no-links'} == 0)

{

   $cmdoptions->{'no-links'} = 1;

}

#use XML::Handler::SGMLSpl;     # we link to this explicitly during building

$manxml::templates = XML::Handler::SGMLSpl->new(

                        { 'options' => $cmdoptions });

$manxml::templates->push_mode('file-unselected');

$manxml::templates->{namespaces}->{''} = "http://docbook2x.sourceforge.net/xmlns/Man-XML";

##################################################

#

# RoffWriter: Sanitized output routines

#

##################################################

package RoffWriter;

require Exporter;

@RoffWriter::ISA = qw(Exporter);

@RoffWriter::EXPORT_OK = qw(man_escape man_normalize_ws);

#

# Use RoffWriter on specified file

# Params: fh - an IO::Handle to send the output

#

sub new

{

    my ($class, $fh) = @_;

    my $self = { fh => $fh, line_start => 1, whitespace_last => 0 };

    return bless($self, $class);

}

#

# Write output to filehandle

# or the string buffer (see buffer_{on,off}).

#

sub write

{

    my ($self, $text) = @_;

    if(defined $self->{stringbuffer}) {

        $self->{stringbuffer} .= $text;

    } else {

        $self->{fh}->print($text);

    }

}

#

# buffer_on, buffer_off

#

# Hack to allow the user to buffer output temporarily

# to a string which can be back pasted in later with write().

#

# This is used, in particular, for tbl output:

# The column and span width information must precede

# the cell data for each row, but the cell data may be 

# arbitrarily complex text mixed with any number of 

# roff requests.

#

# Don't take this facility lightly :)

# It is low-level: it intentionally does not save or restore

# the line_start internal state --- you must do that yourself,

# or use this facility only at well-defined points

# (e.g. only at line_start = 1).

#

sub buffer_on

{

    my ($self) = @_;

    $self->{stringbuffer} = '';

}

sub buffer_off

{

    my ($self) = @_;

    my $stringbuffer = $self->{stringbuffer};

    $self->{stringbuffer} = undef;

    return $stringbuffer;

}

#

# Print text with whitespace folding

# Usually need to escape text first

# Params: text - string to print

# 

sub print_ws

{

    my ($self, $text) = @_;

    my @lines = split(/(\n)/, $text);

    foreach my $line (@lines) {

        # Go to beginning of next line

        # unless already at beginning of a line

        if($line eq "\n") {

            $self->write("\n")

                unless $self->{line_start}++;

        } else {

            # No spaces at the beginning of a line.

            # 

            # The second if condition ensures that whenever the 

            # 'logical' input contains a string of whitespace, but

            # the 'logical' input is split into two separate print_ws

            # in the middle of the string of whitespace, like this:

            #

            # print_ws('text      ') ; print_ws('     more text')

            #

            # Then the output should be 'text more text'

            # with one space in between the (first two) words.

            #

            # NB: The use of 'whitespace' here excludes the newline.

            # NB: whitespace_last is only meaningful when

            #     line_start == 0.  This interpretation

            #     allows us to not have to update 

            #     the whitespace_last status as much.

            #

            $line =~ s/^[ \t]+// if $self->{line_start}

                or $self->{whitespace_last};

            # "." and "'" get misinterpreted as a request

            # at beginning of lines, so use a no-width space

            # to prevent that.

            $line =~ s/^([.'])/\\\&$1/ if $self->{line_start};

            # Fold whitespaces in the middle of the line

            $line =~ tr/ \t/ /s;

            if($line ne '') {

                $self->write($line);

                $self->{line_start} = 0;

                $self->{whitespace_last} = ($line =~ /[ \t]$/);

            }

        }

    }

}

#

# Print text without folding whitespace

# Usually need to escape text first

# Params: text - string to print

#

sub print

{

    my ($self, $text) = @_;

    my @lines = split(/(\n)/, $text);

    foreach my $line (@lines) {

        if($line eq "\n") {

            $self->write("\n");

            $self->{line_start} = 1;

        } else {

            # "." and "'" get misinterpreted as a request

            # at beginning of lines, so use a no-width space

            # to prevent that.

            $line =~ s/^([.'])/\\\&$1/ if $self->{line_start};

            $self->{line_start} = ($line eq '');

            $self->{whitespace_last} = ($line =~ /[ \t]$/);

            $self->write($line);

        }

    }

}

sub skip_line

{

    my ($self) = @_;

    $self->write(($self->{line_start}++? "\n" : "\n\n"));

}

#

# Make a roff "request"

# Params: name - request identifier.  The beginning '.' is optional.

#         args - request arguments, in raw form.

#                If there are characters to be escaped,

#                wrap the string in a call to string_escape.

# Does not support using a different request start character.

#

sub request

{

    my ($self, $name, @args) = @_;

    $name = ".$name" if $name !~ /^[\.']/;

    $self->write 

        ($self->{line_start} ? "$name" : "\n$name");

    foreach my $arg (@args) {

        $arg =~ tr/\n/ /;

        # Suggestion from groff Info manual.

        # Escape double quotes using \(dq

        $arg =~ s/"/\\\(dq/g;

        # Quote arguments if either

        # 1. the argument contains spaces

        # 2. the argument is empty, and it is not the sole

        #    argument to the request

        $arg = '"' . $arg . '"' if ($arg =~ / /

            or (@args>1 and $arg eq ''));

        $self->write(' ' . $arg);

    }

    $self->write("\n");

    $self->{line_start} = 1;

}

#

# Print a comment in the output.

# Params: comment - the comment text.  

#                   May use any characters; they need not be escaped.

#

sub comment

{

    my ($self, $comment) = @_;

    $self->write("\n") unless $self->{line_start};

    foreach my $line (split(/\n/, $comment)) {

        $self->write('.\" ');

        $self->write($line);

        $self->write("\n");

    }

    $self->{line_start} = 1;

}

#

# Use a roff "escape" i.e. commands embedded in text starting with \

# Params: escape - the escape sequence, excluding \

# Does not support using a different escape character.

#

sub escape

{

    my ($self, $escape) = @_;

    $self->write("\\$escape");

}

#

# Escape characters special to roff so they are displayed literally

# Params: s - the string to escape

# Returns: new string, with offending characters escaped

#

sub man_escape

{

    my $s = shift;

    $s =~ s/\\/\\e/g;

    return $s;

}

sub man_normalize_ws

{

    my $s = shift;

    $s =~ tr/[ \t\n]/ /s;

    $s =~ s/(^ )|( $)//;

    return $s;

}

package manxml;

import RoffWriter qw(man_escape man_normalize_ws);

use IO::File;

use vars qw($templates);

##################################################

#

# Man page management

#

##################################################

# Remove leading and trailing blanks.

sub strip_string

{

    my $str = shift;

    $str = $1 if ($str =~ m#^\s*(\S.*)#);

    $str = $1 if ($str =~ m#^(.*\S)\s*$#);

    return $str;

}

#

# Generate a good file name for a man page, given a title and section

# 

# Params: title - man page title

#         section - 1, 2, 3, 4, etc.

#

sub man_filename

{

    my $title = strip_string(shift);

    my $sect = strip_string(shift);

    # Escape the path separator '/' which is not allowed

    # in Unix file names. (NUL is not allowed either, but 

    # it can't occur in XML data anyway.)

    # Also escape lone . or .., or blank file name,

    # which are also not allowed.

    # 

    # We deliberate do NOT escape any other characters

    # (e.g. space) because the user who happens to want

    # to use a space in his file names, for whatever reason,

    # would be justifiably annoyed at us if we had hard-coded

    # any unnecessary escaping here. 

    #

    # On the other hand, for people who want escaping, they 

    # can either fix their XML sources or stylesheets, very easily.

    $title =~ tr/\//_/;

    $sect =~ tr/\//_/;

    $title =~ s/^(\.{0,2})$/_$1/;

    return "$title.$sect";

}

sub shell_quote

{

    join(' ', map { my $u = $_;

                    $u =~ s#([\$`"\\\n])#\\$1#g;

                    '"' . $u . '"' } @_);

}

sub man_openfile

{

    my ($self, $filename) = @_;

    my $encoding = $self->{options}->{'encoding'};

    my $dir = $self->{options}->{'output-dir'};

    $dir =~ s/([^\/])$/$1\//;     # terminate with slash

    my $openstr = '';

    if(($encoding !~ /^utf|ucs/i or $encoding =~ s/\/\/TRANSLIT$//i)

        and $self->{options}->{'utf8trans-program'} ne '') 

    {

        $openstr .= '| ' .

            shell_quote($self->{options}->{'utf8trans-program'}) . ' -- ' .

            shell_quote($self->{options}->{'utf8trans-map'}) . ' ';

    }

    if($encoding !~ /^utf-?8$/i 

        and $self->{options}->{'iconv-program'} ne '') 

    {

        $openstr .= '| ' .

            shell_quote($self->{options}->{'iconv-program'},

                        '-f', 'utf-8',

                        '-t', $encoding)

            . ' ';

    }

    if($openstr eq '') {

        if(!$self->{options}->{'to-stdout'}) {

            $openstr = "${dir}$filename";

            # Trick from Perl FAQ to open file with arbitrary characters

            $openstr =~ s#^(\s)#./$1#;

            $openstr = ">${openstr}\0";

            print "${dir}$filename\n"

                if $self->{options}->{'list-files'};

        } else {

            $openstr = '>-';

        }

    } else {

        if(!$self->{options}->{'to-stdout'}) {

            $openstr .= '> ' . shell_quote("${dir}$filename");

            print "${dir}$filename\n"

                if $self->{options}->{'list-files'};

        }

    }

    my $iof = new IO::File($openstr)

        or die "$0: error opening $openstr: $!\n";

    # Set output encoding to UTF-8 on Perl >=5.8.0

    # so it doesn't complain

    binmode($iof, ":utf8") unless $] < 5.008;

    return $iof;

}

$templates->add_rule('manpage<', 'file-unselected', sub {

    my ($self, $elem, $templates) = @_;

    my $filename = man_filename(

                    $elem->attr('title'),

                    $elem->attr('sect'));

    $self->{fh} = man_openfile($self, $filename);

    $self->{rw} = new RoffWriter($self->{fh});

    $self->{'adjust-stack'} = [ 'b' ];

    $self->{rw}->comment($elem->attr('preprocessors'))

        if($elem->attr('preprocessors') ne '');

    # I've dug through the Internet to see if there was any

    # standard way to specify encoding with man pages.

    # The following seems to be a reasonable proposal:

    # <URL:http://mail.nl.linux.org/linux-utf8/2001-04/msg00168.html>

    my $encoding = $self->{options}->{'encoding'};

    $encoding =~ s#//TRANSLIT$##i;

    $self->{rw}->comment("-*- coding: $encoding -*-");

    # Define escapes for switching to and from monospace fonts (groff only)

    $self->{rw}->request(qw{ .if \n(.g .ds T< \\\\FC});

    $self->{rw}->request(qw{ .if \n(.g .ds T> \\\\F[\n[.fam]]});

    # Provide the URL macro

    $self->{rw}->request(qw{ .de URL});

    $self->{rw}->print('\\\\$2 \(la\\\\$1\(ra\\\\$3');

    $self->{rw}->request('..');

    $self->{rw}->request(qw{ .if \n(.g .mso www.tmac});

    $self->{rw}->request('TH',

        # Nothing in the man macros say this has to be the same as

        # the $file and $sect.  While it is best to follow convention,

        # some stylesheets may want to uppercase/lowercase the name, 

        # so it is best leave this to them.

        man_normalize_ws(man_escape($elem->attr('h1'))),

        man_normalize_ws(man_escape($elem->attr('h2'))),

        man_normalize_ws(man_escape($elem->attr('h3'))),

        man_normalize_ws(man_escape($elem->attr('h4'))),

        man_normalize_ws(man_escape($elem->attr('h5'))));

    $templates->pop_mode();

});

$templates->add_rule('manpage>', 'file-unselected', sub {

    my ($self, $elem, $templates) = @_;

    $self->{rw}->print_ws("\n");        # ensure file ends in eol

    $self->{fh}->close

        or die $! ? "$0: error closing file/pipe: $!\n"

                  : "$0: program in pipeline exited with an error\n";

    $self->{fh} = undef;

    $self->{rw} = undef;

    my $mainfilename = man_filename($elem->attr('title'),

                                    $elem->attr('sect'));

    # Make the files for the alternate names for the man page

    foreach my $refname (@{$elem->ext->{'refnames'}})

    {

        my $filename = man_filename($refname, $elem->attr('sect'));

        if($filename eq $mainfilename || $self->{options}->{'no-links'}

            || $self->{options}->{'to-stdout'})

        {

            # Same as main man page, don't make link.

        }

        else {

            print STDOUT "$filename\n"

                if $self->{options}->{'list-files'};

            if($self->{options}->{'symlinks'}) {

                symlink($mainfilename, $filename);

            } else {

                my $sectnum = $1 if $mainfilename =~ /^.+\.(\d)/;

                my $fh = new IO::File $filename, "w";

                my $rw = new RoffWriter($fh);

                $rw->request('so', 

                    man_escape("man${sectnum}/$mainfilename"));

                $fh->close;

            }

        }

    }

    $templates->push_mode('file-unselected');

});

$templates->add_rule('manpageset<', 'file-unselected', sub {});

$templates->add_rule('manpageset>', 'file-unselected', sub {});

$templates->add_rule('text()', 'file-unselected', \&illegal_text_handler);

$templates->add_rule('*<', 'file-unselected', \&illegal_element_handler);

##################################################

#

# A clean solution to the extra-newlines problem

#

##################################################

# Call before almost block-level element; needed to ensure

# hanging indent and line-breaking before and after

# is handled correctly.

sub block_start

{

    my ($self, $elem) = @_;

    my $lastchild = $elem->parent->ext->{lastchild};

    # There's no macro to stop the hang indent without

    # starting a new paragraph (.PP), so it has to be

    # done at the beginning of the next block.

    if($lastchild eq 'hanging') {

        $self->{rw}->request('PP');

    }

    # Conversely, here we are supposed to be hanging, 

    # so do not use .PP, which would nullify it

    elsif($elem->within('TPitem')) {

        $self->{rw}->skip_line()

            unless $lastchild eq '';    # Don't put blank before first block

    }

    # Start a new 'paragraph'

    elsif($lastchild eq 'block') {

        # .PP macro messes up the indentation when

        # used inside a table entry.

        if($elem->parent->name eq 'entry') {

            $self->{rw}->skip_line();

        } else {

            $self->{rw}->request('PP');

        }

    }

    # Could also be done with .PP.

    elsif($lastchild eq 'inline') {

        $self->{rw}->skip_line();

    }

    $elem->parent->ext->{lastchild} = 'block';

}

sub mixed_inline_start

{

    my ($self, $node) = @_;

    # If text is just whitespace, then breaking should not be done

    # at this point. Otherwise the following input

    #

    # <para>xxx<TP>...</TP>

    # </para><para>yyy</para>

    #

    # would lead to extra .PP requests:

    #

    # xxx

    # .PP

    # .PP

    # yyy

    #

    # the first .PP being caused by the newline 

    # at the end of the </TP> tag that is otherwise meaningless.

    #

    # So quit now if the text node is whitespace.

    # Note this means we also do not change the lastchild

    # status; this is correct behavior, because we still

    # want breaking to be done later if necessary.

    return if $node->{Data} !~ /[^ \t\r\n]/;

    if($node->parent->ext->{lastchild} eq 'block') {

        $self->{rw}->skip_line();

    }

    elsif($node->parent->ext->{lastchild} eq 'hanging') {

        # Skipping a line after a hanging paragraph

        # doesn't work, because we want to stop

        # the indent

        $self->{rw}->request('PP');

    }

    $node->parent->ext->{lastchild} = 'inline';

}

##################################################

#

# Changing fonts

#

##################################################

$templates->add_rule('b<', \&bold_start_handler);

$templates->add_rule('b>', \&bold_end_handler);

$templates->add_rule('i<', \&italic_start_handler);

$templates->add_rule('i>', \&italic_end_handler);

$templates->add_rule('b<', 'single-line-mode', \&bold_start_handler);

$templates->add_rule('b>', 'single-line-mode', \&bold_end_handler);

$templates->add_rule('i<', 'single-line-mode', \&italic_start_handler);

$templates->add_rule('i>', 'single-line-mode', \&italic_end_handler);

$templates->add_rule('b<', 'table-mode', \&bold_start_handler);

$templates->add_rule('b>', 'table-mode', \&bold_end_handler);

$templates->add_rule('i<', 'table-mode', \&italic_start_handler);

$templates->add_rule('i>', 'table-mode', \&italic_end_handler);

$templates->add_rule('b<', 'verbatim-mode', \&bold_start_handler);

$templates->add_rule('b>', 'verbatim-mode', \&bold_end_handler);

$templates->add_rule('i<', 'verbatim-mode', \&italic_start_handler);

$templates->add_rule('i>', 'verbatim-mode', \&italic_end_handler);

sub bold_start_handler {

    my ($self, $elem, $templates) = @_;

    mixed_inline_start($self, $elem);

    # If the last font is also bold, don't change anything.

    # Basically this is to just get more readable man output.

    $self->{rw}->escape('fB')

        unless $elem->in('b');

}

sub bold_end_handler {

    my ($self, $elem, $templates) = @_;

    if($elem->in('i')) { 

        $self->{rw}->escape('fI');

    }

    elsif($elem->in('b')) { }

    else {

        $self->{rw}->escape('fR');

    }

}

sub italic_start_handler {

    my ($self, $elem, $templates) = @_;

    mixed_inline_start($self, $elem);

    # If the last font is also bold, don't change anything.

    # Basically this is to just get more readable man output.

    $self->{rw}->escape('fI')

        unless $elem->in('i');

}

sub italic_end_handler {

    my ($self, $elem, $templates) = @_;

    if($elem->in('b')) { 

        $self->{rw}->escape('fB');

    }

    elsif($elem->in('i')) { }

    else {

        $self->{rw}->escape('fR');

    }

}

# Fixed-width fonts

# 

# We do not use the font "CW", because you then cannot apply bold 

# and italic to it.  Although groff comes with the fonts 

# "CI" and "CB" (in Postscript), they are not defined

# for TTY output! 

#

# Switching the font family (with \Fx) is a groff extension; to be 

# compatible with other man-page processors we use a custom escape

# instead of outputing \Fx directly.  See the handling of the manpage

# element for the definition of these escapes.

#

sub monospace_start_handler {

    my ($self, $elem, $templates) = @_;

    if(not $elem->within('tt')) {

        $self->{rw}->escape('*(T<');

    }

}

sub monospace_end_handler {

    my ($self, $elem, $templates) = @_;

    if(not $elem->within('tt')) {

        $self->{rw}->escape('*(T>');

    }

}

$templates->add_rule('tt<', \&monospace_start_handler);

$templates->add_rule('tt>', \&monospace_end_handler);

$templates->add_rule('tt<', 'single-line-mode', \&monospace_start_handler);

$templates->add_rule('tt>', 'single-line-mode', \&monospace_end_handler);

$templates->add_rule('tt<', 'table-mode', \&monospace_start_handler);

$templates->add_rule('tt>', 'table-mode', \&monospace_end_handler);

$templates->add_rule('tt<', 'verbatim-mode', \&monospace_start_handler);

$templates->add_rule('tt>', 'verbatim-mode', \&monospace_end_handler);

#

# Groff URL macros

# 

sub ulink_start_handler {

    my ($self, $elem, $templates) = @_;

    $templates->push_mode('section-mode');

    $self->{output_save} = '';

}

sub ulink_end_handler {

    my ($self, $elem, $templates) = @_;

    $templates->pop_mode();

    my $s = $self->{output_save};

    $self->{output_save} = undef;

    $self->{rw}->request('URL', 

        man_escape($elem->attr('url')), $s);

}

sub ulink_start_plain_handler {

    my ($self, $elem, $templates) = @_;

}

sub ulink_end_plain_handler {

    my ($self, $elem, $templates) = @_;

    $self->{rw}->print_ws(

        ' \(la' . man_escape($elem->attr('ulink')) . '\(ra ');

}

$templates->add_rule('ulink<', \&ulink_start_handler);

$templates->add_rule('ulink>', \&ulink_end_handler);

$templates->add_rule('ulink<', 'single-line-mode', \&ulink_start_plain_handler);

$templates->add_rule('ulink>', 'single-line-mode', \&ulink_end_plain_handler);

$templates->add_rule('ulink<', 'table-mode', \&ulink_start_handler);

$templates->add_rule('ulink>', 'table-mode', \&ulink_end_handler);

$templates->add_rule('ulink<', 'verbatim-mode', \&ulink_start_plain_handler);

$templates->add_rule('ulink>', 'verbatim-mode', \&ulink_end_plain_handler);

#

# Turn off/on hyphenation (used for long URI's and the like)

#

sub hyphenation_off {

    my ($self, $elem, $templates) = @_;

    return if $templates->mode() eq 'single-line-mode';

    $self->{rw}->request("'nh");

}

sub hyphenation_on {

    my ($self, $elem, $templates) = @_;

    return if $templates->mode() eq 'single-line-mode';

    $self->{rw}->request("'hy");

}

$templates->add_rule('nh<', \&hyphenation_off);

$templates->add_rule('nh>', \&hyphenation_on);

$templates->add_rule('nh<', 'table-mode', \&hyphenation_off);

$templates->add_rule('nh>', 'table-mode', \&hyphenation_on);

$templates->add_rule('nh<', 'single-line-mode', sub {});

$templates->add_rule('nh<', 'verbatim-mode', sub {});

# roff distinguishes between the ASCII hyphen-minus

# and a normal hyphen. 

# See <URL:http://www.cs.tut.fi/~jkorpela/dashes.html>

sub disambiguate_hyphen_minus 

{

    my ($text, $elem) = @_;

    if(!$elem or $elem->within('tt') or $elem->within('verbatim')) {

        $text =~ s/-/\\-/g;

    }

    return $text;

}

sub disable_hyphenation

{

    my ($text, $elem) = @_;

    return $text;       # Disable for now

    if($elem and $elem->within('tt') and not $elem->within('verbatim')) {

        $text =~ s/ / \\%/g;

    }

    return $text;

}