Merge lp:~mitya57/ubuntu/saucy/texinfo/5.1.dfsg.1-4ubuntu1 into lp:ubuntu/saucy/texinfo

[Dmitry Shachnev]

A trivial merge from Debian, which fixes a "Severity: serious" bug.

[Daniel Holbach (dholbach)]

Thanks. Uploaded.

review: Approve

[Dmitry Shachnev (mitya57)]

Thanks Daniel, marking as merged.

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-01-20 20:25:10 +0000
+++ .pc/applied-patches	2013-07-14 15:17:24 +0000
@@ -3,3 +3,4 @@
 numerical-signal-names
 info_universal_argument
 dont_build_info
+maybe-upstream-fix-itemize-start
 
=== added directory '.pc/maybe-upstream-fix-itemize-start'
=== added directory '.pc/maybe-upstream-fix-itemize-start/tp'
=== added directory '.pc/maybe-upstream-fix-itemize-start/tp/Texinfo'
=== added file '.pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Common.pm'
--- .pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Common.pm	1970-01-01 00:00:00 +0000
+++ .pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Common.pm	2013-07-14 15:17:24 +0000
@@ -0,0 +1,2530 @@
+# Common.pm: definition of commands. Common code of other Texinfo modules.
+#
+# Copyright 2010, 2011, 2012 Free Software Foundation, Inc.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License,
+# or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# 
+# Original author: Patrice Dumas <[e-mail]>
+# Parts (also from Patrice Dumas) come from texi2html.pl or texi2html.init.
+
+package Texinfo::Common;
+
+use strict;
+
+# for unicode/layer support in binmode
+use 5.006;
+
+# to determine the null file
+use Config;
+use File::Spec;
+
+use Texinfo::Documentlanguages;
+
+# debugging
+use Carp qw(cluck);
+
+require Exporter;
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+@ISA = qw(Exporter);
+
+# Items to export into callers namespace by default. Note: do not export
+# names by default without a very good reason. Use EXPORT_OK instead.
+# Do not simply export all your public functions/methods/constants.
+
+# This allows declaration       use Texinfo::Covert::Text ':all';
+# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
+# will save memory.
+%EXPORT_TAGS = ( 'all' => [ qw(
+expand_verbatiminclude
+definition_category
+expand_today
+numbered_heading
+trim_spaces_comment_from_content
+float_name_caption
+normalize_top_node_name
+protect_comma_in_tree
+protect_first_parenthesis
+protect_hashchar_at_line_beginning
+protect_colon_in_tree
+protect_node_after_label_in_tree
+valid_tree_transformation
+move_index_entries_after_items_in_tree
+) ] );
+
+@EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+
+@EXPORT = qw(
+);
+
+$VERSION = '5.0';
+
+# i18n
+sub N__($)
+{
+  return $_[0];
+}
+
+# determine the null devices
+my $default_null_device = File::Spec->devnull();
+our %null_device_file = (
+  $default_null_device => 1
+);
+# special case, djgpp recognizes both null devices
+if ($Config{osname} eq 'dos' and $Config{osvers} eq 'djgpp') {
+  $null_device_file{'/dev/null'} = 1;
+  $null_device_file{'NUL'} = 1;
+}
+
+# these are the default values for the parser state that may be 
+# initialized to values given by the user.
+# They are defined here, because they are used below and we 
+# don't want Texinfo::Common to use Texinfo::Parser.
+our %default_parser_state_configuration = (
+  # this is the initial context.  It is put at the bottom of the 
+  # 'context_stack'.  It is not clear if this is really useful to be
+  # able to customize that value.
+  'context' => '_root',
+  'expanded_formats' => [],
+  'gettext' => sub {return $_[0];},
+  'pgettext' => sub {return $_[1];},
+  'include_directories' => [ '.' ],
+  # these are the user-added indices.  May be an array reference on names
+  # or an hash reference in the same format than %index_names below
+  'indices' => [],
+  # the following are dynamically modified during the document parsing.
+  'aliases' => {},            # key is a command name value is the alias
+  'clickstyle' => 'arrow',
+  'documentlanguage' => undef,
+                              # Current documentlanguage set by 
+                              # @documentlanguage
+  'explained_commands' => {}, # the key is a command name, either acronym
+                              # or abbr, the value is a hash.  The key hash 
+                              # is a normalized first argument of the 
+                              # corresponding command, the value is the 
+                              # contents array of the previous command with
+                              # this first arg and a second arg.
+  'kbdinputstyle' => 'distinct',
+  'labels'          => {},    # keys are normalized label names, as described
+                              # in the `HTML Xref' node.  Value should be
+                              # a node/anchor or float in the tree.
+  'macros' => {},             # the key is the user-defined macro name.  The 
+                              # value is the reference on a macro element 
+                              # as obtained by parsing the @macro
+  'merged_indices' => {},     # the key is merged in the value
+  'novalidate' => 0,          # same as setting @novalidate.
+  'sections_level' => 0,      # modified by raise/lowersections
+  'values' => {'txicommandconditionals' => 1},
+                              # the key is the name, the value the @set name 
+                              # argument.  A Texinfo tree may also be used.
+);
+
+# command-line options
+#my @command_line_settable_at_commands = ('footnotestyle', 'novalidate',
+#  'documentlanguage', 'paragraphindent');
+
+
+# FIXME maybe this should better be set as texinfo passed to texi2any as
+# texi2dvi --command 
+
+# customization options
+our %document_settable_at_commands = (
+  'allowcodebreaks' => 'true',
+  'clickstyle' => '@arrow',
+  'codequotebacktick' => 'off',
+  'codequoteundirected' => 'off',
+  'contents' => 0,
+  'deftypefnnewline' => 'off',
+  'documentencoding' => 'us-ascii',
+  'documentlanguage' => 'en',
+  # is N ems in TeX, 0.4 in.
+  'exampleindent' => 5,
+  'firstparagraphindent' => 'none',
+  'frenchspacing' => 'off',
+  'headings' => 'on',
+  'kbdinputstyle' => 'distinct',
+  'paragraphindent' => 3,
+  'shortcontents' => 0,
+  'urefbreakstyle' => 'after',
+  'xrefautomaticsectiontitle' => 'off',
+);
+
+# those should be unique
+our %document_settable_unique_at_commands = (
+  # when passed through a configuration variable, documentdescription
+  # should be already formatted for HTML
+  'documentdescription' => undef,
+  'evenfootingmarks' => undef,
+  'evenheadingmarks' => undef,
+  'everyfootingmarks' => 'bottom', 
+  'everyheadingmarks' => 'bottom',
+  'fonttextsize' => 11, 
+  'footnotestyle' => 'end', 
+  'novalidate' => 0,
+  'oddfootingmarks' => undef,
+  'oddheadingmarks' => undef,
+  # FIXME not clear here.
+  'pagesizes' => undef,
+  'setchapternewpage' => 'on',
+  'setcontentsaftertitlepage' => 0,
+  'setfilename' => undef,
+  'setshortcontentsaftertitlepage' => 0,
+  'everyheading'      => undef,
+  'everyfooting'      => undef,
+  'evenheading'       => undef,
+  'evenfooting'       => undef,
+  'oddheading'        => undef,
+  'oddfooting'        => undef,
+);
+
+my @command_line_settables = ('FILLCOLUMN', 'SPLIT', 'SPLIT_SIZE',
+  'HEADERS',
+  'MACRO_EXPAND', 'NUMBER_SECTIONS',
+  'NUMBER_FOOTNOTES', 'NODE_FILES',
+  'NO_WARN', 'VERBOSE',
+  'TRANSLITERATE_FILE_NAMES', 'ERROR_LIMIT', 'ENABLE_ENCODING',
+  'FORCE', 'INTERNAL_LINKS', 'OUTFILE', 'SUBDIR', 'OUT',
+  'SILENT', 'CASE_INSENSITIVE_FILENAMES',
+);
+
+# documented in the Texinfo::Parser pod section
+# all are lower cased in texi2any.pl
+my @parser_options = map {uc($_)} (keys(%default_parser_state_configuration));
+
+my @obsolete_variables = ('TOP_HEADING_AT_BEGINNING', 'USE_SECTIONS',
+  'IDX_SUMMARY', 'I18N_PERL_HASH', 'USE_UNICODE', 'USE_NLS',
+  'USE_UP_FOR_ADJACENT_NODES', 'SEPARATE_DESCRIPTION', 
+  'NEW_CROSSREF_STYLE', 'SHORT_REF', 'IGNORE_PREAMBLE_TEXT',
+  'OUT_ENCODING', 
+  'IN_ENCODING', 'DEFAULT_ENCODING');
+
+my @variable_settables_not_used = ('COMPLETE_IMAGE_PATHS', 'TOC_FILE',
+  'SPLIT_INDEX');
+
+my @formats_settable = (
+);
+
+my @variable_string_settables = (
+  'DEBUG', 'FRAMES', 'FRAMESET_DOCTYPE', 'DOCTYPE', 'TEST', 'DUMP_TEXI',
+  'TOP_FILE', 'SHOW_MENU', 'USE_NODES', 'TOC_LINKS', 'SHORTEXTN',
+  'PREFIX', 'DEF_TABLE', 'L2H', 'MONOLITHIC',
+  'L2H_L2H', 'L2H_SKIP', 'L2H_TMP', 'L2H_FILE', 'L2H_CLEAN',
+  'L2H_HTML_VERSION', 'EXTERNAL_DIR', 'USE_ISO',
+  'VERTICAL_HEAD_NAVIGATION', 'INLINE_CONTENTS', 'NODE_FILE_EXTENSION',
+  'NO_CSS', 'INLINE_CSS_STYLE', 'USE_TITLEPAGE_FOR_TITLE',
+  'SIMPLE_MENU', 'EXTENSION', 'INLINE_INSERTCOPYING', 'USE_NUMERIC_ENTITY',
+  'ENABLE_ENCODING_USE_ENTITY', 'ICONS',
+  'USE_UNIDECODE', 'DATE_IN_HEADER', 'OPEN_QUOTE_SYMBOL',
+  'CLOSE_QUOTE_SYMBOL', 'TOP_NODE_UP', 'TOP_NODE_UP_URL', 'TOP_NODE_FILE',
+  'TOP_NODE_FILE_TARGET', 'SHOW_TITLE', 'WORDS_IN_PAGE',
+  'HEADER_IN_TABLE', 'USE_ACCESSKEY', 'USE_REL_REV', 'USE_LINKS',
+  'OVERVIEW_LINK_TO_TOC', 'AVOID_MENU_REDUNDANCY', 'NODE_NAME_IN_MENU',
+  'NODE_NAME_IN_INDEX', 'NO_USE_SETFILENAME', 'USE_SETFILENAME_EXTENSION',
+  'COMPLEX_FORMAT_IN_TABLE',
+  'IGNORE_BEFORE_SETFILENAME', 'IGNORE_SPACE_AFTER_BRACED_COMMAND_NAME',
+  'USE_NODE_TARGET',
+  'PROGRAM_NAME_IN_FOOTER', 'NODE_FILENAMES',
+  'EXTERNAL_CROSSREF_SPLIT', 'BODYTEXT',
+  'CSS_LINES', 'RENAMED_NODES_REDIRECTIONS', 'RENAMED_NODES_FILE',
+  'CPP_LINE_DIRECTIVES',
+  'TEXI2DVI', 'DUMP_TREE', 'MAX_MACRO_CALL_NESTING',
+  'INPUT_ENCODING_NAME', 'INPUT_PERL_ENCODING', 
+  'OUTPUT_ENCODING_NAME', 'OUTPUT_PERL_ENCODING', 
+  'PACKAGE_VERSION',
+  'PACKAGE_AND_VERSION', 'PACKAGE_URL', 'PACKAGE', 'PACKAGE_NAME', 'PROGRAM',
+  'PRE_BODY_CLOSE', 'AFTER_BODY_OPEN', 'PRE_ABOUT', 'AFTER_ABOUT',
+  'EXTRA_HEAD', 'DO_ABOUT',
+  'DEFAULT_RULE', 'BIG_RULE',
+  'MENU_ENTRY_COLON', 'INDEX_ENTRY_COLON', 'MENU_SYMBOL',
+  'MAX_HEADER_LEVEL', 'CHAPTER_HEADER_LEVEL',
+  'FOOTNOTE_END_HEADER_LEVEL', 'FOOTNOTE_SEPARATE_HEADER_LEVEL',
+  'USE_UP_NODE_FOR_ELEMENT_UP',
+  'BEFORE_OVERVIEW', 'AFTER_OVERVIEW',
+  'BEFORE_TOC_LINES', 'AFTER_TOC_LINES',
+  'SORT_ELEMENT_COUNT', 'SORT_ELEMENT_COUNT_WORDS',
+  'KEEP_TOP_EXTERNAL_REF',
+  'TEXI2HTML', 'IMAGE_LINK_PREFIX', 'FIX_TEXINFO',
+  'TREE_TRANSFORMATIONS', 'BASEFILENAME_LENGTH',
+  'TEXTCONTENT_COMMENT', 'XREF_USE_FLOAT_LABEL', 'XREF_USE_NODE_NAME_ARG',
+  'MACRO_BODY_IGNORES_LEADING_SPACE', 'CHECK_HTMLXREF',
+  'TEXINFO_DTD_VERSION', 'TEXINFO_COLUMN_FOR_DESCRIPTION',
+  'TEXINFO_OUTPUT_FORMAT',
+);
+# Not strings. 
+# FIXME To be documented somewhere, but where?
+my @variable_other_settables = (
+  'LINKS_BUTTONS', 'TOP_BUTTONS', 'SECTION_BUTTONS', 'BUTTONS_TEXT',
+  'BUTTONS_ACCESSKEY', 'BUTTONS_REL', 'BUTTONS_GOTO',
+  'CHAPTER_FOOTER_BUTTONS', 'SECTION_FOOTER_BUTTONS',
+  'NODE_FOOTER_BUTTONS',
+  'MISC_BUTTONS', 'CHAPTER_BUTTONS', 'BUTTONS_NAME',
+  'BUTTONS_EXAMPLE', 'SPECIAL_ELEMENTS_NAME', 'SPECIAL_ELEMENTS_CLASS',
+  'ACTIVE_ICONS', 'PASSIVE_ICONS',
+  'CSS_FILES', 'CSS_REFS', 
+  'GLOBAL_COMMANDS',
+);
+
+my %valid_options;
+foreach my $var (keys(%document_settable_at_commands), 
+         keys(%document_settable_unique_at_commands),
+         @command_line_settables, @variable_string_settables, 
+         @variable_other_settables, @parser_options,
+         @formats_settable,
+         @obsolete_variables, @variable_settables_not_used) {
+  $valid_options{$var} = 1;
+}
+
+my %obsolete_options;
+foreach my $var (@obsolete_variables) {
+  $obsolete_options{$var} = 1;
+}
+
+sub valid_option($)
+{
+  my $option = shift;
+  return $valid_options{$option};
+}
+
+sub obsolete_option($)
+{
+  my $option = shift;
+  return $obsolete_options{$option};
+}
+
+my %customization_variable_classes = (
+  'document_settable_at_commands' => [ sort(keys(%document_settable_at_commands)) ],
+  'document_settable_unique_at_commands' => [ sort(keys(%document_settable_unique_at_commands)) ],
+  'command_line_settables' => \@command_line_settables,
+  'variable_string_settables' => \@variable_string_settables,
+  'variable_other_settables' => \@variable_other_settables,
+  'parser_options' => \@parser_options,
+  #'formats_settable' => \@formats_settable,
+  'obsolete_variables' => \@obsolete_variables,
+  'variable_settables_not_used' => \@variable_settables_not_used,
+);
+
+my @secondary_customization_variables = (
+  'obsolete_variables', 'variable_settables_not_used'
+);
+sub _customization_variable_classes(;$)
+{
+  my $print_all = shift;
+  my $result = '';
+  foreach my $type (sort(keys(%customization_variable_classes))) {
+    next if (!$print_all 
+             and grep {$_ eq $type} @secondary_customization_variables);
+    foreach my $variable (@{$customization_variable_classes{$type}}) {
+      $result .= "$variable\t$type\n";
+    }
+  }
+  return $result;
+}
+
+my %valid_tree_transformations;
+foreach my $valid_transformation ('simple_menus', 
+    'fill_gaps_in_sectioning', 'move_index_entries_after_items',
+    'insert_nodes_for_sectioning_commands',
+    'complete_tree_nodes_menus', 'regenerate_master_menu',
+    'indent_menu_descriptions') {
+  $valid_tree_transformations{$valid_transformation} = 1;
+}
+
+sub valid_tree_transformation ($)
+{
+  my $transformation = shift;
+  return 1 if (defined($transformation) 
+               and $valid_tree_transformations{$transformation});
+  return 0;
+}
+
+our %no_brace_commands;             # commands never taking braces
+%no_brace_commands = (
+           '*', "\n",
+           ' ', ' ',
+           "\t", ' ',
+           "\n", ' ',
+           '-', '',  # hyphenation hint
+           '|', '',  # used in formatting commands @evenfooting and friends
+           '/', '',
+           ':', '',
+           '!', '!',
+           '?', '?',
+           '.', '.',
+           '@', '@',
+           '}', '}',
+           '{', '{',
+           '\\', '\\',  # should only appear in math
+);
+
+
+# commands taking a line as argument or no argument.
+# sectioning commands and def* commands are added below.
+# index commands are added dynamically.
+#
+# The values signification is:
+# special:     no value and macro expansion, all the line is used, and 
+#              analysed during parsing (_parse_special_misc_command)
+# lineraw:     no value and macro expansion, the line is kept as-is, not 
+#              analysed
+# skipline:    no argument, everything else on the line is skipped
+# skipspace:   no argument, following spaces are skipped.
+# noarg:       no argument
+# text:        the line is parsed as texinfo, and the argument is converted
+#              to simple text (in _end_line)
+# line:        the line is parsed as texinfo
+# a number:    the line is parsed as texinfo and the result should be plain 
+#              text maybe followed by a comment; the result is analysed
+#              during parsing (_parse_line_command_args).  
+#              The number is an indication of the number of arguments of 
+#              the command.
+#
+# Beware that @item and @itemx may be like 'line' or 'skipspace' depending
+# on the context.
+our %misc_commands = (
+  'node'              => 'line', # special arg
+  'bye'               => 'skipline', # no arg
+  'end'               => 'text',
+  # set, clear
+  'set'               => 'special', # special arg
+  'clear'             => 'special', # special arg
+  'unmacro'           => 'special', 
+  # comments
+  'comment'           => 'lineraw',
+  'c'                 => 'lineraw',
+  # special
+  'definfoenclose'    => 3,
+  'alias'             => 2, 
+  # number of arguments is not known in advance.
+  'columnfractions'   => 1, 
+  # file names
+  'setfilename'       => 'text',
+  'verbatiminclude'   => 'text',
+  'include'           => 'text',
+
+  'raisesections'     => 'skipline',  # no arg
+  'lowersections'     => 'skipline', # no arg
+  'contents'          => 'skipline', # no arg
+  'shortcontents'     => 'skipline', # no arg
+  'summarycontents'   => 'skipline', # no arg
+  'insertcopying'     => 'noarg', # no arg
+  'clickstyle'        => 'special', # arg should be an @-command
+  # more relevant in preamble
+  'setcontentsaftertitlepage'      => 'skipline', # no arg
+  'setshortcontentsaftertitlepage' => 'skipline', # no arg
+  'documentencoding'  => 'text', # or 1?
+  'novalidate'        => 'skipline', # no arg
+  'dircategory'       => 'line', # line. Position with regard 
+                                 # with direntry is significant
+  'pagesizes'         => 'line', # can have 2 args 
+                           # or one? 200mm,150mm 11.5in
+  'finalout'          => 'skipline', # no arg
+  'paragraphindent'   => 1, # arg none asis 
+                       # or a number and forbids anything else on the line
+  'firstparagraphindent' => 1, # none insert
+  'frenchspacing'     => 1, # on off
+  'codequoteundirected'       => 1, # on off
+  'codequotebacktick'         => 1, # on off
+  'xrefautomaticsectiontitle' => 1, # on off
+  'deftypefnnewline'  => 1, # on off
+  'fonttextsize'      => 1, # 10 11
+  'allowcodebreaks'   => 1, # false or true
+  'exampleindent'     => 1, # asis or a number
+  'footnotestyle'     => 1, # end and separate, nothing else on the line
+  'urefbreakstyle'    => 1, # after|before|none
+  'afourpaper'        => 'skipline', # no arg
+  'afivepaper'        => 'skipline', # no arg
+  'afourlatex'        => 'skipline', # no arg
+  'afourwide'         => 'skipline', # no arg
+  'headings'          => 1, #off on single double singleafter doubleafter
+                            # interacts with setchapternewpage
+  'setchapternewpage' => 1, # off on odd
+
+  # only relevant in TeX, and special
+  'everyheading'      => 'lineraw',  # @*heading @*footing use @|
+  'everyfooting'      => 'lineraw',  # + @thispage @thissectionname
+  'evenheading'       => 'lineraw',  # @thissectionnum @thissection
+  'evenfooting'       => 'lineraw',  # @thischaptername @thischapternum
+  'oddheading'        => 'lineraw',  # @thischapter @thistitle @thisfile
+  'oddfooting'        => 'lineraw',
+
+  'smallbook'         => 'skipline', # no arg
+  'syncodeindex'      => 2,   # args are index identifiers
+  'synindex'          => 2,
+  'defindex'          => 1, # one identifier arg
+  'defcodeindex'      => 1, # one identifier arg
+  'documentlanguage'  => 'text',     # language code arg
+  'kbdinputstyle'     => 1,          # code example distinct
+  'everyheadingmarks' => 1, # top bottom
+  'everyfootingmarks' => 1,
+  'evenheadingmarks'  => 1,
+  'oddheadingmarks'   => 1,
+  'evenfootingmarks'  => 1,
+  'oddfootingmarks'   => 1,
+  # not valid for info (should be in @iftex)
+  'cropmarks'         => 'skipline', # no arg
+
+  # formatting
+  'center'            => 'line',
+  'printindex'        => 1,
+  'listoffloats'      => 'line',
+  # especially in titlepage
+#  'shorttitle'        => 'line',
+  'shorttitlepage'    => 'line',
+  'settitle'          => 'line',
+  'author'            => 'line',
+  'subtitle'          => 'line',
+  'title'             => 'line',
+  'sp'                => 1, # numerical arg
+  'page'              => 'skipline', # no arg (pagebreak)
+  'need'              => 1, # one numerical/real arg
+  # formatting
+  'noindent'          => 'skipspace', # no arg
+  'indent'            => 'skipspace',
+  'exdent'            => 'line',
+  'headitem'          => 'skipspace',
+  'item'              => 'skipspace', # or line, depending on the context
+  'itemx'             => 'skipspace', # or line, depending on the context
+  'tab'               => 'skipspace', 
+  # only valid in heading or footing
+  'thischapter'       => 'noarg',
+  'thischaptername'   => 'noarg',
+  'thischapternum'    => 'noarg',
+  'thisfile'          => 'noarg',
+  'thispage'          => 'noarg',
+  'thistitle'         => 'noarg',
+  # not valid for info (should be in @iftex)
+  'vskip'             => 'lineraw', # arg line in TeX
+  # obsolete @-commands.
+  'refill'            => 'noarg',   # no arg (obsolete, to be ignored)
+  # Remove spaces and end of lines after the 
+  # commands? If no, they can lead to empty lines
+  'quote-arg'         => 'skipline',
+  'allow-recursion'   => 'skipline',
+);
+
+# key is index name, keys of the reference value are the prefixes.
+# value associated with the prefix is 0 if the prefix is not a code-like
+# prefix, 1 if it is a code-like prefix (set by defcodeindex/syncodeindex).
+#our %index_names = (
+# 'cp' => {'cp' => 0, 'c' => 0},
+# 'fn' => {'fn' => 1, 'f' => 1},
+# 'vr' => {'vr' => 1, 'v' => 1},
+# 'ky' => {'ky' => 1, 'k' => 1},
+# 'pg' => {'pg' => 1, 'p' => 1},
+# 'tp' => {'tp' => 1, 't' => 1}
+#);
+
+our %index_names = (
+ 'cp' => {'prefix' => ['c'], 'in_code' => 0},
+ 'fn' => {'prefix' => ['f'], 'in_code' => 1},
+ 'vr' => {'prefix' => ['v'], 'in_code' => 1},
+ 'ky' => {'prefix' => ['k'], 'in_code' => 1},
+ 'pg' => {'prefix' => ['p'], 'in_code' => 1},
+ 'tp' => {'prefix' => ['t'], 'in_code' => 1},
+);
+
+foreach my $index(keys(%index_names)) {
+  $index_names{$index}->{'name'} = $index;
+  push @{$index_names{$index}->{'prefix'}}, $index;
+}
+
+our %default_index_commands;
+# all the commands are readded dynamically in the Parser.
+foreach my $index_name (keys (%index_names)) {
+  foreach my $index_prefix (@{$index_names{$index_name}->{'prefix'}}) {
+    next if ($index_prefix eq $index_name);
+    # only put the one letter versions in the hash.
+    $misc_commands{$index_prefix.'index'} = 'line';
+    $default_index_commands{$index_prefix.'index'} = 1;
+  }
+}
+
+# command with braces. Value is the max number of arguments.
+our %brace_commands;    
+
+our %letter_no_arg_commands;
+foreach my $letter_no_arg_command ('aa','AA','ae','oe','AE','OE','o','O',
+                                   'ss','l','L','DH','dh','TH','th') {
+  $letter_no_arg_commands{$letter_no_arg_command} = 1;
+  $brace_commands{$letter_no_arg_command} = 0;
+}
+
+foreach my $no_arg_command ('TeX','LaTeX','bullet','copyright',
+  'registeredsymbol','dots','enddots','equiv','error','expansion','arrow',
+  'minus','point','print','result','today',
+  'exclamdown','questiondown','pounds','ordf','ordm',
+  'atchar', 'lbracechar', 'rbracechar', 'backslashchar', 'hashchar', 'comma',
+  'euro', 'geq','leq','tie','textdegree','click',
+  'quotedblleft','quotedblright','quoteleft','quoteright','quotedblbase',
+  'quotesinglbase','guillemetleft','guillemetright','guillemotleft',
+  'guillemotright','guilsinglleft','guilsinglright') {
+  $brace_commands{$no_arg_command} = 0;
+}
+
+# accent commands. They may be called with and without braces.
+our %accent_commands;
+foreach my $accent_command ('"','~','^','`',"'",',','=',
+                           'ringaccent','H','dotaccent','u','ubaraccent',
+                           'udotaccent','v','ogonek','tieaccent', 'dotless') {
+  $accent_commands{$accent_command} = 1;
+  $brace_commands{$accent_command} = 1;
+}
+
+our %style_commands;
+foreach my $style_command ('asis','cite','clicksequence',
+  'dfn', 'emph',
+  'sc', 't', 'var',
+  'headitemfont', 'code', 'command', 'env', 'file', 'kbd',
+  'option', 'samp', 'strong') {
+  $brace_commands{$style_command} = 1;
+  $style_commands{$style_command} = 1;
+}
+
+our %regular_font_style_commands;
+foreach my $command ('r', 'i', 'b', 'sansserif', 'slanted') {
+  $regular_font_style_commands{$command} = 1;
+  $brace_commands{$command} = 1;
+  $style_commands{$command} = 1;
+}
+
+foreach my $one_arg_command (
+  'ctrl','dmn', 'w', 'key',
+  'titlefont','hyphenation','anchor','errormsg') {
+  $brace_commands{$one_arg_command} = 1;
+}
+
+our %code_style_commands;
+foreach my $command ('code', 'command', 'env', 'file', 'kbd', 'key', 'option',
+   'samp', 'indicateurl', 'verb', 't') {
+  $code_style_commands{$command} = 1;
+  $brace_commands{$command} = 1;
+}
+
+
+# Commands that enclose full texts
+our %context_brace_commands;
+foreach my $context_brace_command ('footnote', 'caption', 'shortcaption', 'math') {
+  $context_brace_commands{$context_brace_command} = $context_brace_command;
+  $brace_commands{$context_brace_command} = 1;
+}
+
+our %explained_commands;
+foreach my $explained_command ('abbr', 'acronym') {
+  $explained_commands{$explained_command} = 1;
+  $brace_commands{$explained_command} = 2;
+}
+
+our %inline_format_commands;
+foreach my $inline_format_command ('inlineraw', 'inlinefmt') {
+  $inline_format_commands{$inline_format_command} = 1;
+  $brace_commands{$inline_format_command} = 2;
+}
+
+foreach my $two_arg_command('email') {
+  $brace_commands{$two_arg_command} = 2;
+}
+
+foreach my $three_arg_command('uref','url','inforef') {
+  $brace_commands{$three_arg_command} = 3;
+}
+
+foreach my $five_arg_command('xref','ref','pxref','image') {
+  $brace_commands{$five_arg_command} = 5;
+}
+
+
+# some classification to help converters
+our %ref_commands;
+foreach my $ref_command ('xref','ref','pxref','inforef') {
+  $ref_commands{$ref_command} = 1;
+}
+
+
+our %in_heading_commands;
+foreach my $in_heading_command ('thischapter', 'thischaptername',
+  'thischapternum', 'thisfile', 'thispage', 'thistitle') {
+  $in_heading_commands{$in_heading_command} = 1;
+}
+
+# commands delimiting blocks, with an @end.
+# Value is either the number of arguments on the line separated by
+# commas or the type of command, 'raw', 'def' or 'multitable'.
+our %block_commands;
+
+# commands that have a possible content before an item
+our %block_item_commands;
+
+sub gdt($)
+{
+  return $_[0];
+}
+
+our %def_map = (
+    # basic commands. 
+    # 'arg' and 'argtype' are for everything appearing after the other
+    # arguments.
+    'deffn',     [ 'category', 'name', 'arg' ],
+    'defvr',     [ 'category', 'name' ],
+    'deftypefn', [ 'category', 'type', 'name', 'argtype' ],
+    'deftypeop', [ 'category', 'class' , 'type', 'name', 'argtype' ],
+    'deftypevr', [ 'category', 'type', 'name' ],
+    'defcv',     [ 'category', 'class' , 'name' ],
+    'deftypecv', [ 'category', 'class' , 'type', 'name' ],
+    'defop',     [ 'category', 'class' , 'name', 'arg' ],
+    'deftp',     [ 'category', 'name', 'argtype' ],
+    # shortcuts
+    'defun',         {'deffn'     => gdt('Function')},
+    'defmac',        {'deffn'     => gdt('Macro')},
+    'defspec',       {'deffn'     => '{'.gdt('Special Form').'}'},
+    'defvar',        {'defvr'     => gdt('Variable')},
+    'defopt',        {'defvr'     => '{'.gdt('User Option').'}'},
+    'deftypefun',    {'deftypefn' => gdt('Function')},
+    'deftypevar',    {'deftypevr' => gdt('Variable')},
+    'defivar',       {'defcv'     => '{'.gdt('Instance Variable').'}'},
+    'deftypeivar',   {'deftypecv' => '{'.gdt('Instance Variable').'}'},
+    'defmethod',     {'defop'     => gdt('Method')},
+    'deftypemethod', {'deftypeop' => gdt('Method')},
+);
+
+# the type of index, f: function, v: variable, t: type
+my %index_type_def = (
+ 'f' => ['deffn', 'deftypefn', 'deftypeop', 'defop'],
+ 'v' => ['defvr', 'deftypevr', 'defcv', 'deftypecv' ],
+ 't' => ['deftp']
+);
+
+our %command_index_prefix;
+
+$command_index_prefix{'vtable'} = 'v';
+$command_index_prefix{'ftable'} = 'f';
+
+foreach my $index_type (keys %index_type_def) {
+  foreach my $def (@{$index_type_def{$index_type}}) {
+    $command_index_prefix{$def} = $index_type;
+  }
+}
+
+our %def_commands;
+our %def_aliases;
+foreach my $def_command(keys %def_map) {
+  if (ref($def_map{$def_command}) eq 'HASH') {
+    my ($real_command) = keys (%{$def_map{$def_command}});
+    $command_index_prefix{$def_command} = $command_index_prefix{$real_command};
+    $def_aliases{$def_command} = $real_command;
+  }
+  $block_commands{$def_command} = 'def';
+  $misc_commands{$def_command.'x'} = 'line';
+  $def_commands{$def_command} = 1;
+  $def_commands{$def_command.'x'} = 1;
+  $command_index_prefix{$def_command.'x'} = $command_index_prefix{$def_command};
+}
+
+#print STDERR "".Data::Dumper->Dump([\%def_aliases]);
+#print STDERR "".Data::Dumper->Dump([\%def_prepended_content]);
+
+$block_commands{'multitable'} = 'multitable';
+$block_item_commands{'multitable'} = 1;
+
+# block commands in which menu entry and menu comments appear
+our %menu_commands;
+foreach my $menu_command ('menu', 'detailmenu', 'direntry') {
+  $menu_commands{$menu_command} = 1;
+  $block_commands{$menu_command} = 0;
+};
+
+our %align_commands;
+foreach my $align_command('raggedright', 'flushleft', 'flushright') {
+  $block_commands{$align_command} = 0;
+  $align_commands{$align_command} = 1;
+}
+$align_commands{'center'} = 1;
+
+foreach my $block_command(
+    'cartouche', 'group', 'indentedblock', 'smallindentedblock') {
+  $block_commands{$block_command} = 0;
+}
+
+our %region_commands;
+foreach my $block_command('titlepage', 'copying', 'documentdescription') {
+  $block_commands{$block_command} = 0;
+  $region_commands{$block_command} = 1;
+}
+  
+our %preformatted_commands;
+our %preformatted_code_commands;
+foreach my $preformatted_command(
+    'example', 'smallexample', 'lisp', 'smalllisp') {
+  $block_commands{$preformatted_command} = 0;
+  $preformatted_commands{$preformatted_command} = 1;
+  $preformatted_code_commands{$preformatted_command} = 1;
+}
+
+foreach my $preformatted_command(
+    'display', 'smalldisplay', 'format', 'smallformat') {
+  $block_commands{$preformatted_command} = 0;
+  $preformatted_commands{$preformatted_command} = 1;
+}
+
+our %format_raw_commands;
+foreach my $format_raw_command('html', 'tex', 'xml', 'docbook') {
+  $block_commands{$format_raw_command} = 0;
+  $format_raw_commands{$format_raw_command} = 1;
+}
+
+our %raw_commands;
+# macro/rmacro are special
+foreach my $raw_command ('verbatim',
+                         'ignore', 'macro', 'rmacro') {
+  $block_commands{$raw_command} = 'raw';
+  $raw_commands{$raw_command} = 1;
+}
+
+our %texinfo_output_formats;
+foreach my $command (keys(%format_raw_commands), 'info', 'plaintext') {
+  $block_commands{'if' . $command} = 'conditional';
+  $block_commands{'ifnot' . $command} = 'conditional';
+  $texinfo_output_formats{$command} = $command;
+}
+
+$block_commands{'ifset'} = 'conditional';
+$block_commands{'ifclear'} = 'conditional';
+
+$block_commands{'ifcommanddefined'} = 'conditional';
+$block_commands{'ifcommandnotdefined'} = 'conditional';
+
+# 'macro' ?
+foreach my $block_command_one_arg('table', 'ftable', 'vtable',
+  'itemize', 'enumerate', 'quotation', 'smallquotation') {
+  $block_commands{$block_command_one_arg} = 1;
+  $block_item_commands{$block_command_one_arg} = 1 
+    unless ($block_command_one_arg =~ /quotation/);
+}
+
+$block_commands{'float'} = 2;
+
+# commands that forces closing an opened paragraph.
+our %close_paragraph_commands;
+
+foreach my $block_command (keys(%block_commands)) {
+  $close_paragraph_commands{$block_command} = 1
+     unless ($block_commands{$block_command} eq 'raw' or
+             $block_commands{$block_command} eq 'conditional'
+             or $format_raw_commands{$block_command});
+}
+
+$close_paragraph_commands{'verbatim'} = 1;
+
+foreach my $close_paragraph_command ('titlefont', 'insertcopying', 'sp',
+  'verbatiminclude', 'page', 'item', 'itemx', 'tab', 'headitem',
+  'printindex', 'listoffloats', 'center', 'dircategory', 'contents',
+  'shortcontents', 'summarycontents', 'caption', 'shortcaption',
+  'setfilename', 'exdent') {
+  $close_paragraph_commands{$close_paragraph_command} = 1;
+}
+
+foreach my $close_paragraph_command (keys(%def_commands)) {
+  $close_paragraph_commands{$close_paragraph_command} = 1;
+}
+
+our %item_container_commands;
+foreach my $item_container_command ('itemize', 'enumerate') {
+  $item_container_commands{$item_container_command} = 1;
+}
+our %item_line_commands;
+foreach my $item_line_command ('table', 'ftable', 'vtable') {
+  $item_line_commands{$item_line_command} = 1;
+}
+
+our %deprecated_commands = (
+  'ctrl' => '',
+  'allow-recursion' => N__('recursion is always allowed'),
+  'quote-arg' => N__('arguments are quoted by default'),
+);
+
+# commands that should only appear at the root level and contain up to
+# the next root command.  @node and sectioning commands.
+our %root_commands;
+
+our %command_structuring_level = (
+              'top', 0,
+              'chapter', 1,
+              'unnumbered', 1,
+              'chapheading', 1,
+              'appendix', 1,
+              'section', 2,
+              'unnumberedsec', 2,
+              'heading', 2,
+              'appendixsec', 2,
+              'subsection', 3,
+              'unnumberedsubsec', 3,
+              'subheading', 3,
+              'appendixsubsec', 3,
+              'subsubsection', 4,
+              'unnumberedsubsubsec', 4,
+              'subsubheading', 4,
+              'appendixsubsubsec', 4,
+         );
+
+our %level_to_structuring_command;
+
+{
+  my $sections = [ ];
+  my $appendices = [ ];
+  my $unnumbered = [ ];
+  my $headings = [ ];
+  foreach my $command (keys (%command_structuring_level)) {
+    if ($command =~ /^appendix/) {
+      $level_to_structuring_command{$command} = $appendices;
+    } elsif ($command =~ /^unnumbered/ or $command eq 'top') {
+      $level_to_structuring_command{$command} = $unnumbered;
+    } elsif ($command =~ /section$/ or $command eq 'chapter') {
+      $level_to_structuring_command{$command} = $sections;
+    } else {
+      $level_to_structuring_command{$command} = $headings;
+    }
+    $level_to_structuring_command{$command}->[$command_structuring_level{$command}] 
+      = $command;
+  }
+  $level_to_structuring_command{'appendixsection'} = $appendices;
+  $level_to_structuring_command{'majorheading'} = $headings;
+  $level_to_structuring_command{'centerchap'} = $unnumbered;
+}
+
+
+# out of the main hierarchy
+$command_structuring_level{'part'} = 0;
+# this are synonyms
+$command_structuring_level{'appendixsection'} = 2;
+# command_structuring_level{'majorheading'} is also 1 and not 0
+$command_structuring_level{'majorheading'} = 1;
+$command_structuring_level{'centerchap'} = 1;
+
+our %sectioning_commands;
+
+foreach my $sectioning_command (keys (%command_structuring_level)) {
+  $misc_commands{$sectioning_command} = 'line';
+  if ($sectioning_command =~ /heading/) {
+    $close_paragraph_commands{$sectioning_command} = 1;
+  } else {
+    $root_commands{$sectioning_command} = 1;
+  }
+  $sectioning_commands{$sectioning_command} = 1;
+}
+
+$root_commands{'node'} = 1;
+
+our %all_commands;
+foreach my $command (
+  keys(%Texinfo::Common::block_commands),
+  keys(%Texinfo::Common::brace_commands),
+  keys(%Texinfo::Common::misc_commands),
+  keys(%Texinfo::Common::no_brace_commands), 
+  qw(value),
+ ) {
+  $all_commands{$command} = 1;
+} 
+
+our @MONTH_NAMES =
+    (
+     'January', 'February', 'March', 'April', 'May',
+     'June', 'July', 'August', 'September', 'October',
+     'November', 'December'
+    );
+
+sub locate_include_file($$)
+{
+  my $self = shift;
+  my $text = shift;
+  my $file;
+
+  my $ignore_include_directories = 0;
+
+  my ($volume, $directories, $filename) = File::Spec->splitpath($text);
+  my @directories = File::Spec->splitdir($directories);
+
+  #print STDERR "$self $text @{$self->{'include_directories'}}\n";
+  # If the path is absolute or begins with . or .., do not search in
+  # include directories.
+  if (File::Spec->file_name_is_absolute($text)) {
+    $ignore_include_directories = 1;
+  } else {
+    foreach my $dir (@directories) {
+      if ($dir eq File::Spec->updir() or $dir eq File::Spec->curdir()) {
+        $ignore_include_directories = 1;
+        last;
+      } elsif ($dir ne '') {
+        last;
+      }
+    }
+  }
+
+  #if ($text =~ m,^(/|\./|\.\./),) {
+  if ($ignore_include_directories) {
+    $file = $text if (-e $text and -r $text);
+  } else {
+    my @dirs;
+    if ($self) {
+      @dirs = @{$self->{'include_directories'}};
+    } else {
+      # no object with directory list and not an absolute path, never succeed
+      return undef;
+    }
+    foreach my $include_dir (@{$self->{'include_directories'}}) {
+      my ($include_volume, $include_directories, $include_filename) 
+         = File::Spec->splitpath($include_dir, 1);
+      
+      my $possible_file = File::Spec->catpath($include_volume, 
+        File::Spec->catdir(File::Spec->splitdir($include_directories), 
+                           @directories), $filename);
+      #$file = "$include_dir/$text" if (-e "$include_dir/$text" and -r "$include_dir/$text");
+      $file = "$possible_file" if (-e "$possible_file" and -r "$possible_file");
+      last if (defined($file));
+    }
+  }
+  return $file;
+}
+
+sub open_out($$;$)
+{
+  my $self = shift;
+  my $file = shift;
+  my $encoding = shift;
+
+  if (!defined($encoding) and $self 
+      and defined($self->get_conf('OUTPUT_PERL_ENCODING'))) {
+    $encoding = $self->get_conf('OUTPUT_PERL_ENCODING');
+  }
+
+  if ($file eq '-') {
+    binmode(STDOUT, ":encoding($encoding)") if ($encoding);
+    if ($self) {
+      $self->{'unclosed_files'}->{$file} = \*STDOUT;
+    }
+    return \*STDOUT;
+  }
+  my $filehandle = do { local *FH };
+  if (!open ($filehandle, '>', $file)) {
+    return undef; 
+  }
+  if ($encoding) {
+    if ($encoding eq 'utf8' or $encoding eq 'utf-8-strict') {
+      binmode($filehandle, ':utf8');
+    } else { # FIXME also right for shiftijs or similar encodings?
+      binmode($filehandle, ':bytes');
+    }
+    binmode($filehandle, ":encoding($encoding)");
+  }
+  if ($self) {
+    push @{$self->{'opened_files'}}, $file;
+    $self->{'unclosed_files'}->{$file} = $filehandle;
+    #print STDERR "OOOOOOO $file ".join('|',@{$self->{'opened_files'}})."\n";
+    #cluck;
+  }
+  return $filehandle;
+}
+
+sub warn_unknown_language($$) {
+  my $lang = shift;
+  my $gettext = shift;
+
+  my @messages = ();
+  my $lang_code = $lang;
+  my $region_code;
+
+  if ($lang =~ /^([a-z]+)_([A-Z]+)/) {
+    $lang_code = $1;
+    $region_code = $2;
+  }
+
+  if (! $Texinfo::Documentlanguages::language_codes{$lang_code}) {
+    push @messages, sprintf(&$gettext(N__("%s is not a valid language code")), 
+                            $lang_code);
+  }
+  if (defined($region_code) 
+       and ! $Texinfo::Documentlanguages::region_codes{$region_code}) {
+    push @messages, sprintf(&$gettext(N__("%s is not a valid region code")), 
+                            $region_code);
+  }
+  return @messages;
+}
+
+my %possible_split = (
+  'chapter' => 1,
+  'section' => 1,
+  'node' => 1,
+);
+
+sub warn_unknown_split($$) {
+  my $split = shift;
+  my $gettext = shift;
+
+  my @messages = ();
+  if ($split and !$possible_split{$split}) {
+    push @messages, sprintf(&$gettext(N__("%s is not a valid split possibility")),
+                            $split);
+  }
+  return @messages;
+}
+
+# This should do the job, or at least don't do wrong if $self
+# is not defined, as could be the case if called from 
+# Texinfo::Convert::Text.
+sub expand_verbatiminclude($$)
+{
+  my $self = shift;
+  my $current = shift;
+
+  return unless ($current->{'extra'} and defined($current->{'extra'}->{'text_arg'}));
+  my $text = $current->{'extra'}->{'text_arg'};
+  my $file = locate_include_file($self, $text);
+
+  my $verbatiminclude;
+
+  if (defined($file)) {
+    if (!open(VERBINCLUDE, $file)) {
+      if ($self) {
+        $self->line_error(sprintf($self->__("could not read %s: %s"), $file, $!), 
+                            $current->{'line_nr'});
+      }
+    } else {
+      if ($self and defined($self->get_conf('INPUT_PERL_ENCODING'))) {
+        binmode(VERBINCLUDE, ":encoding(".
+                            $self->get_conf('INPUT_PERL_ENCODING').")");
+      }
+      $verbatiminclude = { 'cmdname' => 'verbatim',
+                           'parent' => $current->{'parent'},
+                           'extra' => 
+                        {'text_arg' => $current->{'extra'}->{'text_arg'}} };
+      while (<VERBINCLUDE>) {
+        push @{$verbatiminclude->{'contents'}}, 
+                  {'type' => 'raw', 'text' => $_ };
+      }
+      if (!close (VERBINCLUDE)) {
+        $self->document_warn(sprintf($self->__(
+                      "error on closing \@verbatiminclude file %s: %s"),
+                             $file, $!));
+      }
+    }
+  } elsif ($self) {
+    $self->line_error(sprintf($self->__("\@%s: could not find %s"), 
+                    $current->{'cmdname'}, $text), $current->{'line_nr'});
+  }
+  return $verbatiminclude;
+}
+
+sub definition_category($$)
+{
+  my $self = shift;
+  my $current = shift;
+
+  return undef if (!$current->{'extra'} or !$current->{'extra'}->{'def_args'});
+
+  my $arg_category = $current->{'extra'}->{'def_parsed_hash'}->{'category'};
+  my $arg_class = $current->{'extra'}->{'def_parsed_hash'}->{'class'};
+
+  return $arg_category
+    if (!defined($arg_class));
+  
+  my $style = 
+    $command_index_prefix{$current->{'extra'}->{'def_command'}};
+  if ($style eq 'f') {
+    if ($self) {
+      return $self->gdt('{category} on {class}', { 'category' => $arg_category,
+                                          'class' => $arg_class });
+    } else {
+      return {'contents' => [$arg_category, {'text' => ' on '}, $arg_class]};
+    }
+  } elsif ($style eq 'v') {
+    if ($self) {
+      return $self->gdt('{category} of {class}', { 'category' => $arg_category,
+                                          'class' => $arg_class });
+    } else {
+      return {'contents' => [$arg_category, {'text' => ' of '}, $arg_class]};
+    }
+  }
+}
+
+sub expand_today($)
+{
+  my $self = shift;
+  if ($self->get_conf('TEST')) {
+    return {'text' => 'a sunny day'};
+  }
+  my($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst)
+   = localtime(time);
+  $year += ($year < 70) ? 2000 : 1900;
+  return $self->gdt('{month} {day}, {year}',
+          { 'month' => $self->gdt($MONTH_NAMES[$mon]),
+            'day' => $mday, 'year' => $year });
+}
+
+sub translated_command_tree($$)
+{
+  my $self = shift;
+  my $cmdname = shift;
+  if ($self->{'translated_commands'}->{$cmdname}) {
+    return $self->gdt($self->{'translated_commands'}->{$cmdname});
+  }
+  return undef;
+}
+
+sub numbered_heading($$$;$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $text = shift;
+  my $numbered = shift;
+
+  my $number;
+  if (defined($current->{'number'}) and ($numbered or !defined($numbered))) {
+    $number = $current->{'number'};
+  }
+
+  my $result;
+  if ($self) {
+    if (defined($number)) {
+      if ($current->{'cmdname'} eq 'appendix' and $current->{'level'} == 1) {
+        $result = $self->gdt('Appendix {number} {section_title}',
+                   {'number' => $number, 'section_title' => $text}, 
+                   'translated_text');
+      } else {
+        $result = $self->gdt('{number} {section_title}',
+                   {'number' => $number, 'section_title' => $text},
+                   'translated_text');
+      }
+    } else {
+      $result = $text;
+    }
+  } else {
+    $result = $text;
+    $result = $number.' '.$result if (defined($number));
+    if ($current->{'cmdname'} eq 'appendix' and $current->{'level'} == 1) {
+      $result = 'Appendix '.$result;
+    }
+  }
+  chomp ($result);
+  return $result;
+}
+
+sub definition_arguments_content($)
+{
+  my $root = shift;
+  my $result;
+
+  return undef if (!defined($root->{'extra'}) 
+                    or !defined($root->{'extra'}->{'def_args'}));
+  my @args = @{$root->{'extra'}->{'def_args'}};
+  while (@args) {
+    last if ($args[0]->[0] ne 'spaces'
+             and !$root->{'extra'}->{'def_parsed_hash'}->{$args[0]->[0]});
+    shift @args;
+  }
+  if (@args) {
+    foreach my $arg (@args) {
+      push @$result, $arg->[1];
+    }
+  }
+  return $result;
+}
+
+# find the accent commands stack and the innermost text contents
+sub find_innermost_accent_contents($;$)
+{
+  my $current = shift;
+  my $encoding = shift;
+  my @accent_commands = ();
+  my $debug = 0;
+ ACCENT:
+  while (1) {
+    # the following can happen if called with a bad tree
+    if (!$current->{'cmdname'} 
+        or !$accent_commands{$current->{'cmdname'}}) {
+      #print STDERR "BUG: Not an accent command in accent\n";
+      cluck "BUG: Not an accent command in accent\n";
+      #print STDERR Texinfo::Convert::Texinfo::convert($current)."\n";
+      #print STDERR Data::Dumper->Dump([$current]);
+      last;
+    }
+    push @accent_commands, $current;
+    # A bogus accent, that may happen
+    if (!$current->{'args'}) {
+      return ([], \@accent_commands);
+    }
+    my $arg = $current->{'args'}->[0];
+    if (!$arg->{'contents'}) {
+      print STDERR "BUG: No content in accent command\n";
+      #print STDERR Data::Dumper->Dump([$current]);
+      #print STDERR Texinfo::Convert::Texinfo::convert($current)."\n";
+      return ([], \@accent_commands);
+    }
+    # inside the argument of an accent
+    my $text_contents = [];
+    foreach my $content (@{$arg->{'contents'}}) {
+      if (!($content->{'extra'} and $content->{'extra'}->{'invalid_nesting'})
+         and !($content->{'cmdname'} and ($content->{'cmdname'} eq 'c'
+                                  or $content->{'cmdname'} eq 'comment'))) {
+        if ($content->{'cmdname'} and $accent_commands{$content->{'cmdname'}}) {
+          $current = $content;
+          next ACCENT;
+        } else {
+          push @$text_contents, $content;
+        }
+      }
+    }
+    # we go here if there was no nested accent
+    return ($text_contents, \@accent_commands);
+  }
+}
+
+sub trim_spaces_comment_from_content($)
+{
+  my $contents = shift;
+  shift @$contents 
+    if ($contents->[0] and $contents->[0]->{'type'}
+       and ($contents->[0]->{'type'} eq 'empty_line_after_command'
+            or $contents->[0]->{'type'} eq 'empty_spaces_after_command'
+            or $contents->[0]->{'type'} eq 'empty_spaces_before_argument'
+            or $contents->[0]->{'type'} eq 'empty_space_at_end_def_bracketed'
+            or $contents->[0]->{'type'} eq 'empty_spaces_after_close_brace'));
+
+  while (@$contents 
+         and (($contents->[-1]->{'cmdname'}
+               and ($contents->[-1]->{'cmdname'} eq 'c' 
+                    or $contents->[-1]->{'cmdname'} eq 'comment'))
+              or ($contents->[-1]->{'type'}
+                  and ($contents->[-1]->{'type'} eq 'spaces_at_end'
+                       or $contents->[-1]->{'type'} eq 'space_at_end_block_command')))) {
+    pop @$contents;
+  }
+}
+
+sub float_name_caption($$)
+{
+  my $self = shift;
+  my $root = shift;
+
+  my $caption;
+  if ($root->{'extra'}->{'caption'}) {
+    $caption = $root->{'extra'}->{'caption'};
+  } elsif ($root->{'extra'}->{'shortcaption'}) {
+    $caption = $root->{'extra'}->{'shortcaption'};
+  }
+  #if ($self->get_conf('DEBUG')) {
+  #  my $caption_texi = 
+  #    Texinfo::Convert::Texinfo::convert({ 'contents' => $caption->{'contents'}});
+  #  print STDERR "  CAPTION: $caption_texi\n";
+  #}
+  my $type;
+  if ($root->{'extra'}->{'type'}->{'normalized'} ne '') {
+    $type = {'contents' => $root->{'extra'}->{'type'}->{'content'}};
+  }
+
+  my $prepended;
+  if ($type) {
+    if ($caption) {
+      if (defined($root->{'number'})) {
+        $prepended = $self->gdt('{float_type} {float_number}: ',
+            {'float_type' => $type,
+             'float_number' => $root->{'number'}});
+      } else {
+        $prepended = $self->gdt('{float_type}: ',
+          {'float_type' => $type});
+      }
+    } else {
+      if (defined($root->{'number'})) {
+        $prepended = $self->gdt("{float_type} {float_number}\n",
+            {'float_type' => $type,
+              'float_number' => $root->{'number'}});
+      } else {
+        $prepended = $self->gdt("{float_type}\n",
+            {'float_type' => $type});
+      }
+    }
+  } elsif (defined($root->{'number'})) {
+    if ($caption) {
+      $prepended = $self->gdt('{float_number}: ',
+          {'float_number' => $root->{'number'}});
+    } else {
+      $prepended = $self->gdt("{float_number}\n",
+           {'float_number' => $root->{'number'}});
+    }
+  }
+  return ($caption, $prepended);
+}
+
+# decompose a decimal number on a given base.
+sub _decompose_integer($$)
+{
+  my $number = shift;
+  my $base = shift;
+  my @result = ();
+
+  while ($number >= 0) {
+    my $factor = $number % $base;
+    push (@result, $factor);
+    $number = int(($number - $factor) / $base) - 1;
+  }
+  return @result;
+}
+
+sub enumerate_item_representation($$)
+{
+  my $specification = shift;
+  my $number = shift;
+
+  if ($specification =~ /^[0-9]$/) {
+    return $specification + $number -1;
+  }
+
+  my $result = '';
+  my $base_letter = ord('a');
+  $base_letter = ord('A') if (ucfirst($specification) eq $specification);
+  my @letter_ords = _decompose_integer(ord($specification) - $base_letter + $number - 1, 26);
+  foreach my $ord (@letter_ords) {
+    $result = chr($base_letter + $ord) . $result;
+  }
+  return $result;
+}
+
+
+our %htmlxref_entries = (
+ 'node' => [ 'node', 'section', 'chapter', 'mono' ],
+ 'section' => [ 'section', 'chapter','node', 'mono' ],
+ 'chapter' => [ 'chapter', 'section', 'node', 'mono' ],
+ 'mono' => [ 'mono', 'chapter', 'section', 'node' ],
+);
+
+sub parse_htmlxref_files($$)
+{
+  my $self = shift;
+  my $files = shift;
+  my $htmlxref;
+
+  foreach my $file (@$files) {
+    print STDERR "html refs config file: $file\n" if ($self->get_conf('DEBUG'));
+    unless (open (HTMLXREF, $file)) {
+      $self->document_warn(
+        sprintf($self->__("could not open html refs config file %s: %s"),
+          $file, $!));
+      next;
+    }
+    my $line_nr = 0;
+    my %variables;
+    while (my $hline = <HTMLXREF>) {
+      my $line = $hline;
+      $line_nr++;
+      next if $hline =~ /^\s*#/;
+      #$hline =~ s/[#]\s.*//;
+      $hline =~ s/^\s*//;
+      next if $hline =~ /^\s*$/;
+      chomp ($hline);
+      if ($hline =~ s/^\s*(\w+)\s*=\s*//) {
+        # handle variables
+        my $var = $1;
+        my $re = join '|', map { quotemeta $_ } keys %variables;
+        $hline =~ s/\$\{($re)\}/defined $variables{$1} ? $variables{$1} 
+                                                       : "\${$1}"/ge;
+        $variables{$var} = $hline;
+        next;
+      }
+      my @htmlxref = split /\s+/, $hline;
+      my $manual = shift @htmlxref;
+      my $split_or_mono = shift @htmlxref;
+      #print STDERR "$split_or_mono $Texi2HTML::Config::htmlxref_entries{$split_or_mono} $line_nr\n";
+      if (!defined($split_or_mono)) {
+        $self->file_line_warn($self->__("missing type"), $file, $line_nr);
+        next;
+      } elsif (!defined($htmlxref_entries{$split_or_mono})) {
+        $self->file_line_warn(sprintf($self->__("unrecognized type: %s"), 
+                               $split_or_mono), $file, $line_nr);
+        next;
+      }
+      my $href = shift @htmlxref;
+      next if (exists($htmlxref->{$manual}->{$split_or_mono}));
+
+      if (defined($href)) { # substitute 'variables'
+        my $re = join '|', map { quotemeta $_ } keys %variables;
+        $href =~ s/\$\{($re)\}/defined $variables{$1} ? $variables{$1} 
+                                                      : "\${$1}"/ge;
+        $href =~ s/\/*$// if ($split_or_mono ne 'mono');
+      }
+      $htmlxref->{$manual}->{$split_or_mono} = $href;
+    }
+    if (!close (HTMLXREF)) {
+      $self->document_warn(sprintf($self->__(
+                       "error on closing html refs config file %s: %s"),
+                             $file, $!));
+    }
+  }
+  return $htmlxref;
+}
+
+sub parse_renamed_nodes_file($$;$$)
+{
+  my $self = shift;
+  my $renamed_nodes_file = shift;
+  # if not given they are automatically created
+  my $renamed_nodes = shift;
+  my $renamed_nodes_lines = shift;
+
+  if (open(RENAMEDFILE, "<$renamed_nodes_file")) {
+    if ($self->get_conf('INPUT_PERL_ENCODING')) {
+      binmode(RENAMEDFILE, ":encoding(".
+                       $self->get_conf('INPUT_PERL_ENCODING').")");
+    }
+    my $renamed_nodes_line_nr = 0;
+    my @old_names = ();
+    while (<RENAMEDFILE>) {
+      $renamed_nodes_line_nr++;
+      next unless (/\S/);
+      next if (/^\s*\@c\b/);
+      if (s/^\s*\@\@\{\}\s+(\S)/$1/) {
+        chomp;
+        if (scalar(@old_names)) {
+          foreach my $old_node_name (@old_names) {
+            $renamed_nodes->{$old_node_name} = $_;
+          }
+          $renamed_nodes_lines->{$_} = $renamed_nodes_line_nr;
+          @old_names = ();
+        } else {
+          $self->file_line_warn($self->__("no node to be renamed"),
+                        $renamed_nodes_file, $renamed_nodes_line_nr);
+        }
+      } else {
+        chomp;
+        s/^\s*//;
+        $renamed_nodes_lines->{$_} = $renamed_nodes_line_nr;
+        push @old_names, $_;
+      }
+    }
+    if (scalar(@old_names)) {
+      $self->file_line_warn($self->__("nodes without a new name at the end of file"),
+             $renamed_nodes_file, $renamed_nodes_line_nr);
+    }
+    if (!close(RENAMEDFILE)) {
+      $self->document_warn(sprintf($self->__p(
+          "see HTML Xref Link Preservation in the Texinfo manual for context",
+          "error on closing node-renaming configuration file %s: %s"), 
+                            $renamed_nodes_file, $!));
+    }
+  } else {
+    $self->document_warn(sprintf($self->__("could not open %s: %s"), 
+                         $renamed_nodes_file, $!));
+  }
+  return ($renamed_nodes, $renamed_nodes_lines);
+}
+
+sub collect_renamed_nodes($$;$$)
+{
+  my $self = shift;
+  my $basename = shift;
+  my $renamed_nodes = shift;
+  my $renamed_nodes_lines = shift;
+
+  my $renamed_nodes_file;
+  if (defined($self->get_conf('RENAMED_NODES_FILE'))) {
+    $renamed_nodes_file = $self->get_conf('RENAMED_NODES_FILE');
+  } elsif (-f $basename . '-noderename.cnf') {
+    $renamed_nodes_file = $basename . '-noderename.cnf';
+  }
+  if (defined($renamed_nodes_file)) {
+    my ($renamed_nodes, $renamed_nodes_lines)
+     = parse_renamed_nodes_file($self, $renamed_nodes_file, $renamed_nodes,
+                                $renamed_nodes_lines);
+    return ($renamed_nodes, $renamed_nodes_lines, $renamed_nodes_file);
+  }
+  return (undef, undef, undef);
+}
+
+sub normalize_top_node_name($)
+{
+  my $node = shift;
+  if ($node =~ /^top$/i) {
+    return 'Top';
+  }
+  return $node;
+}
+
+sub _convert_text_options($)
+{
+  my $self = shift;
+  my %options;
+  if ($self->get_conf('ENABLE_ENCODING')) {
+    if ($self->get_conf('OUTPUT_ENCODING_NAME')) {
+      $options{'enabled_encoding'} = $self->get_conf('OUTPUT_ENCODING_NAME');
+    } elsif ($self->get_conf('INPUT_ENCODING_NAME')) {
+      $options{'enabled_encoding'} = $self->get_conf('INPUT_ENCODING_NAME');
+    }
+  }
+  $options{'TEST'} = 1 if ($self->get_conf('TEST'));
+  $options{'NUMBER_SECTIONS'} = $self->get_conf('NUMBER_SECTIONS');
+  $options{'converter'} = $self;
+  $options{'expanded_formats_hash'} = $self->{'expanded_formats_hash'};
+  return %options;
+}
+
+sub count_bytes($$;$) 
+{
+  my $self = shift;
+  my $string = shift;
+  my $encoding = shift;
+
+  if (!defined($encoding) and $self and $self->get_conf('OUTPUT_PERL_ENCODING')) {
+    $encoding = $self->get_conf('OUTPUT_PERL_ENCODING');
+  }
+
+  if ($encoding and $encoding ne 'ascii') {
+    return length(Encode::encode($encoding, $string));
+  } else {
+    return length($string);
+  }
+  # FIXME is the following required for correct count of end of lines?
+  #if ($encoding) {
+  #  return length(Encode::encode($encoding, $string));
+  #} else {
+  #  return length(Encode::encode('ascii', $string));
+  #}
+}
+
+# TODO
+# also recurse into
+# extra->misc_args, extra->args_index
+# extra->index_entry extra->type
+#
+# extra that should point to other elements: 
+# command_as_argument
+# @block_command_line_contents @brace_command_contents @misc_content end_command
+# associated_section part_associated_section associated_node associated_part
+# @prototypes @columnfractions titlepage quotation @author command
+# menu_entry_description menu_entry_name
+# 
+# should point to other elements, or be copied.  And some should be recursed
+# into too.
+# extra->type->content
+# extra->nodes_manuals->[]
+# extra->node_content
+# extra->node_argument
+# extra->explanation_contents
+# extra->menu_entry_node
+# extra->def_arg
+
+
+sub _copy_tree($$$);
+sub _copy_tree($$$)
+{
+  my $current = shift;
+  my $parent = shift;
+  my $reference_associations = shift;
+  my $new = {};
+  $reference_associations->{$current} = $new;
+  $new->{'parent'} = $parent if ($parent);
+  foreach my $key ('type', 'cmdname', 'text') {
+    $new->{$key} = $current->{$key} if (exists($current->{$key}));
+  }
+  foreach my $key ('args', 'contents') {
+    if ($current->{$key}) {
+      if (ref($current->{$key}) ne 'ARRAY') {
+        my $command_or_type = '';
+        if ($new->{'cmdname'}) {
+          $command_or_type = '@'.$new->{'cmdname'};
+        } elsif ($new->{'type'}) {
+          $command_or_type = $new->{'type'};
+        }
+        print STDERR "Not an array [$command_or_type] $key ".ref($current->{$key})."\n";
+      }
+      $new->{$key} = [];
+      $reference_associations->{$current->{$key}} = $new->{$key};
+      foreach my $child (@{$current->{$key}}) {
+        push @{$new->{$key}}, _copy_tree($child, $new, $reference_associations);
+      }
+    }
+  }
+  if ($current->{'extra'}) {
+    $new->{'extra'} = {};
+    foreach my $key (keys %{$current->{'extra'}}) {
+      if ($current->{'cmdname'} and $current->{'cmdname'} eq 'multitable'
+          and $key eq 'prototypes') {
+        $new->{'extra'}->{$key} = [];
+        $reference_associations->{$current->{'extra'}->{$key}} = $new->{$key};
+        foreach my $child (@{$current->{'extra'}->{$key}}) {
+          push @{$new->{'extra'}->{$key}}, 
+                  _copy_tree($child, $new, $reference_associations);
+        }
+      } elsif (!ref($current->{'extra'}->{$key})) {
+        $new->{'extra'}->{$key} = $current->{'extra'}->{$key};
+      }
+    }
+  }
+  return $new;
+}
+
+# Not used.
+sub _collect_references($$);
+sub _collect_references($$)
+{
+  my $current = shift;
+  my $references = shift;
+  foreach my $key ('args', 'contents') {
+    if ($current->{$key}) {
+      $references->{$current->{$key}} = $current->{$key};
+      foreach my $child (@{$current->{$key}}) {
+        $references->{$child} = $child;
+        _collect_references($child, $references);
+      }
+    }
+  }
+}
+
+sub _substitute_references_in_array($$$);
+sub _substitute_references_in_array($$$)
+{
+  my $array = shift;
+  my $reference_associations = shift;
+  my $context = shift;
+
+  my $result = [];
+  my $index = 0;
+  foreach my $item (@{$array}) {
+    if (!ref($item)) {
+      push @{$result}, $item;
+    } elsif ($reference_associations->{$item}) {
+      push @{$result}, $reference_associations->{$item};
+    } elsif (ref($item) eq 'ARRAY') {
+      push @$result, 
+        _substitute_references_in_array($item, $reference_associations,
+                                        "$context [$index]");
+    } elsif (defined($item->{'text'})) {
+      my $new_text = _copy_tree($item, undef, $reference_associations);
+      substitute_references($item, $new_text, $reference_associations);
+      push @{$result}, $new_text;
+    } else {
+      print STDERR "Trouble with $context [$index] (".ref($item).")\n";
+      push @{$result}, undef;
+    }
+    $index++;
+  }
+  return $result;
+}
+
+sub substitute_references($$$);
+sub substitute_references($$$)
+{
+  my $current = shift;
+  my $new = shift;
+  my $reference_associations = shift;
+  
+  foreach my $key ('args', 'contents') {
+    if ($new->{$key}) {
+      my $index = 0;
+      foreach my $child (@{$new->{$key}}) {
+        substitute_references($child, $current->{$key}->[$index],
+                              $reference_associations);
+        $index++;
+      }
+    }
+  }
+  if ($current->{'extra'}) {
+    foreach my $key (keys %{$current->{'extra'}}) {
+      if (ref($current->{'extra'}->{$key})) {
+        my $command_or_type = '';
+        if ($new->{'cmdname'}) {
+          $command_or_type = '@'.$new->{'cmdname'};
+        } elsif ($new->{'type'}) {
+          $command_or_type = $new->{'type'};
+        }
+        
+        if ($current->{'cmdname'} and $current->{'cmdname'} eq 'multitable'
+            and $key eq 'prototypes') {
+          my $index = 0;
+          foreach my $child (@{$new->{'extra'}->{$key}}) {
+            substitute_references($child, $current->{'extra'}->{$key}->[$index],
+                                  $reference_associations);
+            $index++;
+          }
+        } elsif ($reference_associations->{$current->{'extra'}->{$key}}) {
+          $new->{'extra'}->{$key} 
+            = $reference_associations->{$current->{'extra'}->{$key}};
+          #print STDERR "Done [$command_or_type]: $key\n";
+        } else {
+          if (ref($current->{'extra'}->{$key}) eq 'ARRAY') {
+            
+            #print STDERR "Array $command_or_type -> $key\n";
+            $new->{'extra'}->{$key} = _substitute_references_in_array(
+              $current->{'extra'}->{$key}, $reference_associations,
+              "[$command_or_type]{$key}");
+          } else {
+            if (($current->{'cmdname'} 
+                 and ($current->{'cmdname'} eq 'listoffloats'
+                     or $current->{'cmdname'} eq 'float') 
+                 and $key eq 'type')
+                 or ($key eq 'index_entry')
+                 or ($current->{'type'} 
+                     and $current->{'type'} eq 'menu_entry'
+                     and $key eq 'menu_entry_node')) {
+              foreach my $type_key (keys(%{$current->{'extra'}->{$key}})) {
+                if (!ref($current->{'extra'}->{$key}->{$type_key})) {
+                  $new->{'extra'}->{$key}->{$type_key} 
+                    = $current->{'extra'}->{$key}->{$type_key};
+                } elsif ($reference_associations->{$current->{'extra'}->{$key}->{$type_key}}) {
+                  $new->{'extra'}->{$key}->{$type_key}
+                    = $reference_associations->{$current->{'extra'}->{$key}->{$type_key}};
+                } elsif (ref($current->{'extra'}->{$key}->{$type_key}) eq 'ARRAY') {
+                  $new->{'extra'}->{$key}->{$type_key}
+                    = _substitute_references_in_array(
+                      $current->{'extra'}->{$key}->{$type_key}, 
+                      $reference_associations,
+                      "[$command_or_type]{$key}{$type_key}");
+                } else {
+                  print STDERR "Not substituting [$command_or_type]{$key}: $type_key\n";
+                }
+              }
+            } else {
+              print STDERR "Not substituting [$command_or_type]: $key ($current->{'extra'}->{$key})\n";
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+sub copy_tree($;$)
+{
+  my $current = shift;
+  my $parent = shift;
+  my $reference_associations = {};
+  my $copy = _copy_tree($current, $parent, $reference_associations);
+  substitute_references($current, $copy, $reference_associations);
+  return $copy;
+}
+
+sub modify_tree($$$;$);
+sub modify_tree($$$;$)
+{
+  my $self = shift;
+  my $tree = shift;
+  my $operation = shift;
+  my $argument = shift;
+  #print STDERR "modify_tree tree: $tree\n";
+
+  if ($tree->{'args'}) {
+    my @args = @{$tree->{'args'}};
+    for (my $i = 0; $i <= $#args; $i++) {
+      my @new_args = &$operation($self, 'arg', $args[$i], $argument);
+      modify_tree($self, $args[$i], $operation, $argument);
+      # this puts the new args at the place of the old arg using the 
+      # offset from the end of the array
+      splice (@{$tree->{'args'}}, $i - $#args -1, 1, @new_args);
+      #foreach my $arg (@new_args) {
+      #  modify_tree($self, $arg, $operation);
+      #}
+    }
+  }
+  if ($tree->{'contents'}) {
+    my @contents = @{$tree->{'contents'}};
+    for (my $i = 0; $i <= $#contents; $i++) {
+      my @new_contents = &$operation($self, 'content', $contents[$i], $argument);
+      modify_tree($self, $contents[$i], $operation, $argument);
+      # this puts the new contents at the place of the old content using the 
+      # offset from the end of the array
+      splice (@{$tree->{'contents'}}, $i - $#contents -1, 1, @new_contents);
+      #foreach my $content (@new_contents) {
+      #  modify_tree($self, $content, $operation);
+      #}
+    }
+  }
+  return $tree;
+}
+
+sub _protect_comma($$$)
+{
+  my $self = shift;
+  my $type = shift;
+  my $current = shift;
+
+  return _protect_text($current, quotemeta(','));
+}
+
+sub protect_comma_in_tree($)
+{
+  my $tree = shift;
+  return modify_tree(undef, $tree, \&_protect_comma);
+}
+
+sub _new_asis_command_with_text($$;$)
+{
+  my $text = shift;
+  my $parent = shift;
+  my $text_type = shift;
+  my $new_command = {'cmdname' => 'asis', 'parent' => $parent };
+  push @{$new_command->{'args'}}, {'type' => 'brace_command_arg',
+                                   'parent' => $new_command};
+  push @{$new_command->{'args'}->[0]->{'contents'}}, {
+    'text' => $text,
+    'parent' => $new_command->{'args'}->[0]};
+  if (defined($text_type)) {
+    $new_command->{'args'}->[0]->{'contents'}->[0]->{'type'} = $text_type;
+  }
+  return $new_command;
+}
+
+sub _protect_text($$)
+{
+  my $current = shift;
+  my $to_protect = shift;
+
+  #print STDERR "$to_protect: $current "._print_current($current)."\n";
+  if (defined($current->{'text'}) and $current->{'text'} =~ /$to_protect/
+      and !(defined($current->{'type'}) and $current->{'type'} eq 'raw')) {
+    my @result = ();
+    my $remaining_text = $current->{'text'};
+    while ($remaining_text) {
+      if ($remaining_text =~ s/^(.*?)(($to_protect)+)//) {
+        if ($1 ne '') {
+          push @result, {'text' => $1, 'parent' => $current->{'parent'}};
+          $result[-1]->{'type'} = $current->{'type'} 
+            if defined($current->{'type'});
+        }
+        if ($to_protect eq quotemeta(',')) {
+          for (my $i = 0; $i < length($2); $i++) {
+            push @result, {'cmdname' => 'comma', 'parent' => $current->{'parent'},
+                           'args' => [{'type' => 'brace_command_arg'}]};
+          }
+        } else {
+          push @result, _new_asis_command_with_text($2, $current->{'parent'},
+                                                    $current->{'type'});
+        }
+      } else {
+        push @result, {'text' => $remaining_text, 'parent' => $current->{'parent'}};
+        $result[-1]->{'type'} = $current->{'type'} 
+          if defined($current->{'type'});
+        last;
+      }
+    }
+    #print STDERR "Result: @result\n";
+    return @result;
+  } else {
+    #print STDERR "No change: $current\n";
+    return ($current);
+  }
+}
+
+sub _protect_colon($$$)
+{
+  my $self = shift;
+  my $type = shift;
+  my $current = shift;
+
+  return _protect_text ($current, quotemeta(':'));
+}
+
+sub protect_colon_in_tree($)
+{
+  my $tree = shift;
+  return modify_tree(undef, $tree, \&_protect_colon);
+}
+
+sub _protect_node_after_label($$$)
+{
+  my $self = shift;
+  my $type = shift;
+  my $current = shift;
+
+  return _protect_text ($current, '['. quotemeta(".\t,") .']');
+}
+
+sub protect_node_after_label_in_tree($)
+{
+  my $tree = shift;
+  return modify_tree(undef, $tree, \&_protect_node_after_label);
+}
+
+sub _is_cpp_line($)
+{
+  my $text = shift;
+  return 1 if ($text =~ /^\s*#\s*(line)? (\d+)(( "([^"]+)")(\s+\d+)*)?\s*$/);
+  return 0;
+}
+
+sub _protect_hashchar_at_line_beginning($$$)
+{
+  my $self = shift;
+  my $type = shift;
+  my $current = shift;
+
+  #print STDERR "$type $current "._print_current($current)."\n";
+  # if the next is a hash character at line beginning, mark it
+  if (defined($current->{'text'}) and $current->{'text'} =~ /\n$/
+      and $current->{'parent'} and $current->{'parent'}->{'contents'}) {
+    my $parent = $current->{'parent'};
+    #print STDERR "End of line in $current, parent $parent: (@{$parent->{'contents'}})\n";
+    my $current_found = 0;
+    foreach my $content (@{$parent->{'contents'}}) {
+      if ($current_found) {
+        #print STDERR "after $current: $content $content->{'text'}\n";
+        if ($content->{'text'} and _is_cpp_line($content->{'text'})) {
+          $content->{'extra'}->{'_protect_hashchar'} = 1;
+        }
+        last;
+      } elsif ($content eq $current) {
+        $current_found = 1;
+      }
+    }
+  }
+
+  my $protect_hash = 0;
+  # if marked, or first and a cpp_line protect a leading hash character
+  if ($current->{'extra'} and $current->{'extra'}->{'_protect_hashchar'}) {
+    delete $current->{'extra'}->{'_protect_hashchar'};
+    if (!scalar(keys(%{$current->{'extra'}}))) {
+      delete $current->{'extra'};
+    }
+    $protect_hash = 1;
+  } elsif ($current->{'parent'} and $current->{'parent'}->{'contents'}
+           and $current->{'parent'}->{'contents'}->[0]
+           and $current->{'parent'}->{'contents'}->[0] eq $current
+           and $current->{'text'}
+           and _is_cpp_line($current->{'text'})) {
+    $protect_hash = 1;
+  }
+  if ($protect_hash) {
+    my @result = ();
+    if ($current->{'type'} and $current->{'type'} eq 'raw') {
+      if ($self) {
+        my $parent = $current->{'parent'};
+        while ($parent) {
+          if ($parent->{'cmdname'} and $parent->{'line_nr'}) {
+            $self->line_warn(sprintf($self->__(
+                  "could not protect hash character in \@%s"), 
+                             $parent->{'cmdname'}), $parent->{'line_nr'});
+            last;
+          }
+          $parent = $parent->{'parent'};
+        }
+      }
+    } else {
+      $current->{'text'} =~ s/^(\s*)#//;
+      if ($1 ne '') {
+        push @result, {'text' => $1, 'parent' => $current->{'parent'}};
+      }
+      push @result, {'cmdname' => 'hashchar', 'parent' => $current->{'parent'},
+                     'args' => [{'type' => 'brace_command_arg'}]};
+    }
+    push @result, $current;
+    return @result;
+  } else {
+    return ($current);
+  }
+}
+
+sub protect_hashchar_at_line_beginning($$)
+{
+  my $self = shift;
+  my $tree = shift;
+  return modify_tree($self, $tree, \&_protect_hashchar_at_line_beginning);
+}
+
+sub protect_first_parenthesis($)
+{
+  my $contents = shift;
+  return undef if (!defined ($contents));
+  my @contents = @$contents;
+  my $brace;
+  if ($contents[0] and $contents->[0]{'text'} and $contents[0]->{'text'} =~ /^\(/) {
+    if ($contents[0]->{'text'} !~ /^\($/) {
+      $brace = shift @contents;
+      my $brace_text = $brace->{'text'};
+      $brace_text =~ s/^\(//;
+      unshift @contents, { 'text' => $brace_text, 'type' => $brace->{'type'},
+                           'parent' => $brace->{'parent'} } if $brace_text ne '';
+    } else {
+      $brace = shift @contents;
+    }
+    unshift @contents, _new_asis_command_with_text('(', $brace->{'parent'},
+                                                    $brace->{'type'});
+  }
+  return \@contents;
+}
+
+sub find_parent_root_command($$)
+{
+  my $parser = shift;
+  my $current = shift;
+
+  my $root_command;
+  while (1) {
+    if ($current->{'cmdname'}) {
+      if ($root_commands{$current->{'cmdname'}}) {
+        return $current;
+      } elsif ($region_commands{$current->{'cmdname'}}) {
+        if ($current->{'cmdname'} eq 'copying' and $parser
+            and $parser->{'extra'} and $parser->{'extra'}->{'insertcopying'}) {
+          foreach my $insertcopying(@{$parser->{'extra'}->{'insertcopying'}}) {
+            my $root_command
+              = $parser->find_parent_root_command($insertcopying);
+            return $root_command if (defined($root_command));
+          }
+        } else {
+          return undef;
+        }
+      }
+    }
+    if ($current->{'parent'}) {
+      $current = $current->{'parent'};
+    } else {
+      return undef;
+    }
+  }
+  # Should never get there
+  return undef;
+}
+
+# for debugging
+sub _print_current($)
+{
+  my $current = shift;
+  if (ref($current) ne 'HASH') {
+    return  "_print_current: $current not a hash\n";
+  }
+  my $type = '';
+  my $cmd = '';
+  my $parent_string = '';
+  my $text = '';
+  $type = "($current->{'type'})" if (defined($current->{'type'}));
+  $cmd = "\@$current->{'cmdname'}" if (defined($current->{'cmdname'}));
+  $cmd .= "($current->{'level'})" if (defined($current->{'level'}));
+  $text = "[text: $current->{'text'}]" if (defined($current->{'text'}));
+  if ($current->{'parent'}) {
+    my $parent = $current->{'parent'};
+    my $parent_cmd = '';
+    my $parent_type = '';
+    $parent_cmd = "\@$parent->{'cmdname'}" if (defined($parent->{'cmdname'}));
+    $parent_type = "($parent->{'type'})" if (defined($parent->{'type'}));
+    $parent_string = " <- $parent_cmd$parent_type\n";
+  }
+  my $args = '';
+  my $contents = '';
+  $args = "args(".scalar(@{$current->{'args'}}).')' if $current->{'args'};
+  $contents = "contents(".scalar(@{$current->{'contents'}}).')'
+    if $current->{'contents'};
+  if ("$cmd$type" ne '') {
+    return "$cmd$type : $text $args $contents\n$parent_string";
+  } else {
+    return "$text $args $contents\n$parent_string";
+  }
+}
+
+sub move_index_entries_after_items($) {
+  # enumerate or itemize
+  my $current = shift;
+
+  return unless ($current->{'contents'});
+
+  my $previous;
+  foreach my $item (@{$current->{'contents'}}) {
+    #print STDERR "Before proceeding: $previous $item->{'cmdname'} (@{$previous->{'contents'}})\n" if ($previous and $previous->{'contents'});
+    if (defined($previous) and $item->{'cmdname'} 
+        and $item->{'cmdname'} eq 'item' 
+        and $previous->{'contents'} and scalar(@{$previous->{'contents'}})) {
+
+      my $previous_ending_container;
+      if ($previous->{'contents'}->[-1]->{'type'}
+          and ($previous->{'contents'}->[-1]->{'type'} eq 'paragraph'
+               or $previous->{'contents'}->[-1]->{'type'} eq 'preformatted')) {
+        $previous_ending_container = $previous->{'contents'}->[-1];
+      } else {
+        $previous_ending_container = $previous;
+      }
+
+      my @gathered_index_entries;
+
+      #print STDERR "Gathering for item $item in previous $previous ($previous_ending_container)\n";
+      while ($previous_ending_container->{'contents'}->[-1]
+             and (($previous_ending_container->{'contents'}->[-1]->{'type'}
+                   and $previous_ending_container->{'contents'}->[-1]->{'type'} eq 'index_entry_command')
+                  or ($previous_ending_container->{'contents'}->[-1]->{'cmdname'}
+                      and ($previous_ending_container->{'contents'}->[-1]->{'cmdname'} eq 'c'
+                           or $previous_ending_container->{'contents'}->[-1]->{'cmdname'} eq 'comment')))) {
+        unshift @gathered_index_entries, pop @{$previous_ending_container->{'contents'}};
+      }
+      #print STDERR "Gathered: @gathered_index_entries\n";
+      if (scalar(@gathered_index_entries)) {
+        # put back leading comments
+        while ($gathered_index_entries[0]
+               and (!$gathered_index_entries[0]->{'type'}
+                    or $gathered_index_entries[0]->{'type'} ne 'index_entry_command')) {
+          #print STDERR "Putting back $gathered_index_entries[0] $gathered_index_entries[0]->{'cmdname'}\n";
+          push @{$previous_ending_container->{'contents'}}, 
+             shift @gathered_index_entries;
+        }
+
+        # We have the index entries of the previous @item or before item.
+        # Now put them right after the current @item command.
+        if (scalar(@gathered_index_entries)) {
+          my $item_container;
+          if ($item->{'contents'} and $item->{'contents'}->[0]
+              and $item->{'contents'}->[0]->{'type'}
+              and $item->{'contents'}->[0]->{'type'} eq 'preformatted') {
+            $item_container = $item->{'contents'}->[0];
+          } else {
+            $item_container = $item;
+          }
+          foreach my $entry(@gathered_index_entries) {
+            $entry->{'parent'} = $item_container;
+          }
+          if ($item_container->{'contents'} 
+              and $item_container->{'contents'}->[0]
+              and $item_container->{'contents'}->[0]->{'type'}) {
+            if ($item_container->{'contents'}->[0]->{'type'} eq 'empty_line_after_command') {
+              
+              unshift @gathered_index_entries, shift @{$item_container->{'contents'}};
+            } elsif ($item_container->{'contents'}->[0]->{'type'} eq 'empty_spaces_after_command') {
+               unshift @gathered_index_entries, shift @{$item_container->{'contents'}};
+               $gathered_index_entries[0]->{'type'} = 'empty_line_after_command';
+               $gathered_index_entries[0]->{'text'} .= "\n";
+            }
+          }
+          unshift @{$item_container->{'contents'}}, @gathered_index_entries;
+        }
+      }
+    }
+    $previous = $item;
+  }
+}
+
+sub _move_index_entries_after_items($$$)
+{
+  my $self = shift;
+  my $type = shift;
+  my $current = shift;
+
+  if ($current->{'cmdname'} and ($current->{'cmdname'} eq 'enumerate'
+                                 or $current->{'cmdname'} eq 'itemize')) {
+    move_index_entries_after_items($current);
+  }
+  return ($current);
+}
+
+sub move_index_entries_after_items_in_tree($)
+{
+  my $tree = shift;
+  return modify_tree(undef, $tree, \&_move_index_entries_after_items);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Texinfo::Common - Classification of commands and miscellaneous methods
+
+=head1 SYNOPSIS
+
+  use Texinfo::Common qw(expand_today expand_verbatiminclude);
+  if ($Texinfo::Common::accent_commands{$a_command}) {
+    print STDERR "$a_command is an accent command\n";
+  }
+  
+  my $today_tree = expand_today($converter);
+  my $verbatiminclude_tree 
+     = expand_verbatiminclude(undef, $verbatiminclude);
+
+=head1 DESCRIPTION
+
+Texinfo::Common holds interesting hashes classifying Texinfo @-commands,
+as well as miscellaneous methods that may be useful for any backend
+converting texinfo trees.
+
+It also defines, as our variable a hash for default indices,
+named C<%index_names>.  The format of this hash is described in 
+L<Texinfo::Parser/indices_information>.
+
+=head1 COMMAND CLASSES
+
+Hashes are defined as C<our> variables, and are therefore available
+outside of the module.
+
+The key of the hashes are @-command names without the @.  The 
+following hashes are available:
+
+=over
+
+=item %all_commands
+
+All the @-commands.
+
+=item %no_brace_commands
+
+Commands without brace with a single character as name, like C<*>
+or C<:>.  The value is an ascii representation of the command.  It
+may be an empty string.
+
+=item %misc_commands
+
+Command that do not take braces and are not block commands either, like
+C<@node>, C<@chapter>, C<@cindex>, C<@deffnx>, C<@end>, C<@footnotestyle>, 
+C<@set>, C<@settitle>, C<@indent>, C<@definfoenclose>, C<@comment> and many 
+others.
+
+=item %default_index_commands
+
+Index entry commands corresponding to default indices. For example 
+C<@cindex>.
+
+=item %root_commands
+
+Commands that are at the root of a Texinfo document, namely
+C<@node> and sectioning commands, except heading commands.
+
+=item %sectioning_commands
+
+All the sectioning and heading commands.
+
+=item %brace_commands
+
+The commands that take braces.  The associated value is the maximum
+number of arguments.
+
+=item %letter_no_arg_commands
+
+@-commands with braces but no argument corresponding to letters, 
+like C<@AA{}> or C<@ss{}> or C<@o{}>.
+
+=item %accent_commands
+
+Accent @-commands taking an argument, like C<@'> or C<@ringaccent> 
+including C<@dotless> and C<@tieaccent>.
+
+=item %style_commands
+
+Commands that mark a fragment of texinfo, like C<@strong>,
+C<@cite>, C<@code> or C<@asis>.
+
+=item %code_style_commands
+
+I<style_commands> that have their argument in code style, like 
+C<@code>.
+
+=item %regular_font_style_commands
+
+I<style_commands> that have their argument in regular font, like
+C<@r> or C<@slanted>.
+
+=item %context_brace_commands
+
+@-commands with brace like C<@footnote>, C<@caption> and C<@math>
+whose argument is outside of the main text flow in one way or another.
+
+=item %ref_commands
+
+Cross reference @-command referencing nodes, like C<@xref>.
+
+=item %explained_commands
+
+@-commands whose second argument explain first argument and further
+@-command call without first argument, as C<@abbr> and C<@acronym>.
+
+=item %block commands
+
+Commands delimiting a block with a closing C<@end>.  The value
+is I<conditional> for C<@if> commands, I<def> for definition
+commands like C<@deffn>, I<raw> for @-commands that have no expansion
+of @-commands in their bodies and I<multitable> for C<@multitable>.  
+Otherwise it is set to the number of arguments separated by commas 
+that may appear on the @-command line. That means 0 in most cases, 
+1 for C<@quotation> and 2 for C<@float>.
+
+=item %raw_commands
+
+@-commands that have no expansion of @-commands in their bodies,
+as C<@macro>, C<@verbatim> or C<@ignore>.
+
+=item %format_raw_commands
+
+@-commands associated with raw output format, like C<@html>, or
+C<@docbook>.
+
+=item %texinfo_output_formats
+
+Cannonical output formats that have associated conditionals.  In
+practice C<%format_raw_commands> plus C<info> and C<plaintext>.
+
+=item %def_commands
+
+=item %def_aliases
+
+Definition commands.  C<%def_aliases> associates an aliased command
+to the original command, for example C<defun> is associated to C<deffn>.
+
+=item %menu_commands
+
+@-commands with menu entries.
+
+=item %align_commands
+
+@-commands related with alignement of text.
+
+=item %region_commands
+
+Block @-commands that enclose full text regions, like C<@titlepage>.
+
+=item %preformatted_commands
+
+=item %preformatted_code_commands
+
+I<%preformatted_commands> is for commands whose content should not 
+be filled, like C<@example> or C<@display>.  If the command is meant 
+for code, it is also in I<%preformatted_code_commands>, like C<@example>.
+
+=item %item_container_commands
+
+Commands holding C<@item> with C<@item> that contains blocks of text, 
+like C<@itemize>.
+
+=item %item_line_commands
+
+Commands with C<@item> that have their arguments on their lines, like
+C<@ftable>.
+
+=back
+
+=head1 METHODS
+
+No method is exported in the default case.
+
+Most methods takes a I<$converter> as argument, sometime optionally, 
+to get some information and use methods for error reporting, 
+see L<Texinfo::Convert::Converter> and L<Texinfo::Report>.
+
+=over
+
+=item $tree = expand_today($converter)
+
+Expand today's date, as a texinfo tree with translations.
+
+=item $tree = expand_verbatiminclude($converter, $verbatiminclude)
+
+The I<$converter> argument may be undef.  I<$verbatiminclude> is a
+C<@verbatiminclude> tree element.  This function returns a 
+C<@verbatim> tree elements after finding the included file and
+reading it.
+
+=item $tree = definition_category($converter, $def_line)
+
+The I<$converter> argument may be undef.  I<$def_line> is a 
+C<def_line> texinfo tree container.  This function
+returns a texinfo tree corresponding to the category of the
+I<$def_line> taking the class into account, if there is one.
+
+=item $result = numbered_heading ($converter, $heading_element, $heading_text, $do_number)
+
+The I<$converter> argument may be undef.  I<$heading_element> is 
+a heading command tree element.  I<$heading_text> is the already 
+formatted heading text.  if the I<$do_number> optional argument is 
+defined and false, no number is used and the text is returned as is.
+This function returns the heading with a number and the appendix 
+part if needed.
+
+=item ($caption, $prepended) = float_name_caption ($converter, $float)
+
+I<$float> is a texinfo tree C<@float> element.  This function 
+returns the caption that should be used for the float formatting 
+and the I<$prepended> texinfo tree combining the type and label
+of the float.
+
+=item $text = enumerate_item_representation($specification, $number)
+
+This function returns the number or letter correponding to item
+number I<$number> for an C<@enumerate> specification I<$specification>,
+appearing on an C<@enumerate> line.  For example
+
+  enumerate_item_representation('c', 3)
+
+is C<e>.
+
+=item trim_spaces_comment_from_content($contents)
+
+Remove empty spaces after commands or braces at begin and
+spaces and comments at end from a content array, modifying it.
+
+=item $normalized_name = normalize_top_node_name ($node_string)
+
+Normalize the node name string given in argument, by normalizing
+Top node case.
+
+=item protect_comma_in_tree($tree)
+
+Protect comma characters, replacing C<,> with @comma{} in tree.
+
+=item protect_colon_in_tree($tree)
+
+=item protect_node_after_label_in_tree($tree)
+
+Protect colon with C<protect_colon_in_tree> and characters that 
+are special in node names after a label in menu entries (tab
+dot and comma) with C<protect_node_after_label_in_tree>.  
+The protection is achieved by putting protected characters 
+in C<@asis{}>.
+
+=item $contents_result = protect_first_parenthesis ($contents)
+
+Return a contents array reference with first parenthesis in the 
+contents array reference protected.
+
+=item protect_hashchar_at_line_beginning($parser, $tree)
+
+Protect hash character at beginning of line if the line is a cpp
+line directive.  The I<$parser> argument maybe undef, if it is 
+defined it is used for error reporting in case an hash character
+could not be protected because it appeared in a raw environment.
+
+=item move_index_entries_after_items_in_tree($tree)
+
+In C<@enumerate> and C<@itemize> from the tree, move index entries 
+appearing just before C<@item> after the C<@item>.  Comment lines 
+between index entries are moved too.
+
+=item $command = find_parent_root_command($parser, $tree_element)
+
+Find the parent root command of a tree element (sectioning command or node).
+The C<$parser> argument is optional, it is used to continue 
+through C<@insertcopying> if in a C<@copying>.
+
+=item valid_tree_transformation($name)
+
+Return true if the I<$name> is a known tree transformation name
+that may be passed with C<TREE_TRANSFORMATIONS> to modify a texinfo
+tree.
+
+=back
+
+=head1 SEE ALSO
+
+L<Texinfo::Parser>, L<Texinfo::Convert::Converter> and L<Texinfo::Report>. 
+
+=head1 AUTHOR
+
+Patrice Dumas, E<lt>[e-mail]<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright 2010, 2011, 2012 Free Software Foundation, Inc.
+
+This library is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3 of the License,
+or (at your option) any later version.
+
+=cut
+
 
=== added file '.pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Parser.pm'
--- .pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Parser.pm	1970-01-01 00:00:00 +0000
+++ .pc/maybe-upstream-fix-itemize-start/tp/Texinfo/Parser.pm	2013-07-14 15:17:24 +0000
@@ -0,0 +1,6996 @@
+# Parser.pm: parse texinfo code into a tree.
+#
+# Copyright 2010, 2011, 2012 Free Software Foundation, Inc.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License,
+# or (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# 
+# Original author: Patrice Dumas <[e-mail]>
+# Parts (also from Patrice Dumas) come from texi2html.pl or texi2html.init.
+
+# The organization of the file is the following:
+#  module definitions.
+#  default parser state.  With explanation of the internal structures.
+#  initializations, determination of command types.
+#  user visible subroutines.
+#  internal subroutines, doing the parsing.
+
+package Texinfo::Parser;
+
+# We need the unicode stuff.
+use 5.006;
+use strict;
+
+# debug
+use Carp qw(cluck);
+
+use Data::Dumper;
+
+# to detect if an encoding may be used to open the files
+use Encode;
+
+# for fileparse
+use File::Basename;
+
+#use POSIX qw(setlocale LC_ALL LC_CTYPE LC_MESSAGES);
+
+# commands definitions
+use Texinfo::Common;
+# Error reporting and counting, translation of strings.
+use Texinfo::Report;
+# encoding_alias
+use Texinfo::Encoding;
+
+# to expand file names in @include and similar @-commands
+use Texinfo::Convert::Text;
+# to normalize node name, anchor, float arg, listoffloats and first *ref argument.
+use Texinfo::Convert::NodeNameNormalization;
+# in error messages, and for macro body expansion
+use Texinfo::Convert::Texinfo;
+
+require Exporter;
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+@ISA = qw(Exporter Texinfo::Report);
+
+# Items to export into callers namespace by default. Note: do not export
+# names by default without a very good reason. Use EXPORT_OK instead.
+# Do not simply export all your public functions/methods/constants.
+
+# This allows declaration	use Texinfo::Parser ':all';
+# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
+# will save memory.
+%EXPORT_TAGS = ( 'all' => [ qw(
+  parser
+  parse_texi_text
+  parse_texi_line
+  parse_texi_file
+  indices_information
+  floats_information
+  internal_references_information
+  labels_information
+  global_commands_information
+  global_informations
+) ] );
+
+@EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+
+@EXPORT = qw(
+);
+
+$VERSION = '5.0';
+
+sub N__($)
+{
+  return $_[0];
+}
+
+#sub __($$)
+#{
+#  my $self = shift;
+#  return &{$self->{'gettext'}}(@_);
+#}
+
+# Customization variables obeyed by the Parser, and the default values.
+our %default_customization_values = (
+  'TEST' => 0,
+  'DEBUG' => 0,     # if >= 10, tree is printed in texi2any.pl after parsing.
+                    # If >= 100 tree is printed every line.
+  'SHOW_MENU' => 1,             # if false no menu error related.
+  'INLINE_INSERTCOPYING' => 0,
+  'IGNORE_BEFORE_SETFILENAME' => 1,
+  'MACRO_BODY_IGNORES_LEADING_SPACE' => 0,
+  'IGNORE_SPACE_AFTER_BRACED_COMMAND_NAME' => 1,
+  'INPUT_PERL_ENCODING' => undef, # input perl encoding name, set from 
+                              # @documentencoding in the default case
+  'INPUT_ENCODING_NAME' => undef, # encoding name normalized as preferred
+                              # IANA, set from @documentencoding in the default
+                              # case
+  'CPP_LINE_DIRECTIVES' => 1, # handle cpp like synchronization lines
+  'MAX_MACRO_CALL_NESTING' => 100000, # max number of nested macro calls
+  'GLOBAL_COMMANDS' => [],    # list of commands registered 
+  # This is not used directly, but passed to Convert::Text through 
+  # Texinfo::Common::_convert_text_options
+  'ENABLE_ENCODING' => 1,     # output accented and special characters
+                              # based on @documentencoding
+  # following are used in Texinfo::Structuring
+  'TOP_NODE_UP' => '(dir)',   # up node of Top node
+  'SIMPLE_MENU' => 0,         # not used in the parser but in structuring
+  'USE_UP_NODE_FOR_ELEMENT_UP' => 0, # Use node up for Up if there is no 
+                                     # section up.
+);
+
+my %parser_default_configuration = (%Texinfo::Common::default_parser_state_configuration,
+                                    %default_customization_values);
+
+# the other possible keys for the parser state are:
+#
+# expanded_formats_hash   each key comes from expanded_formats value is 1
+# index_names             a structure holding the link between index 
+#                         names, prefixes, merged indices,
+#                         initial value is %index_names in Texinfo::Common.
+# context_stack           stack of the contexts, more recent on top.
+#                         'line' is added when on a line or 
+#                         block @-command line,
+#                         'def' is added instead if on a definition line.
+#                         'preformatted' is added in block commands 
+#                         where there is no paragraphs and spaces are kept 
+#                         (format, example, display...)
+#                         'rawpreformatted' is added in raw block commands
+#                         (html, xml, docbook...)
+#                         'menu' is added in menu commands
+#                         'math', 'footnote', 'caption', 'shortcaption', 
+#                         'inlineraw' are also added when in those commands
+# conditionals_stack      a stack of conditional commands that are expanded.
+# raw_formats_stack       a stack of 1 or 0 for raw formats (@html... or 
+#                         @inlineraw), is 0 if within a raw format that is
+#                         not expanded.
+# macro_stack             stack of macros being expanded (more recent first)
+# definfoenclose          an hash, key is the command name, value is an array
+#                         reference with 2 values, beginning and ending.
+# input                   a stack, with last at bottom.  Holds the opened files
+#                         or text.  Pending macro expansion or text expansion
+#                         is also in that structure.
+# misc_commands           the same than %misc_commands in Texinfo::Common, 
+#                         but with index entry commands dynamically added
+# close_paragraph_commands      same than %close_paragraph_commands, but with
+#                               insertcopying removed if INLINE_INSERTCOPYING
+# close_preformatted_commands   same than %close_preformatted_commands, but with
+#                               insertcopying removed if INLINE_INSERTCOPYING
+# no_paragraph_commands   the same than %default_no_paragraph_commands
+#                         below, with index
+#                         entry commands dynamically added
+# simple_text_commands    the same than %simple_text_commands below, but 
+#                         with index entry commands dynamically added
+# current_node            last seen node.
+# current_section         last seen section.
+# nodes                   list of nodes.
+# command_index_prefix    associate a command name to an index prefix.
+# prefix_to_index_name    associate an index prefix to the index name.
+# floats                  key is the normalized float type, value is an array
+#                         reference holding all the floats.
+# internal_references     an array holding all the internal references.
+
+# set                     points to the value set when initializing, for
+#                         configuration items that are not to be overriden
+#                         by @-commands.  For example documentlanguage.
+
+# A line information is an hash reference with the keys:
+# line_nr        the line number
+# file_name      the file name
+# macro          if in a macro expansion, the name of the macro
+#
+# A text fragment information is a 2 element array reference, the first is the
+# text fragment, the second is the line information.
+
+# The input structure is an array, the first is the most recently included
+# file.  The last element may be a file if the parsing is done on a file, 
+# with parse_texi_file, or simply pending text, if called as parse_texi_text.
+# each element of the array is a hash reference.  The key are:
+# pending    an array reference containing pending text fragments, either the
+#            text given as parse_texi_text or macro expansion text.
+# name       file name
+# line_nr    current line number in the file
+# fh         filehandle for the file
+
+# content is not copied but reference is copied when duplicating a parser.
+my %tree_informations;
+foreach my $tree_information ('values', 'macros', 'explained_commands', 'labels') {
+  $tree_informations{$tree_information} = 1;
+}
+
+# The commands in initialization_overrides are not set in the document if
+# set at the parser initialization.
+my %initialization_overrides = (
+  'INPUT_ENCODING_NAME' => 1,
+  'documentlanguage' => 1,
+);
+
+my %no_brace_commands         = %Texinfo::Common::no_brace_commands;
+my %misc_commands             = %Texinfo::Common::misc_commands;
+my %brace_commands            = %Texinfo::Common::brace_commands;    
+my %accent_commands           = %Texinfo::Common::accent_commands;
+my %context_brace_commands    = %Texinfo::Common::context_brace_commands;
+my %block_commands            = %Texinfo::Common::block_commands;
+my %block_item_commands       = %Texinfo::Common::block_item_commands;
+my %close_paragraph_commands  = %Texinfo::Common::close_paragraph_commands;
+my %def_map                   = %Texinfo::Common::def_map;
+my %def_commands              = %Texinfo::Common::def_commands;
+my %def_aliases               = %Texinfo::Common::def_aliases;
+my %menu_commands             = %Texinfo::Common::menu_commands;
+my %preformatted_commands     = %Texinfo::Common::preformatted_commands;
+my %format_raw_commands = %Texinfo::Common::format_raw_commands;
+my %item_container_commands   = %Texinfo::Common::item_container_commands;
+my %item_line_commands        = %Texinfo::Common::item_line_commands;
+my %deprecated_commands       = %Texinfo::Common::deprecated_commands;
+my %root_commands             = %Texinfo::Common::root_commands;
+my %sectioning_commands       = %Texinfo::Common::sectioning_commands;
+my %command_index_prefix      = %Texinfo::Common::command_index_prefix;
+my %command_structuring_level = %Texinfo::Common::command_structuring_level;
+my %ref_commands              = %Texinfo::Common::ref_commands;
+my %region_commands           = %Texinfo::Common::region_commands;
+my %code_style_commands       = %Texinfo::Common::code_style_commands;
+my %in_heading_commands       = %Texinfo::Common::in_heading_commands;
+my %explained_commands        = %Texinfo::Common::explained_commands;
+my %inline_format_commands    = %Texinfo::Common::inline_format_commands;
+my %all_commands              = %Texinfo::Common::all_commands;
+
+# equivalence between a @set flag and an @@-command
+my %set_flag_command_equivalent = (
+  'txicodequoteundirected' => 'codequoteundirected',
+  'txicodequotebacktick'   => 'codequotebacktick',
+#  'txideftypefnnl'         => 'deftypefnnewline',
+);
+
+
+# keep line information for those commands.
+my %keep_line_nr_brace_commands = %context_brace_commands;
+foreach my $keep_line_nr_brace_command ('titlefont', 'anchor') {
+  $keep_line_nr_brace_commands{$keep_line_nr_brace_command} = 1;
+}
+foreach my $brace_command (keys (%brace_commands)) {
+  $keep_line_nr_brace_commands{$brace_command} = 1
+    if ($brace_commands{$brace_command} > 1);
+}
+
+my %type_with_paragraph;
+foreach my $type ('before_item', 'text_root', 'document_root',
+                  'brace_command_context') {
+  $type_with_paragraph{$type} = 1;
+}
+
+my %command_ignore_space_after;
+foreach my $command ('anchor', 'hyphenation', 'caption', 'shortcaption') {
+  $command_ignore_space_after{$command} = 1;
+}
+
+my %global_multiple_commands;
+foreach my $global_multiple_command (
+  'author', 'footnote', 'hyphenation', 'insertcopying', 'printindex',
+  'subtitle','titlefont', 'listoffloats', 'detailmenu',
+  keys(%Texinfo::Common::document_settable_at_commands), ) {
+  $global_multiple_commands{$global_multiple_command} = 1;
+}
+
+my %global_unique_commands;
+foreach my $global_unique_command (
+  'copying', 'settitle', 
+  'shorttitlepage', 'title', 'titlepage', 'top', 
+  keys(%Texinfo::Common::document_settable_unique_at_commands), ) {
+  $global_unique_commands{$global_unique_command} = 1;
+}
+
+my %index_names = %Texinfo::Common::index_names;
+
+# index names that cannot be set by the user.
+my %forbidden_index_name = ();
+
+foreach my $name(keys(%index_names)) {
+  foreach my $prefix (@{$index_names{$name}->{'prefix'}}) {
+    $forbidden_index_name{$prefix} = 1;
+  }
+}
+
+foreach my $other_forbidden_index_name ('info','ps','pdf','htm',
+   'html', 'log','aux','dvi','texi','txi','texinfo','tex','bib') {
+  $forbidden_index_name{$other_forbidden_index_name} = 1;
+}
+
+# @-commands that do not start a paragraph
+my %default_no_paragraph_commands;
+# @-commands that should be at a line beginning
+my %begin_line_commands;
+
+foreach my $command ('node', 'end') {
+  $begin_line_commands{$command} = $command;
+}
+
+foreach my $no_paragraph_command ('titlefont', 'caption', 'shortcaption', 
+          'image', '*', 'hyphenation', 'anchor', 'errormsg') {
+  $default_no_paragraph_commands{$no_paragraph_command} = 1;
+}
+
+foreach my $no_paragraph_command (keys(%misc_commands)) {
+  $default_no_paragraph_commands{$no_paragraph_command} = 1;
+  $begin_line_commands{$no_paragraph_command} = 1;
+}
+
+# verbatiminclude is not said to begin at the beginning of the line
+# in the manual
+foreach my $misc_not_begin_line ('comment', 'c', 'sp', 'refill', 
+                                'noindent', 'indent', 'columnfractions',
+                                'tab', 'item', 'headitem', 'verbatiminclude',
+                                'set', 'clear',
+                                'vskip', keys(%in_heading_commands)) {
+  delete $begin_line_commands{$misc_not_begin_line};
+}
+
+my %block_arg_commands;
+foreach my $block_command (keys(%block_commands)) {
+  $begin_line_commands{$block_command} = 1;
+  $default_no_paragraph_commands{$block_command} = 1;
+  $block_arg_commands{$block_command} = 1 
+    if ($block_commands{$block_command} ne 'raw');
+#        and ! $format_raw_commands{$block_command});
+}
+
+my %close_preformatted_commands = %close_paragraph_commands;
+foreach my $no_close_preformatted('sp') {
+  delete $close_preformatted_commands{$no_close_preformatted};
+}
+# FIXME to close preformated or not to close?
+#foreach my $format_raw_command(keys(%format_raw_commands)) {
+#  $close_preformatted_commands{$format_raw_command} = 1;
+#}
+
+# commands that may appear in accents
+my %in_accent_commands = %accent_commands;
+foreach my $brace_command(keys(%brace_commands)) {
+  $in_accent_commands{$brace_command} = 1 if (!$brace_commands{$brace_command});
+}
+foreach my $no_brace_command (keys(%no_brace_commands)) {
+  $in_accent_commands{$no_brace_command} = 1;
+}
+$in_accent_commands{'c'} = 1;
+$in_accent_commands{'comment'} = 1;
+
+# commands that may appear in texts arguments
+my %in_full_text_commands;
+foreach my $command (keys(%brace_commands), keys(%no_brace_commands)) {
+  $in_full_text_commands{$command} = 1;
+}
+foreach my $misc_command_in_full_text('c', 'comment', 'refill', 'noindent',
+                         'indent', 'columnfractions', 'set', 'clear', 'end') {
+  $in_full_text_commands{$misc_command_in_full_text} = 1;
+}
+
+foreach my $out_format (keys(%format_raw_commands)) {
+  $in_full_text_commands{$out_format} = 1;
+}
+delete $in_full_text_commands{'caption'};
+delete $in_full_text_commands{'shortcaption'};
+foreach my $block_command (keys(%block_commands)) {
+  $in_full_text_commands{$block_command} = 1 
+    if ($block_commands{$block_command} eq 'conditional');
+}
+
+# commands that may happen on lines where everything is
+# permitted
+my %in_full_line_commands = %in_full_text_commands;
+foreach my $not_in_full_line_commands('noindent', 'indent') {
+  delete $in_full_line_commands{$not_in_full_line_commands};
+}
+
+# commands that may happen on sectioning commands 
+my %in_full_line_commands_no_refs = %in_full_line_commands;
+foreach my $not_in_full_line_commands_no_refs ('titlefont', 
+                                   'anchor', 'footnote', 'verb') {
+  delete $in_full_line_commands_no_refs{$not_in_full_line_commands_no_refs};
+}
+
+# commands that may happen in simple text arguments
+my %in_simple_text_commands = %in_full_line_commands_no_refs;
+foreach my $not_in_simple_text_command('xref', 'ref', 'pxref', 'inforef') {
+  delete $in_simple_text_commands{$not_in_simple_text_command};
+}
+
+# commands that only accept simple text as argument in any context.
+my %simple_text_commands;
+foreach my $misc_command(keys(%misc_commands)) {
+  if ($misc_commands{$misc_command} =~ /^\d+$/ 
+      or ($misc_commands{$misc_command} eq 'line' 
+          and !($sectioning_commands{$misc_command}
+                or $def_commands{$misc_command}))
+      or $misc_commands{$misc_command} eq 'text') {
+    $simple_text_commands{$misc_command} = 1;
+  }
+}
+
+my %full_line_commands_no_refs = (%sectioning_commands,
+                                  %def_commands);
+
+delete $simple_text_commands{'center'};
+delete $simple_text_commands{'exdent'};
+foreach my $command ('titlefont', 'anchor', 'xref','ref','pxref', 
+                     'inforef', 'shortcaption', 'math', 'indicateurl',
+                     'email', 'uref', 'url', 'image', 'abbr', 'acronym', 
+                     'dmn', 'ctrl', 'errormsg') {
+  $simple_text_commands{$command} = 1;
+}
+
+# commands that accept full text, but no block or top-level commands
+my %full_text_commands;
+foreach my $brace_command (keys (%brace_commands)) {  
+  if ($brace_commands{$brace_command} == 1 
+      and !$simple_text_commands{$brace_command} 
+      and !$context_brace_commands{$brace_command}
+      and !$accent_commands{$brace_command}) {
+    $full_text_commands{$brace_command} = 1;
+  }
+}
+
+# commands that accept almost the same than in full text, except
+# what do not make sense on a line.
+my %full_line_commands;
+$full_line_commands{'center'} = 1;
+$full_line_commands{'exdent'} = 1;
+$full_line_commands{'item'} = 1;
+$full_line_commands{'itemx'} = 1;
+
+# Fill the valid nestings hash.  All commands not in that hash 
+# are considered to accept anything within.  There are additional
+# context tests, to make sure, for instance that we are testing
+# @-commands on the block, misc or node @-command line and not
+# in the content.
+# index entry commands are dynamically set as in_simple_text_commands
+my %default_valid_nestings;
+
+foreach my $command (keys(%accent_commands)) {
+  $default_valid_nestings{$command} = \%in_accent_commands;
+}
+foreach my $command (keys(%full_text_commands)) {
+  $default_valid_nestings{$command} = \%in_full_text_commands;
+}
+foreach my $command (keys(%simple_text_commands)) {
+  $default_valid_nestings{$command} = \%in_simple_text_commands;
+}
+foreach my $command (keys(%full_line_commands)) {
+  $default_valid_nestings{$command} = \%in_full_line_commands;
+}
+foreach my $command (keys(%full_line_commands_no_refs)) {
+  $default_valid_nestings{$command} = \%in_full_line_commands_no_refs;
+}
+# Only for block commands with line arguments
+foreach my $command (keys(%block_commands)) {
+  if ($block_commands{$command} and $block_commands{$command} ne 'raw'
+      and $block_commands{$command} ne 'conditional'
+      and !$def_commands{$command}) {
+    $default_valid_nestings{$command} = \%in_simple_text_commands;
+  }
+}
+
+
+my @preformatted_contexts = ('preformatted', 'rawpreformatted');
+my %preformatted_contexts;
+foreach my $preformatted_context (@preformatted_contexts) {
+  $preformatted_contexts{$preformatted_context} = 1;
+}
+
+# contexts on the context_stack stack where empty line don't trigger
+# paragraph
+my %no_paragraph_contexts;
+foreach my $no_paragraph_context ('math', 'menu', @preformatted_contexts, 
+                                  'def', 'inlineraw') {
+  $no_paragraph_contexts{$no_paragraph_context} = 1;
+};
+
+
+
 
+# Format a bug message
+sub _bug_message($$;$$)
+{
+  my $self = shift;
+  my $message = shift;
+  my $line_number = shift;
+  my $current = shift;
+
+  my $line_message = '';
+  if ($line_number) {
+    my $file = $line_number->{'file_name'};
+    $line_message 
+      = "last location: $line_number->{'file_name'}:$line_number->{'line_nr'}";
+    if ($line_number->{'macro'} ne '') {
+      $line_message .= " (possibly involving $line_number->{'macro'})";
+    }
+    $line_message .= "\n";
+  }
+  my $message_context_stack = "context_stack: (@{$self->{'context_stack'}})\n";
+  my $current_element_message = '';
+  if ($current) {
+    $current_element_message = "current: ". _print_current($current);
+  }
+  warn "You found a bug: $message\n\n".
+       "Additional informations:\n".
+       $line_message.$message_context_stack.$current_element_message;
+  
+}
+
+# simple deep copy of a structure
+sub _deep_copy($)
+{
+  my $struct = shift;
+  my $string = Data::Dumper->Dump([$struct], ['struct']);
+  eval $string;
+  return $struct;
+}
+
+# return true if effect of global commands should be ignored.
+sub _ignore_global_commands($)
+{
+  my $self = shift;
+  return !$self->{'raw_formats_stack'}->[-1];
+}
+
+# enter all the commands associated with an index name using the prefix
+# list
+sub _register_index_commands($$)
+{
+  my $self = shift;
+  my $index_name = shift;
+  if (!$self->{'index_names'}->{$index_name}->{'prefix'}) {
+    $self->{'index_names'}->{$index_name}->{'prefix'} = [$index_name];
+  }
+  if (!exists($self->{'index_names'}->{$index_name}->{'name'})) {
+    $self->{'index_names'}->{$index_name}->{'name'} = $index_name;
+  }
+  if (!exists($self->{'index_names'}->{$index_name}->{'contained_indices'})) {
+    $self->{'index_names'}->{$index_name}->{'contained_indices'}->{$index_name} = 1;
+  }
+  foreach my $prefix (@{$self->{'index_names'}->{$index_name}->{'prefix'}}) {
+    $self->{'misc_commands'}->{$prefix.'index'} = 'line';
+    $self->{'no_paragraph_commands'}->{$prefix.'index'} = 1;
+    $self->{'valid_nestings'}->{$prefix.'index'} = \%in_simple_text_commands;
+    $self->{'command_index_prefix'}->{$prefix.'index'} = $prefix;
+    $self->{'prefix_to_index_name'}->{$prefix} = $index_name;
+  }
+}
+
+# initialization entry point.  Set up a parser.
+# The last argument, optional, is a hash provided by the user to change
+# the default values for what is present in %parser_default_configuration.
+# The exact arguments of the function depend on how it was called,
+# in a object oriented way or not.
+sub parser(;$$)
+{
+  my $class = shift;
+  my $conf;
+
+  my $parser = _deep_copy(\%parser_default_configuration);
+  # _deep_copy doesn't handle subs
+  $parser->{'gettext'} = $parser_default_configuration{'gettext'};
+  $parser->{'pgettext'} = $parser_default_configuration{'pgettext'};
+
+  # called not object-oriented
+  if (ref($class) eq 'HASH') {
+    #print STDERR "Not oo\n"
+    $conf = $class;
+    bless $parser;
+
+  } elsif (ref($class)) { 
+    # called on an existing parser, interpreted as a duplication
+    my $old_parser = $class;
+    $class = ref($class);
+    foreach my $key (keys(%parser_default_configuration)) {
+      if ($tree_informations{$key}) {
+        if (defined($old_parser->{$key})) {
+          foreach my $info_key (keys(%{$old_parser->{$key}})) {
+            $parser->{$key}->{$info_key}
+              = $old_parser->{$key}->{$info_key};
+          }
+        }
+      } else {
+        $parser->{$key} = _deep_copy($old_parser->{$key});
+      }
+    }
+    #$parser = _deep_copy($old_parser);
+    $parser->{'gettext'} = $old_parser->{'gettext'};
+    $parser->{'pgettext'} = $old_parser->{'pgettext'};
+    bless $parser, $class;
+    $conf = shift;
+
+  } elsif (defined($class)) {
+    bless $parser, $class;
+    $conf = shift;
+  } else {
+    bless $parser;
+    $conf = shift;
+  }
+
+  if (defined($conf)) {
+    foreach my $key (keys(%$conf)) {
+      if (exists($parser_default_configuration{$key})) {
+        if (ref($conf->{$key}) ne 'CODE' and $key ne 'values') {
+          $parser->{$key} = _deep_copy($conf->{$key});
+        } else {
+          $parser->{$key} = $conf->{$key};
+        }
+        if ($initialization_overrides{$key}) {
+          $parser->{'set'}->{$key} = $parser->{$key};
+        }
+      } else {
+        warn "$key not a possible customization in Texinfo::Parser::parser\n";
+      }
+    }
+  }
+  #foreach my $value (keys %{$parser->{'values'}}) {
+  #  print STDERR "   ->  $value $parser->{'values'}->{$value}\n";
+  #}
+  # Now initialize command hash that are dynamically modified, notably
+  # those for index commands, and lists, based on defaults and user provided.
+  $parser->{'misc_commands'} = _deep_copy (\%misc_commands);
+  $parser->{'valid_nestings'} = _deep_copy (\%default_valid_nestings);
+  $parser->{'no_paragraph_commands'} = { %default_no_paragraph_commands };
+  $parser->{'index_names'} = _deep_copy (\%index_names);
+  $parser->{'command_index_prefix'} = {%command_index_prefix};
+  $parser->{'close_paragraph_commands'} = {%close_paragraph_commands};
+  $parser->{'close_preformatted_commands'} = {%close_preformatted_commands};
+  if ($parser->{'INLINE_INSERTCOPYING'}) {
+    delete $parser->{'close_paragraph_commands'}->{'insercopying'};
+    delete $parser->{'close_preformatted_commands'}->{'insercopying'};
+  }
+  # a hash is simply concatenated.  It should be like %index_names.
+  if (ref($parser->{'indices'}) eq 'HASH') {
+    %{$parser->{'index_names'}} = (%{$parser->{'index_names'}}, 
+                                   %{$parser->{'indices'}});
+  } else { # an array holds index names defined with @defindex
+    foreach my $name (@{$parser->{'indices'}}) {
+      $parser->{'index_names'}->{$name} = {'in_code' => 0};
+    }
+  }
+  foreach my $index (keys (%{$parser->{'index_names'}})) {
+    $parser->_register_index_commands($index);
+  }
+  if ($parser->{'merged_indices'}) {
+    foreach my $index_from (keys (%{$parser->{'merged_indices'}})) {
+      my $index_to = $parser->{'merged_indices'}->{$index_from};
+      if (defined($parser->{'index_names'}->{$index_from})
+          and defined($parser->{'index_names'}->{$index_to})) {
+        $parser->{'index_names'}->{$index_from}->{'merged_in'} = $index_to;
+        $parser->{'index_names'}->{$index_to}->{'contained_indices'}->{$index_from} = 1;
+      }
+    }
+  }
+  foreach my $explained_command(keys(%explained_commands)) {
+    if  (!defined($parser->{'explained_commands'}->{$explained_command})) {
+      $parser->{'explained_commands'}->{$explained_command} = {};
+    }
+  }
+  $parser->{'context_stack'} = [ $parser->{'context'} ];
+  $parser->{'regions_stack'} = [];
+  $parser->{'macro_stack'} = [];
+  $parser->{'conditionals_stack'} = [];
+  $parser->{'raw_formats_stack'} = [1];
+
+  # turn the array to a hash for speed.  Not sure it really matters for such
+  # a small array.
+  foreach my $expanded_format(@{$parser->{'expanded_formats'}}) {
+    $parser->{'expanded_formats_hash'}->{$expanded_format} = 1;
+  }
+
+  %{$parser->{'global_commands'}} = %global_multiple_commands;
+
+  foreach my $global_command (@{$parser->{'GLOBAL_COMMANDS'}}) {
+    $parser->{'global_commands'}->{$global_command} = 1;
+  }
+
+  $parser->Texinfo::Report::new;
+
+  return $parser;
+}
+
+sub get_conf($$)
+{
+  my $self = shift;
+  my $var = shift;
+  return $self->{$var};
+}
+
+# split a scalar text in an array lines.
+sub _text_to_lines($)
+{
+  my $text = shift;
+  die if (!defined($text));
+  my $had_final_end_line = chomp($text);
+  my $lines = [ map {$_."\n"} split (/\n/, $text, -1) ];
+  $lines = [''] if (!@$lines);
+  chomp($lines->[-1]) unless ($had_final_end_line);
+  return $lines;
+}
+
+# construct a text fragments array matching a lines array, based on information
+# supplied.
+# If $fixed_line_number is set the line number is not increased, otherwise
+# it is increased, beginning at $first_line.
+sub _complete_line_nr($$;$$$)
+{
+  my $lines = shift;
+  my $first_line = shift;
+  my $file = shift;
+  my $macro = shift;
+  my $fixed_line_number = shift;
+
+  $macro = '' if (!defined($macro));
+  $file = '' if (!defined($file));
+  my $new_lines = [];
+
+  if (defined($first_line)) {
+    my $line_index = $first_line;
+    foreach my $index(0..scalar(@$lines)-1) {
+      $line_index = $index+$first_line if (!$fixed_line_number);
+      $new_lines->[$index] = [ $lines->[$index],  
+                             { 'line_nr' => $line_index,
+                               'file_name' => $file, 'macro' => $macro } ];
+    }
+  } else {
+    foreach my $line (@$lines) {
+      push @$new_lines, [ $line ];
+    }
+  }
+  return $new_lines;
+}
+
+# entry point for text fragments.
+# Used in tests.
+# Note that it has no associated root type a opposed to parse_texi_line
+# and parse_texi_file.
+sub parse_texi_text($$;$$$$)
+{
+  my $self = shift;
+  my $text = shift;
+  my $lines_nr = shift;
+  my $file = shift;
+  my $macro = shift;
+  my $fixed_line_number = shift;
+
+  return undef if (!defined($text));
+
+  my $lines_array = [];
+  if (!ref($text)) {
+    $text = _text_to_lines($text);
+  }
+  $lines_nr = [] if (!defined($lines_nr));
+  if (!ref($lines_nr)) {
+    #$file =~ s/^.*\/// if (defined($file) and $self->{'TEST'});
+    $lines_array = _complete_line_nr($text, $lines_nr, $file, 
+                                     $macro, $fixed_line_number);
+  } else {
+    while (@$text) {
+      my $line_nr = shift @$lines_nr;
+      my $line = shift @$text;
+      push @$lines_array, [$line, $line_nr];
+    }
+  }
+
+  $self = parser() if (!defined($self));
+  $self->{'input'} = [{'pending' => $lines_array}];
+  my $tree = $self->_parse_texi();
+  return $tree;
+}
+
+# Not used for now, as a @contents after the first sectioning command
+# is correct if not using TeX.
+sub _check_contents_location($$)
+{
+  my $self = shift;
+  my $tree = shift;
+
+  my $commands = $self->global_commands_information();
+  return unless ($commands);
+  # Find the last sectioning command
+  my $index = -1;
+  my %ending_root_commands;
+  my $found = 0;
+  while ($tree->{'contents'}->[$index]) {
+    if (defined($tree->{'contents'}->[$index]->{'cmdname'})) {
+      $ending_root_commands{$tree->{'contents'}->[$index]} = 1;
+      if ($sectioning_commands{$tree->{'contents'}->[$index]->{'cmdname'}}) {
+        $found = 1;
+        last;
+      }
+    }
+    $index--;
+  }
+  return if (!$found);
+
+  #print STDERR "ending_root_commands ".join('|',keys(%ending_root_commands))."\n";
+  #print STDERR "tree contents: ".join('|', @{$tree->{'contents'}})."\n";
+  foreach my $command ('contents', 'shortcontents', 'summarycontents') {
+    if ($commands->{$command}) {
+      foreach my $current (@{$commands->{$command}}) {
+        my $root_command = $self->Texinfo::Common::find_parent_root_command($current);
+        #print STDERR "root_command for $current->{'cmdname'}: $root_command\n";
+        if (defined($root_command) 
+            and !$ending_root_commands{$root_command}) {
+          $self->line_warn(sprintf($self->__(
+                  "\@%s should only appear at beginning or end of document"),
+                            $current->{'cmdname'}), $current->{'line_nr'});                       
+        }
+      }
+    }
+  }
+}
+
+# parse a texi file
+sub parse_texi_file($$)
+{
+  my $self = shift;
+  my $file_name = shift;
+
+  my $filehandle = do { local *FH };
+  if (! open($filehandle, $file_name)) { 
+    $self->document_error(sprintf($self->__("could not open %s: %s"), 
+                                  $file_name, $!));
+    return undef;
+  }
+  my $line_nr = 0;
+  my $line;
+  my @first_lines;
+
+  my $pending_first_texi_line;
+  # the first line not empty and not with \input is kept in 
+  # $pending_first_texi_line and put in the pending lines just below
+  while ($line = <$filehandle>) {
+    $line_nr++;
+    if ($line =~ /^ *\\input/ or $line =~ /^\s*$/) {
+      $line =~ s/\x{7F}.*\s*//;
+      push @first_lines, $line;
+    } else {
+      $pending_first_texi_line = $line;
+      last;
+    }
+  }
+  my $root = { 'contents' => [], 'type' => 'text_root' };
+  if (@first_lines) {
+    push @{$root->{'contents'}}, { 'type' => 'preamble', 'contents' => [] };
+    foreach my $line (@first_lines) {
+      push @{$root->{'contents'}->[-1]->{'contents'}}, 
+                                   { 'text' => $line,
+                                     'type' => 'preamble_text' };
+    }
+  }
+  my ($directories, $suffix);
+  ($file_name, $directories, $suffix) = fileparse($file_name)
+            if ($self->{'TEST'});
+  $self = parser() if (!defined($self));
+  $self->{'input'} = [{
+       'pending' => [[$pending_first_texi_line, {'line_nr' => $line_nr,
+                                'macro' => '', 'file_name' => $file_name}]],
+       'name' => $file_name,
+       'line_nr' => $line_nr,
+       'fh' => $filehandle
+        }];
+  $self->{'info'}->{'input_file_name'} = $file_name;
+  my $tree = $self->_parse_texi($root);
+
+  # Find 'text_root', which contains everything before first node/section.
+  # if there are elements, 'text_root' is the first content, otherwise it
+  # is the root.
+  my $text_root;
+  if ($tree->{'type'} eq 'text_root') {
+    $text_root = $tree;
+  } elsif ($tree->{'contents'} and $tree->{'contents'}->[0]
+           and $tree->{'contents'}->[0]->{'type'} eq 'text_root') {
+    $text_root = $tree->{'contents'}->[0];
+  }
+
+  # Put everything before @setfilename in a special type.  This allows to
+  # ignore everything before @setfilename.
+  if ($self->{'IGNORE_BEFORE_SETFILENAME'} and $text_root and 
+      $self->{'extra'} and $self->{'extra'}->{'setfilename'}
+      and $self->{'extra'}->{'setfilename'}->{'parent'} eq $text_root) {
+    my $before_setfilename = {'type' => 'preamble_before_setfilename',
+                              'parent' => $text_root,
+                              'contents' => []};
+    while ($text_root->{'contents'}->[0] ne $self->{'extra'}->{'setfilename'}) {
+      my $content = shift @{$text_root->{'contents'}};
+      $content->{'parent'} = $before_setfilename;
+      push @{$before_setfilename->{'contents'}}, $content;
+    }
+    unshift (@{$text_root->{'contents'}}, $before_setfilename)
+      if (@{$before_setfilename->{'contents'}});
+  }
+  #$self->_check_contents_location($tree);
+
+  return $tree;
+}
+
+sub parse_texi_line($$;$$$$)
+{
+  my $self = shift;
+  my $text = shift;
+  my $lines_nr = shift;
+  my $file = shift;
+  my $macro = shift;
+  my $fixed_line_number = shift;
+
+  return undef if (!defined($text));
+
+  if (!ref($text)) {
+    $text = _text_to_lines($text);
+  }
+  #$file =~ s/^.*\/// if (defined($file) and $self->{'TEST'});
+  my $lines_array = _complete_line_nr($text, $lines_nr, $file, 
+                                     $macro, $fixed_line_number);
+
+  $self = parser() if (!defined($self));
+  $self->{'input'} = [{'pending' => $lines_array}];
+  my $tree = $self->_parse_texi({'contents' => [], 'type' => 'root_line'});
+  return $tree;
+}
+
+# return indices informations
+sub indices_information($)
+{
+  my $self = shift;
+  return ($self->{'index_names'}, $self->{'merged_indices'});
+  #return ($self->{'index_names'}, $self->{'merged_indices'}, $self->{'index_entries'});
+}
+
+sub floats_information($)
+{
+  my $self = shift;
+  return $self->{'floats'};
+}
+
+sub internal_references_information($)
+{
+  my $self = shift;
+  return $self->{'internal_references'};
+}
+
+sub global_commands_information($)
+{
+  my $self = shift;
+  return $self->{'extra'};
+}
+
+# @ dircategory_direntry
+# @ unassociated_menus
+# perl_encoding
+# input_encoding_name
+# input_file_name
+sub global_informations($)
+{
+  my $self = shift;
+  return $self->{'info'};
+}
+
+sub labels_information($)
+{
+  my $self = shift;
+  return $self->{'labels'};
+}
+
+# Following are the internal subroutines.  The most important are
+# _parse_texi:  the main parser loop.
+# _end_line:    called at an end of line.  Handling of @include lines is 
+#               done here.
+# _next_text:   present the next text fragment, from pending text or line,
+#               as described above.
+
+# for debugging
+sub _print_current($)
+{
+  my $current = shift;
+  return Texinfo::Common::_print_current($current);
+}
+
+# for debugging
+sub _print_command_args_texi($)
+{
+  my $current = shift;
+  return '' if (!$current->{'cmdname'});
+  my $args = '';
+  my $with_brace;
+  if ($current->{'args'} and @{$current->{'args'}}) {
+    $with_brace 
+        = ($current->{'args'}->[0]->{'type'} eq 'brace_command_arg'
+           or $current->{'args'}->[0]->{'type'} eq 'brace_command_context');
+    $args .= '{' if ($with_brace);
+    foreach my $arg (@{$current->{'args'}}) {
+      $args .= Texinfo::Convert::Texinfo::convert($arg).', ';
+    }
+    $args =~ s/, $//;
+  }
+  chomp($args);
+  if ($with_brace) {
+    $args .= '}';
+  }
+  return '@'.$current->{'cmdname'} .$args."\n";
+}
+
+sub _print_current_keys($)
+{
+  my $current = shift;
+  my $string = _print_current($current);
+  foreach my $key (keys (%$current)) {
+    $string .= "   $key: $current->{$key}\n";
+  }
+  if ($current->{'extra'}) {
+    $string .= "    EXTRA\n";
+    foreach my $key (keys (%{$current->{'extra'}})) {
+      $string .= "    $key: $current->{'extra'}->{$key}\n";
+    }
+  }
+  return $string;
+}
+
+# For debugging
+my @kept_keys = ('contents', 'cmdname', 'type', 'text', 'args');
+my %kept_keys;
+foreach my $key (@kept_keys) {
+  $kept_keys{$key} = 1;
+}
+sub _filter_print_keys { [grep {$kept_keys{$_}} ( sort keys %{$_[0]} )] };
+sub _print_tree($)
+{
+  my $tree = shift;
+  local $Data::Dumper::Sortkeys = \&_filter_print_keys;
+  local $Data::Dumper::Purity = 1;
+  local $Data::Dumper::Indent = 1;
+
+  return Data::Dumper->Dump([$tree]);
+}
+
+sub _register_global_command($$$$)
+{
+  my $self = shift;
+  my $command = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  if ($command eq 'summarycontents' and !$self->{'global_commands'}->{$command}) {
+    $command = 'shortcontents';
+  }
+  if ($self->{'global_commands'}->{$command} and $command ne 'author') {
+    push @{$self->{'extra'}->{$command}}, $current
+      unless (_ignore_global_commands($self));
+    $current->{'line_nr'} = $line_nr if (!$current->{'line_nr'});
+    return 1;
+  } elsif ($global_unique_commands{$command}) {
+    # setfilename ignored in an included file
+    $current->{'line_nr'} = $line_nr if (!$current->{'line_nr'});
+    if ($command eq 'setfilename'
+        and scalar(@{$self->{'input'}}) > 1) {
+    } elsif (exists ($self->{'extra'}->{$current->{'cmdname'}})) {
+      $self->line_warn(sprintf($self->__('multiple @%s'), 
+                               $current->{'cmdname'}), $line_nr); 
+    } else {
+      $self->{'extra'}->{$current->{'cmdname'}} = $current
+                     unless (_ignore_global_commands($self));
+    }
+    return 1;
+  }
+  return 0;
+}
+
+# parse a @macro line
+sub _parse_macro_command_line($$$$$;$)
+{
+  my $self = shift;
+  my $command = shift;
+  my $line = shift;
+  my $parent = shift;
+  my $line_nr = shift;
+  my $macro = { 'cmdname' => $command, 'parent' => $parent, 'contents' => [],
+               'extra' => {'arg_line' => $line}, 'line_nr' => $line_nr };
+  # REMACRO
+  if ($line =~ /^\s+([[:alnum:]][[:alnum:]-]*)\s*(.*)/) {
+    my $macro_name = $1;
+    my $args_def = $2;
+    my @args;
+
+    if ($args_def =~ s/^\s*{\s*(.*?)\s*}\s*//) {
+      @args = split(/\s*,\s*/, $1);
+    }
+ 
+    # accept an @-command after the arguments in case there is a @c or
+    # @comment
+    if ($args_def =~ /^\s*[^\@]/) {
+      $self->line_error(sprintf($self->__("bad syntax for \@%s argument: %s"), 
+                                 $command, $args_def),
+                        $line_nr);
+      $macro->{'extra'}->{'invalid_syntax'} = 1;
+    }
+    print STDERR "MACRO \@$command $macro_name\n" if ($self->{'DEBUG'});
+
+    $macro->{'args'} = [ 
+      { 'type' => 'macro_name', 'text' => $macro_name, 
+          'parent' => $macro } ];
+    my $index = 0;
+    foreach my $formal_arg (@args) {
+      push @{$macro->{'args'}}, 
+        { 'type' => 'macro_arg', 'text' => $formal_arg, 
+          'parent' => $macro};
+      if ($formal_arg !~ /^[\w\-]+$/) {
+        $self->line_error(sprintf($self->__("bad or empty \@%s formal argument: %s"),
+                                           $command, $formal_arg), $line_nr);
+        $macro->{'extra'}->{'invalid_syntax'} = 1;
+      }
+      $macro->{'extra'}->{'args_index'}->{$formal_arg} = $index;
+      $index++;
+    }
+  } elsif ($line !~ /\S/) {
+    $self->line_error(sprintf($self->
+                    __("%c%s requires a name"), ord('@'), $command), $line_nr);
+    $macro->{'extra'}->{'invalid_syntax'} = 1;
+  } else {
+    $self->line_error(sprintf($self->
+                    __("bad name for \@%s"), $command), $line_nr);
+    $macro->{'extra'}->{'invalid_syntax'} = 1;
+  }
+  return $macro;
+}
+
+# start a paragraph if in a context where paragraphs are to be started.
+sub _begin_paragraph($$;$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+
+  if ((!$current->{'type'} or $type_with_paragraph{$current->{'type'}})
+      and !$no_paragraph_contexts{$self->{'context_stack'}->[-1]}) {
+    if (!defined($current->{'contents'})) {
+      $self->_bug_message("contents undef", $line_nr, $current);
+      die;
+    }
+
+    # find whether an @indent precedes the paragraph
+    my $indent;
+    if (scalar(@{$current->{'contents'}})) {
+      my $index = scalar(@{$current->{'contents'}}) -1;
+      while ($index >= 0
+            and !($current->{'contents'}->[$index]->{'type'} 
+              and ($current->{'contents'}->[$index]->{'type'} eq 'empty_line'
+                   or $current->{'contents'}->[$index]->{'type'} eq 'paragraph'))
+            and !($current->{'contents'}->[$index]->{'cmdname'}
+                  and $self->{'close_paragraph_commands'}->{$current->{'contents'}->[$index]->{'cmdname'}})) {
+        if ($current->{'contents'}->[$index]->{'cmdname'}
+          and ($current->{'contents'}->[$index]->{'cmdname'} eq 'indent'
+              or $current->{'contents'}->[$index]->{'cmdname'} eq 'noindent')) {
+          $indent = $current->{'contents'}->[$index]->{'cmdname'};
+          last;
+        }
+        $index--;
+      }
+    }
+    push @{$current->{'contents'}}, 
+            { 'type' => 'paragraph', 'parent' => $current, 'contents' => [] };
+    $current->{'contents'}->[-1]->{'extra'}->{$indent} = 1 if ($indent);
+    $current = $current->{'contents'}->[-1];
+    print STDERR "PARAGRAPH\n" if ($self->{'DEBUG'});
+    return $current;
+  }
+  return 0;
+}
+
+sub _begin_preformatted($)
+{
+  my $self = shift;
+  my $current = shift;
+  if ($preformatted_contexts{$self->{'context_stack'}->[-1]}) {
+    push @{$current->{'contents'}}, 
+          { 'type' => $self->{'context_stack'}->[-1], 
+            'parent' => $current, 'contents' => [] };
+    $current = $current->{'contents'}->[-1];
+    print STDERR "PREFORMATTED $self->{'context_stack'}->[-1]\n" if ($self->{'DEBUG'});
+  }
+  return $current;
+}
+
+# wrapper around line_warn.  Set line_nr to be the line_nr of the command,
+# corresponding to the opening of the command.  Call line_warn with
+# sprintf if needed.
+sub _command_warn($$$$;@)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $message = shift;
+
+  if ($current->{'line_nr'}) {
+    $line_nr = $current->{'line_nr'};
+  }
+  if (@_) {
+    $self->line_warn(sprintf($message, @_), $line_nr);
+  } else {
+    $self->line_warn($message, $line_nr);
+  }
+}
+
+sub _command_error($$$$;@)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $message = shift;
+
+  # use the beginning of the @-command for the error message
+  # line number if available. 
+  # FIXME line_nr currently not registered for regular brace commands
+  if ($current->{'line_nr'}) {
+    $line_nr = $current->{'line_nr'};
+  }
+  if (@_) {
+    $self->line_error(sprintf($message, @_), $line_nr);
+  } else {
+    $self->line_error($message, $line_nr);
+  }
+}
+
+# currently doesn't do much more than
+# return $_[1]->{'parent'}
+sub _close_brace_command($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;
+
+  if ($current->{'cmdname'} ne 'verb' or $current->{'type'} eq '') {
+    if (defined($closed_command)) {
+      $self->_command_error($current, $line_nr,
+        $self->__("\@end %s seen before \@%s closing brace"), 
+                  $closed_command, $current->{'cmdname'});
+    } elsif (defined($interrupting_command)) {
+      $self->_command_error($current, $line_nr,
+        $self->__("\@%s seen before \@%s closing brace"), 
+                  $interrupting_command, $current->{'cmdname'});
+                                                       
+    } else {
+      $self->_command_error($current, $line_nr, 
+        $self->__("%c%s missing close brace"), ord('@'), $current->{'cmdname'});
+    }
+  } else {
+    $self->_command_error($current, $line_nr,
+       $self->__("\@%s missing closing delimiter sequence: %s}"),
+       $current->{'cmdname'}, $current->{'type'});
+  }
+  $current = $current->{'parent'};
+  return $current;
+}
+
+sub _in_code($$)
+{
+  my $self = shift;
+  my $current = shift;
+
+  while ($current->{'parent'} and $current->{'parent'}->{'cmdname'}
+          and exists $brace_commands{$current->{'parent'}->{'cmdname'}}
+          and !exists $context_brace_commands{$current->{'parent'}->{'cmdname'}}) {
+    return 1 if ($code_style_commands{$current->{'parent'}->{'cmdname'}});
+    $current = $current->{'parent'}->{'parent'};
+  }
+  return 0;
+}
+
+# close brace commands, that don't set a new context (ie @caption, @footnote)
+sub _close_all_style_commands($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;
+
+  while ($current->{'parent'} and $current->{'parent'}->{'cmdname'}
+          and exists $brace_commands{$current->{'parent'}->{'cmdname'}}
+          and !exists $context_brace_commands{$current->{'parent'}->{'cmdname'}}) {
+    $current = _close_brace_command($self, $current->{'parent'}, $line_nr,
+                                    $closed_command, $interrupting_command);
+  }
+  return $current;
+}
+
+# close brace commands except for @caption, @footnote then the paragraph
+sub _end_paragraph($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;
+
+  $current = _close_all_style_commands($self, $current, $line_nr, 
+                                       $closed_command, $interrupting_command);
+  if ($current->{'type'} and $current->{'type'} eq 'paragraph') {
+    print STDERR "CLOSE PARA\n" if ($self->{'DEBUG'});
+    $current = $current->{'parent'};
+  } 
+  return $current;
+}
+
+# close brace commands except for @caption, @footnote then the preformatted
+sub _end_preformatted($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;
+
+  $current = _close_all_style_commands($self, $current, $line_nr,
+                                       $closed_command, $interrupting_command);
+  if ($current->{'type'} and $preformatted_contexts{$current->{'type'}}) {
+    print STDERR "CLOSE PREFORMATTED $current->{'type'}\n" if ($self->{'DEBUG'});
+    # completly remove void preformatted contexts
+    if (!@{$current->{'contents'}}) {
+      my $removed = pop @{$current->{'parent'}->{'contents'}};
+      print STDERR "popping $removed->{'type'}\n" if ($self->{'DEBUG'});
+    }
+    $current = $current->{'parent'};
+  }
+  return $current;
+}
+
+# check that there are no text holding environment (currently
+# checking only paragraphs and preformatted) in contents
+sub _check_no_text($)
+{
+  my $current = shift;
+  my $after_paragraph = 0;
+  foreach my $content (@{$current->{'contents'}}) {
+    if ($content->{'type'} and $content->{'type'} eq 'paragraph') {
+      $after_paragraph = 1;
+      last;
+    } elsif ($content->{'type'} and $preformatted_contexts{$content->{'type'}}) {
+      foreach my $preformatted_content (@{$content->{'contents'}}) {
+        if ((defined($preformatted_content->{'text'}) 
+             and $preformatted_content->{'text'} =~ /\S/)
+            or ($preformatted_content->{'cmdname'} 
+                and ($preformatted_content->{'cmdname'} ne 'c'
+                     and $preformatted_content->{'cmdname'} ne 'comment')
+                and !($preformatted_content->{'type'} 
+                      and $preformatted_content->{'type'} eq 'index_entry_command'))) {
+          $after_paragraph = 1;
+          last;
+        }
+      }
+      last if ($after_paragraph);
+    }
+  }
+  return $after_paragraph;
+}
+
+# put everything after the last @item/@itemx in an item_table type container
+# and distinguish table_term and table_entry.
+sub _gather_previous_item($$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $next_command = shift;
+  my $line_nr = shift;
+
+  # nothing to do in that case.
+  if ($current->{'contents'}->[-1]->{'type'}
+      and $current->{'contents'}->[-1]->{'type'} eq 'before_item') {
+    if ($next_command and $next_command eq 'itemx') {
+      $self->line_warn(sprintf($self->__("\@itemx should not begin \@%s"), 
+                                $current->{'cmdname'}), $line_nr);
+    }
+    return;
+  }
+  #print STDERR "GATHER "._print_current($current)."\n";
+  my $type;
+  # if before an itemx, the type is different since there should not be 
+  # real content, so it may be treated differently
+  if ($next_command and $next_command eq 'itemx') {
+    $type = 'inter_item';
+  } else {
+    $type = 'table_item';
+  }
+  my $table_gathered = {'type' => $type,
+                       'contents' => []};
+  # remove everything that is not an @item/@items or before_item to 
+  # put it in the table_item, starting from the end.
+  my $contents_count = scalar(@{$current->{'contents'}});
+  for (my $i = 0; $i < $contents_count; $i++) {
+    #print STDERR "_gather_previous_item $i on $contents_count: "._print_current($current->{'contents'}->[-1])."\n";
+    if ($current->{'contents'}->[-1]->{'cmdname'} 
+        and ($current->{'contents'}->[-1]->{'cmdname'} eq 'item' 
+             or ($current->{'contents'}->[-1]->{'cmdname'} eq 'itemx'))) {
+      last;
+    } else {
+      my $item_content = pop @{$current->{'contents'}};
+      $item_content->{'parent'} = $table_gathered;
+      unshift @{$table_gathered->{'contents'}}, $item_content;
+    }
+  }
+  if ($type eq 'table_item') {
+    my $table_entry = {'type' => 'table_entry',
+                    'parent' => $current,
+                    'contents' => []};
+    my $table_term = {'type' => 'table_term',
+                    'parent' => $table_entry,
+                    'contents' => []};
+    push @{$table_entry->{'contents'}}, $table_term;
+    my $contents_count = scalar(@{$current->{'contents'}});
+    for (my $i = 0; $i < $contents_count; $i++) {
+      if ($current->{'contents'}->[-1]->{'type'} 
+           and ($current->{'contents'}->[-1]->{'type'} eq 'before_item'
+                or $current->{'contents'}->[-1]->{'type'} eq 'table_entry')) {
+        last;
+      } else {
+        my $item_content = pop @{$current->{'contents'}};
+        $item_content->{'parent'} = $table_term;
+        unshift @{$table_term->{'contents'}}, $item_content;
+        # debug
+        if (! (($item_content->{'cmdname'} 
+                and ($item_content->{'cmdname'} eq 'itemx'
+                    or $item_content->{'cmdname'} eq 'item'))
+               or ($item_content->{'type'} 
+                   and $item_content->{'type'} eq 'inter_item'))) {
+          $self->_bug_message("wrong element in table term", $line_nr, 
+                              $item_content);
+        }
+      }
+    }
+    push @{$current->{'contents'}}, $table_entry;
+    if (scalar(@{$table_gathered->{'contents'}})) {
+      push @{$table_entry->{'contents'}}, $table_gathered;
+      $table_gathered->{'parent'} = $table_entry;
+    }
+  } else {
+    my $after_paragraph = _check_no_text($table_gathered);
+    if ($after_paragraph) {
+      $self->line_error($self->__("\@itemx must follow \@item"), $line_nr);
+    }
+    if (scalar(@{$table_gathered->{'contents'}})) {
+      push @{$current->{'contents'}}, $table_gathered;
+      $table_gathered->{'parent'} = $current;
+    }
+  }
+}
+
+# Starting from the end, gather everything util the def_line to put in 
+# a def_item
+sub _gather_def_item($;$)
+{
+  my $current = shift;
+  my $next_command = shift;
+  my $type;
+  # means that we are between a @def*x and a @def
+  if ($next_command) {
+    $type = 'inter_def_item';
+  } else {
+    $type = 'def_item';
+  }
+
+  # This may happen for a construct like
+  # @deffnx a b @section
+  # but otherwise the end of line will lead to the command closing
+  return if (!$current->{'cmdname'} or $current->{'cmdname'} =~ /x$/);
+  #print STDERR "_gather_def_item($type) in "._print_current($current)."\n";
+  my $def_item = {'type' => $type,
+                  'parent' => $current,
+                  'contents' => []};
+  # remove everything that is not a def_line to put it in the def_item,
+  # starting from the end.
+  my $contents_count = scalar(@{$current->{'contents'}});
+  for (my $i = 0; $i < $contents_count; $i++) {
+    #print STDERR "_gather_def_item $type ($i on $contents_count) "._print_current($current->{'contents'}->[-1])."\n";
+    if ($current->{'contents'}->[-1]->{'type'} 
+        and $current->{'contents'}->[-1]->{'type'} eq 'def_line') {
+     #   and !$current->{'contents'}->[-1]->{'extra'}->{'not_after_command'}) {
+      last;
+    } else {
+      my $item_content = pop @{$current->{'contents'}};
+      $item_content->{'parent'} = $def_item;
+      unshift @{$def_item->{'contents'}}, $item_content;
+    }
+  }
+  if (scalar(@{$def_item->{'contents'}})) {
+    push @{$current->{'contents'}}, $def_item;
+  }
+}
+
+# close formats
+sub _close_command_cleanup($$$) {
+  my $self = shift;
+  my $current = shift;
+
+  return unless ($current->{'cmdname'});
+  # remove the dynamic counters in multitable, they are not of use in the final
+  # tree.  Also determine the multitable_body and multitable_head with 
+  # @item or @headitem rows.
+  if ($current->{'cmdname'} eq 'multitable') {
+    my $in_head_or_rows;
+    my @contents = @{$current->{'contents'}};
+    $current->{'contents'} = [];
+    foreach my $row (@contents) {
+      if ($row->{'type'} and $row->{'type'} eq 'row') {
+        delete $row->{'cells_count'};
+        if ($row->{'contents'}->[0]->{'cmdname'} eq 'headitem') {
+          if (!$in_head_or_rows) {
+            push @{$current->{'contents'}}, {'type' => 'multitable_head',
+                                             'parent' => $current};
+            $in_head_or_rows = 1;
+          }
+        } elsif ($row->{'contents'}->[0]->{'cmdname'} eq 'item') {
+          if (!defined($in_head_or_rows) or $in_head_or_rows) {
+            push @{$current->{'contents'}}, {'type' => 'multitable_body',
+                                             'parent' => $current};
+            $in_head_or_rows = 0;
+          }
+        }
+        push @{$current->{'contents'}->[-1]->{'contents'}}, $row;
+        $row->{'parent'} = $current->{'contents'}->[-1];
+      } else {
+        push @{$current->{'contents'}}, $row;
+        $in_head_or_rows = undef;
+      }
+    }
+    delete $current->{'rows_count'};
+  } elsif ($item_container_commands{$current->{'cmdname'}}) {
+    delete $current->{'items_count'};
+  }
+
+  # put everything after the last @def*x command in a def_item type container.
+  if ($def_commands{$current->{'cmdname'}}) {
+    # At this point the end command hasn't been added to the command contents.
+    # so checks cannot be done at this point.
+    _gather_def_item($current);
+  }
+
+  if ($item_line_commands{$current->{'cmdname'}}) {
+    # At this point the end command hasn't been added to the command contents.
+    # so checks cannot be done at this point.
+    if (@{$current->{'contents'}}) {
+      $self->_gather_previous_item($current);
+    }
+  }
+  
+  # put end out of before_item, and replace it at the end of the parent.
+  # remove empty before_item.
+  # warn if not empty before_item, but format is empty
+  if ($block_item_commands{$current->{'cmdname'}}) {
+    if (@{$current->{'contents'}}) {
+      my $leading_spaces = 0;
+      my $before_item;
+      if ($current->{'contents'}->[0]->{'type'}
+          and $current->{'contents'}->[0]->{'type'} eq 'empty_line_after_command'
+          and $current->{'contents'}->[1]
+          and $current->{'contents'}->[1]->{'type'}
+          and $current->{'contents'}->[1]->{'type'} eq 'before_item') {
+        $leading_spaces = 1;
+        $before_item = $current->{'contents'}->[1];
+      } elsif ($current->{'contents'}->[0]->{'type'} 
+              and $current->{'contents'}->[0]->{'type'} eq 'before_item') {
+        $before_item = $current->{'contents'}->[0];
+      }
+      if ($before_item) {
+        if ($current->{'extra'}->{'end_command'}
+            and @{$before_item->{'contents'}} 
+            and $before_item->{'contents'}->[-1] eq $current->{'extra'}->{'end_command'}) {
+          my $end = pop @{$before_item->{'contents'}};
+          $end->{'parent'} = $current;
+          push @{$current->{'contents'}}, $end;
+        }
+        # remove empty before_items
+        if (!@{$before_item->{'contents'}}) {
+          if ($leading_spaces) {
+            my $space = shift @{$current->{'contents'}};
+            shift @{$current->{'contents'}};
+            unshift @{$current->{'contents'}}, $space;
+          } else {
+            shift @{$current->{'contents'}};
+          }
+        } else {
+          # warn if not empty before_item, but format is empty
+          my $empty_before_item = 1;
+          foreach my $before_item_content (@{$before_item->{'contents'}}) {
+            if (!$before_item_content->{'cmdname'} or 
+                  ($before_item_content->{'cmdname'} ne 'c' 
+                   and $before_item_content->{'cmdname'} ne 'comment')) {
+              $empty_before_item = 0;
+              last;
+            }
+          }
+          if (!$empty_before_item) {
+            my $empty_format = 1;
+            foreach my $format_content (@{$current->{'contents'}}) {
+              next if ($format_content eq $before_item);
+              if (($format_content->{'cmdname'} and 
+                   ($format_content->{'cmdname'} ne 'c'
+                    and $format_content->{'cmdname'} ne 'comment'
+                    and $format_content->{'cmdname'} ne 'end'))
+                  or ($format_content->{'type'} and
+                    ($format_content->{'type'} ne 'empty_line_after_command'))) {
+                $empty_format = 0;
+                last;
+              }
+            }
+            if ($empty_format) {
+              $self->line_warn(sprintf($self->__("\@%s has text but no \@item"),
+                                        $current->{'cmdname'}), $current->{'line_nr'});                       
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+# close the current command, with error messages and give the parent.
+# If the last argument is given it is the command being closed if
+# hadn't there be an error, currently only block command, used for a
+# better error message.
+sub _close_current($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;
+
+  if ($current->{'cmdname'}) {
+    print STDERR "CLOSING(_close_current) \@$current->{'cmdname'}\n" if ($self->{'DEBUG'});
+    if (exists($brace_commands{$current->{'cmdname'}})) {
+      pop @{$self->{'context_stack'}}
+         if (exists $context_brace_commands{$current->{'cmdname'}});
+      $current = _close_brace_command($self, $current, $line_nr, 
+                                      $closed_command, $interrupting_command);
+    } elsif (exists($block_commands{$current->{'cmdname'}})) {
+      if (defined($closed_command)) {
+        $self->line_error(sprintf($self->__("`\@end' expected `%s', but saw `%s'"),
+                                   $current->{'cmdname'}, $closed_command), $line_nr);
+      } elsif ($interrupting_command) {
+        $self->line_error(sprintf($self->__("\@%s seen before \@end %s"),
+                                  $interrupting_command, $current->{'cmdname'}),
+                          $line_nr);
+      } else {
+        $self->line_error(sprintf($self->__("no matching `%cend %s'"),
+                                   ord('@'), $current->{'cmdname'}), $line_nr);
+        if ($block_commands{$current->{'cmdname'}} eq 'conditional') {
+          # in this case we are within an ignored conditional
+          my $conditional = pop @{$current->{'parent'}->{'contents'}};
+        }
+      }
+      if ($preformatted_commands{$current->{'cmdname'}}
+          or $menu_commands{$current->{'cmdname'}}
+          or $format_raw_commands{$current->{'cmdname'}}) {
+        my $context = pop @{$self->{'context_stack'}};
+        pop @{$self->{'raw_formats_stack'}} 
+          if ($format_raw_commands{$current->{'cmdname'}});
+      }
+      pop @{$self->{'regions_stack'}} 
+         if ($region_commands{$current->{'cmdname'}});
+      $current = $current->{'parent'};
+    } else {
+      # There @item and @tab commands are closed, and also line commands
+      # with invalid content
+      $current = $current->{'parent'};
+    }
+  } elsif ($current->{'type'}) {
+    print STDERR "CLOSING type $current->{'type'}\n" if ($self->{'DEBUG'});
+    if ($current->{'type'} eq 'bracketed') {
+      $self->_command_error($current, $line_nr, 
+                            $self->__("misplaced %c"), ord('{'));
+    } elsif ($current->{'type'} eq 'menu_comment' 
+          or $current->{'type'} eq 'menu_entry_description') {
+      my $context = pop @{$self->{'context_stack'}};
+      if ($context ne 'preformatted') {
+        $self->_bug_message("context $context instead of preformatted", 
+                            $line_nr, $current);
+      }
+      # close empty menu_comment
+      if (!@{$current->{'contents'}}) {
+        pop @{$current->{'parent'}->{'contents'}};
+      }
+    } elsif ($current->{'type'} eq 'misc_line_arg'
+             or $current->{'type'} eq 'block_line_arg') {
+      my $context = pop @{$self->{'context_stack'}};
+      if ($context ne 'line' and $context ne 'def') {
+        $self->_bug_message("context $context instead of line or def", 
+                            $line_nr, $current);
+        die;
+      }
+    }
+    $current = $current->{'parent'};
+  } else { # Should never go here.
+    $current = $current->{'parent'} if ($current->{'parent'});
+    $self->_bug_message("No type nor cmdname when closing", 
+                        $line_nr, $current);
+  }
+  return $current;
+}
+
+# a closed_command arg means closing until that command is found.
+# no command arg means closing until the root or a root_command
+# is found.
+sub _close_commands($$$;$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $line_nr = shift;
+  my $closed_command = shift;
+  my $interrupting_command = shift;;
+
+  $current = _end_paragraph($self, $current, $line_nr, $closed_command, 
+                            $interrupting_command);
+  $current = _end_preformatted($self, $current, $line_nr, $closed_command,
+                               $interrupting_command);
+
+        # stop if the command is found
+  while (!($closed_command and $current->{'cmdname'}
+           and $current->{'cmdname'} eq $closed_command) 
+         # stop if at the root
+         and $current->{'parent'}
+     # stop if in a root command 
+     # or in a context_brace_commands and searching for a specific 
+     # end block command (with $closed_command set).  
+     # This second condition means that a footnote is not closed when 
+     # looking for the end of a block command, but is closed when 
+     # completly closing the stack.
+         and !($current->{'cmdname'}
+               and ($root_commands{$current->{'cmdname'}}
+                    or ($closed_command and $current->{'parent'}->{'cmdname'}
+                       and $context_brace_commands{$current->{'parent'}->{'cmdname'}})))){
+    $self->_close_command_cleanup($current);
+    $current = $self->_close_current($current, $line_nr, $closed_command, 
+                                     $interrupting_command);
+  }
+
+  my $closed_element;
+  if ($closed_command and $current->{'cmdname'} 
+      and $current->{'cmdname'} eq $closed_command) {
+    if ($preformatted_commands{$current->{'cmdname'}}) {
+      my $context = pop @{$self->{'context_stack'}};
+      if ($context ne 'preformatted') {
+        $self->_bug_message("context $context instead of preformatted for $closed_command", 
+                            $line_nr, $current);
+      }
+    } elsif ($format_raw_commands{$current->{'cmdname'}}) {
+      my $context = pop @{$self->{'context_stack'}};
+      if ($context ne 'rawpreformatted') {
+        $self->_bug_message("context $context instead of rawpreformatted for $closed_command", 
+                            $line_nr, $current);
+      }
+      pop @{$self->{'raw_formats_stack'}};
+    } elsif ($menu_commands{$current->{'cmdname'}}) {
+      my $context = pop @{$self->{'context_stack'}};
+      # may be in menu, but context is preformatted if in a preformatted too.
+      if ($context ne 'menu' and $context ne 'preformatted') {
+        $self->_bug_message("context $context instead of preformatted or menu for $closed_command", 
+                            $line_nr, $current);
+      }
+    }
+    #print STDERR "close context $context for $current->{'cmdname'}\n"
+    #  if ($self->{'DEBUG'});
+    pop @{$self->{'regions_stack'}} 
+       if ($region_commands{$current->{'cmdname'}});
+    $closed_element = $current;
+    #$self->_close_command_cleanup($current);
+    $current = $current->{'parent'};
+  } elsif ($closed_command) {
+    $self->line_error(sprintf($self->__("unmatched `%c%s'"), 
+                       ord('@'), "end $closed_command"), $line_nr);
+  }
+  return ($closed_element, $current);
+}
+
+# begin paragraph if needed.  If not try to merge with the previous
+# content if it is also some text.
+sub _merge_text($$$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $text = shift;
+
+  my $paragraph;
+
+  my $no_merge_with_following_text = 0;
+  if ($text =~ /\S/) {
+    my $leading_spaces;
+    if ($text =~ /^(\s+)/) {
+      $leading_spaces = $1;
+    }
+    if ($current->{'contents'} and @{$current->{'contents'}}
+      and $current->{'contents'}->[-1]->{'type'}
+      and ($current->{'contents'}->[-1]->{'type'} eq 'empty_line_after_command'
+         or $current->{'contents'}->[-1]->{'type'} eq 'empty_spaces_before_argument'
+         or $current->{'contents'}->[-1]->{'type'} eq 'empty_spaces_after_close_brace')) {
+      $no_merge_with_following_text = 1;
+    }
+    if (_abort_empty_line($self, $current, $leading_spaces)) {
+      $text =~ s/^(\s+)//;
+    } 
+
+    $paragraph = _begin_paragraph($self, $current);
+    $current = $paragraph if ($paragraph);
+  }
+
+  if (!defined($current->{'contents'})) {
+    $self->_bug_message("No contents in _merge_text", 
+                            undef, $current);
+    die;
+  }
+
+  if (@{$current->{'contents'}} 
+      and exists($current->{'contents'}->[-1]->{'text'}) 
+      and $current->{'contents'}->[-1]->{'text'} !~ /\n/
+      and !$no_merge_with_following_text) {
+    $current->{'contents'}->[-1]->{'text'} .= $text;
+    print STDERR "MERGED TEXT: $text|||\n" if ($self->{'DEBUG'});
+  } else {
+    push @{$current->{'contents'}}, { 'text' => $text, 'parent' => $current };
+    print STDERR "NEW TEXT: $text|||\n" if ($self->{'DEBUG'});
+  }
+  return $current;
+}
+
+# return the parent if in a item_container command, itemize or enumerate
+sub _item_container_parent($)
+{
+  my $current = shift;
+  if ((($current->{'cmdname'} and $current->{'cmdname'} eq 'item')
+       or ($current->{'type'} and $current->{'type'} eq 'before_item'))
+      and ($current->{'parent'} and $current->{'parent'}->{'cmdname'}
+        and $item_container_commands{$current->{'parent'}->{'cmdname'}})) {
+    return ($current->{'parent'});
+  }
+  return undef;
+}
+
+# return the parent if in a item_line command, @*table
+sub _item_line_parent($)
+{
+  my $current = shift;
+  if ($current->{'cmdname'} and ($current->{'cmdname'} eq 'item'
+       or $current->{'cmdname'} eq 'itemx')) {
+      $current = $current->{'parent'}->{'parent'};
+  } elsif ($current->{'type'} and $current->{'type'} eq 'before_item'
+            and $current->{'parent'}) {
+    $current = $current->{'parent'};
+  }
+  return $current if ($current->{'cmdname'} 
+                       and $item_line_commands{$current->{'cmdname'}});
+  return undef;
+}
+
+# return the parent if in a multitable
+sub _item_multitable_parent($)
+{
+  my $current = shift;
+  if (($current->{'cmdname'} and ($current->{'cmdname'} eq 'headitem'
+       or $current->{'cmdname'} eq 'item' or $current->{'cmdname'} eq 'tab'))
+      and $current->{'parent'} and $current->{'parent'}->{'parent'}) {
+    $current = $current->{'parent'}->{'parent'};
+  } elsif ($current->{'type'} and $current->{'type'} eq 'before_item'
+            and $current->{'parent'}) {
+    $current = $current->{'parent'};
+  }
+  return $current if ($current->{'cmdname'} 
+                       and $current->{'cmdname'} eq 'multitable');
+  return undef;
+}
+
+# returns next text fragment, be it pending from a macro expansion or 
+# text or file
+sub _next_text($$$)
+{
+  my $self = shift;
+  my $line_nr = shift;
+  my $current = shift;
+ 
+  while (@{$self->{'input'}}) {
+    my $input = $self->{'input'}->[0];
+    if (@{$input->{'pending'}}) {
+      my $new_text = shift @{$input->{'pending'}};
+      if ($new_text->[1] and $new_text->[1]->{'end_macro'}) {
+        delete $new_text->[1]->{'end_macro'};
+        my $top_macro = shift @{$self->{'macro_stack'}};
+        print STDERR "SHIFT MACRO_STACK(@{$self->{'macro_stack'}}): $top_macro->{'args'}->[0]->{'text'}\n"
+          if ($self->{'DEBUG'});
+      }
+      return ($new_text->[0], $new_text->[1]);
+    } elsif ($input->{'fh'}) {
+      my $fh = $input->{'fh'};
+      my $line = <$fh>;
+      while (defined($line)) {
+        $line =~ s/\x{7F}.*\s*//;
+        if ($self->{'CPP_LINE_DIRECTIVES'}
+            # no cpp directives in ignored/macro/verbatim
+            and defined ($current)
+            and not 
+             (($current->{'cmdname'}
+              and $block_commands{$current->{'cmdname'}}
+               and ($block_commands{$current->{'cmdname'}} eq 'raw'
+                    or $block_commands{$current->{'cmdname'}} eq 'conditional'))
+             or 
+              ($current->{'parent'} and $current->{'parent'}->{'cmdname'}
+               and $current->{'parent'}->{'cmdname'} eq 'verb')
+             )
+            and $line =~ /^\s*#\s*(line)? (\d+)(( "([^"]+)")(\s+\d+)*)?\s*$/) {
+          $input->{'line_nr'} = $2;
+          if (defined($5)) {
+            $input->{'name'} = $5;
+          }
+          $line = <$fh>;
+        } else {
+          $input->{'line_nr'}++;
+          return ($line, {'line_nr' => $input->{'line_nr'}, 
+                          'file_name' => $input->{'name'},
+                          'macro' => ''});
+        }
+      }
+    }
+    my $previous_input = shift(@{$self->{'input'}});
+    # Don't close STDIN
+    if ($previous_input->{'fh'} and $previous_input->{'name'} ne '-') {
+      if (!close($previous_input->{'fh'})) {
+        $self->document_warn(sprintf($self->__("error on closing %s: %s"),
+                                     $previous_input->{'name'}, $!));
+
+      }
+    }
+  }
+
+  return (undef, $line_nr);
+}
+
+# collect text and line numbers until an end of line is found.
+sub _new_line($$$)
+{
+  my $self = shift;
+  my $line_nr = shift;
+  my $current = shift;
+  my $new_line = '';
+
+  while (1) {
+    my $new_text;
+    ($new_text, $line_nr) = _next_text($self, $line_nr, $current);
+    if (!defined($new_text)) {
+      $new_line = undef if ($new_line eq '');
+      last;
+    }
+
+    $new_line .= $new_text;
+
+    my $chomped_text = $new_text;
+    last if chomp($chomped_text);
+  }
+  return ($new_line, $line_nr);
+}
+
+sub _expand_macro_arguments($$$$)
+{
+  my $self = shift;
+  my $macro = shift;
+  my $line = shift;
+  my $line_nr = shift;
+  my $braces_level = 1;
+  my $arguments = [ '' ];
+  my $arg_nr = 0;
+  my $args_total = scalar(@{$macro->{'args'}}) -1;
+  my $name = $macro->{'args'}->[0]->{'text'};
+
+  my $line_nr_orig = $line_nr;
+
+  while (1) {
+    if ($line =~ s/([^\\{},]*)([\\{},])//) {
+      my $separator = $2;
+      $arguments->[-1] .= $1;
+      if ($separator eq '\\') {
+        if ($line =~ s/^(.)//) {
+          my $protected_char = $1;
+          if ($protected_char !~ /[\\{},]/) {
+            $arguments->[-1] .= '\\';
+          }
+          $arguments->[-1] .= $protected_char;
+          
+          print STDERR "MACRO ARG: $separator: $protected_char\n" if ($self->{'DEBUG'});
+        } else {
+          $arguments->[-1] .= '\\';
+          print STDERR "MACRO ARG: $separator\n" if ($self->{'DEBUG'});
+        }
+      } elsif ($separator eq ',') {
+        if ($braces_level == 1) {
+          if (scalar(@$arguments) < $args_total) {
+            push @$arguments, '';
+            $line =~ s/^\s*//;
+            print STDERR "MACRO NEW ARG\n" if ($self->{'DEBUG'});
+          } else {
+            # implicit quoting when there is one argument.
+            if ($args_total != 1) {
+              $self->line_error(sprintf($self->__(
+                                     "macro `%s' called with too many args"), 
+                                        $name), $line_nr);
+            }
+            $arguments->[-1] .= ',';
+          }
+        } else {
+          $arguments->[-1] .= ',';
+        }
+      } elsif ($separator eq '}') {
+        $braces_level--;
+        last if ($braces_level == 0);
+        $arguments->[-1] .= $separator;
+      } elsif ($separator eq '{') {
+        $braces_level++;
+        $arguments->[-1] .= $separator;
+      }
+    } else {
+      print STDERR "MACRO ARG end of line\n" if ($self->{'DEBUG'});
+      $arguments->[-1] .= $line;
+
+      ($line, $line_nr) = _new_line($self, $line_nr, $macro);
+      if (!defined($line)) {
+        $self->line_error(sprintf($self->__("\@%s missing close brace"), 
+           $name), $line_nr_orig);
+        return ($arguments, "\n", $line_nr);
+      }
+    }
+  }
+  if ($args_total == 0 and $arguments->[0] =~ /\S/) {
+    $self->line_error(sprintf($self->__(
+               "macro `%s' declared without argument called with an argument"), 
+                                $name), $line_nr);
+  }
+  print STDERR "END MACRO ARGS EXPANSION(".scalar(@$arguments)."): ".
+                  join("|\n", @$arguments) ."|\n" if ($self->{'DEBUG'});
+  return ($arguments, $line, $line_nr);
+}
+
+sub _expand_macro_body($$$$) {
+  my $self = shift;
+  my $macro = shift;
+  my $args = shift;
+  my $line_nr = shift;
+
+  my $macrobody = $macro->{'extra'}->{'macrobody'};
+  my $args_total = scalar(@{$macro->{'args'}}) -1;
+  my $args_index = $macro->{'extra'}->{'args_index'};
+
+  my $i;
+  for ($i=0; $i<=$args_total; $i++) {
+    $args->[$i] = "" unless (defined($args->[$i]));
+  }
+
+  my $result = '';
+  while ($macrobody ne '') {
+    if ($macrobody =~ s/^([^\\]*)\\//o) {
+      $result .= $1;
+      if ($macrobody =~ s/^\\//) {
+        $result .= '\\';
+      } elsif ($macrobody =~ s/^([^\\]*)\\//) {
+        my $arg = $1;
+        if (defined($args_index->{$arg})) {
+          $result .= $args->[$args_index->{$arg}];
+        } else {
+          $self->line_error(sprintf($self->__(
+         "\\ in \@%s expansion followed `%s' instead of parameter name or \\"), 
+                             $macro->{'args'}->[0]->{'text'}, $arg), $line_nr);
+          $result .= '\\' . $arg;
+        }
+      }
+      next;
+    }
+    $result .= $macrobody;
+    last;
+  }
+  return $result;
+}
+
+# each time a new line appeared, a container is opened to hold the text
+# consisting only of spaces.  This container is removed here, typically
+# this is called when non-space happens on a line.
+sub _abort_empty_line($$;$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $additional_text = shift;
+  $additional_text = '' if (!defined($additional_text));
+  if ($current->{'contents'} and @{$current->{'contents'}} 
+       and $current->{'contents'}->[-1]->{'type'}
+       and ($current->{'contents'}->[-1]->{'type'} eq 'empty_line' 
+           or $current->{'contents'}->[-1]->{'type'} eq 'empty_line_after_command'
+           or $current->{'contents'}->[-1]->{'type'} eq 'empty_spaces_before_argument'
+           or $current->{'contents'}->[-1]->{'type'} eq 'empty_spaces_after_close_brace')) {
+    print STDERR "ABORT EMPTY additional text |$additional_text|, current |$current->{'contents'}->[-1]->{'text'}|\n" if ($self->{'DEBUG'});
+    $current->{'contents'}->[-1]->{'text'} .= $additional_text;
+    if ($current->{'contents'}->[-1]->{'text'} eq '') {
+      if ($current->{'extra'} 
+          and $current->{'extra'}->{'spaces_before_argument'}
+          and $current->{'extra'}->{'spaces_before_argument'} 
+                eq $current->{'contents'}->[-1]) {
+        delete ($current->{'extra'}->{'spaces_before_argument'});
+        delete ($current->{'extra'}) if !(keys(%{$current->{'extra'}}));
+      }
+      pop @{$current->{'contents'}} 
+    } elsif ($current->{'contents'}->[-1]->{'type'} eq 'empty_line') {
+      # exactly the same condition than to begin a paragraph
+      if ((!$current->{'type'} or $type_with_paragraph{$current->{'type'}})
+         and !$no_paragraph_contexts{$self->{'context_stack'}->[-1]}) {
+        $current->{'contents'}->[-1]->{'type'} = 'empty_spaces_before_paragraph';
+      } else { 
+        delete $current->{'contents'}->[-1]->{'type'};
+      }
+    } elsif ($current->{'contents'}->[-1]->{'type'} eq 'empty_line_after_command') {
+      $current->{'contents'}->[-1]->{'type'} = 'empty_spaces_after_command';
+    }
+    return 1;
+  }
+  return 0;
+}
+
+# isolate last space in a command to help expansion disregard unuseful spaces.
+sub _isolate_last_space($$;$)
+{
+  my $self = shift;
+  my $current = shift;
+  my $type = shift;
+  $type = 'spaces_at_end' if (!defined($type));
+  if ($current->{'contents'} and @{$current->{'contents'}}) {
+    my $index = -1;
+    $index = -2 
+      if (scalar(@{$current->{'contents'}}) > 1 
+        and $current->{'contents'}->[-1]->{'cmdname'}
+        and $self->{'misc_commands'}->{$current->{'contents'}->[-1]->{'cmdname'}});
+    if (defined($current->{'contents'}->[$index]->{'text'}) 
+        and !$current->{'contents'}->[$index]->{'type'}
+        and $current->{'contents'}->[$index]->{'text'} =~ /\s+$/) {
+      if ($current->{'contents'}->[$index]->{'text'} !~ /\S/) {
+        $current->{'contents'}->[$index]->{'type'} = $type;
+      } else {
+        $current->{'contents'}->[$index]->{'text'} =~ s/(\s+)$//;
+        my $spaces = $1;
+        my $new_spaces = { 'text' => $spaces, 'parent' => $current,
+                           'type' => $type };
+        if ($index == -1) {
+          push @{$current->{'contents'}}, $new_spaces;
+        } else {
+          splice (@{$current->{'contents'}}, $index+1, 0, $new_spaces);
+        }
+      }
+    }
+  }
+}
+
+# used to put a node name in error messages.
+sub _node_extra_to_texi($)
+{
+  my $node = shift;
+  my $result = '';
+  if ($node->{'manual_content'}) {
+    $result = '('.Texinfo::Convert::Texinfo::convert({'contents'
+                                     => $node->{'manual_content'}}) .')';
+  }
+  if ($node->{'node_content'}) {
+    $result .= Texinfo::Convert::Texinfo::convert ({'contents'
+                                          => $node->{'node_content'}});
+  }
+  return $result;
+}
+
+sub _find_end_brace($$)
+{
+  my $text = shift;
+  my $braces_count = shift;
+
+  my $before = '';
+  while ($braces_count > 0 and length($text)) {
+    if ($text =~ s/([^()]*)([()])//) {
+      $before .= $1.$2;
+      my $brace = $2;
+      if ($brace eq '(') {
+        $braces_count++;
+      } else {
+        $braces_count--;
+        if ($braces_count == 0) {
+          return ($before, $text, 0);
+        }
+      }
+    } else {
+      $before .= $text;
+      $text = '';
+    }
+  }
+  return ($before, undef, $braces_count);
+}
+
+# This only counts opening braces, and returns 0 once all the parentheses
+# are closed
+sub _count_opened_tree_braces($$);
+sub _count_opened_tree_braces($$)
+{
+  my $current = shift;
+  my $braces_count = shift;
+  if (defined($current->{'text'})) {
+    my ($before, $after);
+    ($before, $after, $braces_count) = _find_end_brace($current->{'text'},
+                                                          $braces_count);
+  }
+  if ($current->{'args'}) {
+    foreach my $arg (@{$current->{'args'}}) {
+      $braces_count = _count_opened_tree_braces($arg, $braces_count);
+      return $braces_count if ($braces_count == 0);
+    }
+  }
+  if ($current->{'contents'}) {
+    foreach my $content (@{$current->{'contents'}}) {
+      $braces_count = _count_opened_tree_braces($content, $braces_count);
+      return $braces_count if ($braces_count == 0);
+    }
+  }
+  return $braces_count;
+}
+
+# retrieve a leading manual name in parentheses, if there is one.
+sub _parse_node_manual($)
+{
+  my $node = shift;
+  my @contents = @{$node->{'contents'}};
+  _trim_spaces_comment_from_content(\@contents);
+
+  my $manual;
+  my $result;
+#print STDERR "RRR $contents[0] and $contents[0]->{'text'} \n";
+  if ($contents[0] and $contents[0]->{'text'} and $contents[0]->{'text'} =~ /^\(/) {
+    my $braces_count = 1;
+    if ($contents[0]->{'text'} !~ /^\($/) {
+      my $brace = shift @contents;
+      my $brace_text = $brace->{'text'};
+      $brace_text =~ s/^\(//;
+      unshift @contents, { 'text' => $brace_text, 'type' => $brace->{'type'},
+                           'parent' => $brace->{'parent'} } if $brace_text ne '';
+    } else {
+      shift @contents;
+    }
+    while(@contents) {
+      my $content = shift @contents;
+      if (!defined($content->{'text'}) or $content->{'text'} !~ /\)/) {
+        push @$manual, $content;
+        $braces_count = _count_opened_tree_braces($content, $braces_count);
+        # This is an error, braces were closed in a command
+        if ($braces_count == 0) {
+          last;
+        }
+      } else {
+        my ($before, $after);
+        ($before, $after, $braces_count) = _find_end_brace($content->{'text'},
+                                                              $braces_count);
+        if ($braces_count == 0) {
+          $before =~ s/\)$//;
+          push @$manual, { 'text' => $before, 'parent' => $content->{'parent'} }
+            if ($before ne '');
+          $after =~ s/^\s*//;
+          unshift @contents,  { 'text' => $after, 'parent' => $content->{'parent'} }
+            if ($after ne '');
+          last;
+        } else {
+          push @$manual, $content;
+        }
+      }
+    }
+    $result->{'manual_content'} = $manual if (defined($manual));
+  }
+  if (@contents) {
+    $result->{'node_content'} = \@contents;
+    $result->{'normalized'} =
+      Texinfo::Convert::NodeNameNormalization::normalize_node({'contents' => \@contents});
+  }
+  return $result;
+}
+
+sub _parse_float_type($)
+{
+  my $current = shift;
+  if (@{$current->{'args'}}) {
+    my @type_contents = @{$current->{'args'}->[0]->{'contents'}};
+    _trim_spaces_comment_from_content(\@type_contents);
+    if (@type_contents) {
+      my $normalized 
+        = Texinfo::Convert::NodeNameNormalization::normalize_node(
+                                               {'contents' => \@type_contents});
+      $current->{'extra'}->{'type'}->{'content'} = \@type_contents;
+      if ($normalized =~ /[^-]/) {
+        $current->{'extra'}->{'type'}->{'normalized'} = $normalized;
+        return 1;
+      }
+    }
+  }
+  $current->{'extra'}->{'type'}->{'normalized'} = '';
+  return 0;
+}
+
+# used for definition line parsing
+sub _next_bracketed_or_word($$)
+{
+  my $self = shift;
+  my $contents = shift;
+  return undef if (!scalar(@{$contents}));
+  my $spaces;
+  $spaces = shift @{$contents} if (defined($contents->[0]->{'text'}) and 
+                                     $contents->[0]->{'text'} !~ /\S/);
+  if (defined($spaces)) {
+    $spaces->{'type'} = 'spaces';
+    chomp $spaces->{'text'};
+    $spaces = undef if ($spaces->{'text'} eq '');
+  }
+  return ($spaces, undef) if (!scalar(@{$contents}));
+
+  #print STDERR "BEFORE PROCESSING ".Texinfo::Convert::Texinfo::convert({'contents' => $contents});
+  if ($contents->[0]->{'type'} and $contents->[0]->{'type'} eq 'bracketed') {
+    #print STDERR "Return bracketed\n";
+    my $bracketed = shift @{$contents};
+    $self->_isolate_last_space($bracketed, 'empty_space_at_end_def_bracketed');
+    my $bracketed_def_content = { 'contents' => $bracketed->{'contents'},
+                                  'parent' => $bracketed->{'parent'},
+                                  'type' => 'bracketed_def_content', };
+    if ($bracketed->{'extra'} and $bracketed->{'extra'}->{'spaces_before_argument'}) {
+      $bracketed_def_content->{'extra'}->{'spaces_before_argument'}
+        = $bracketed->{'extra'}->{'spaces_before_argument'};
+    }
+    return ($spaces, $bracketed_def_content);
+  } elsif ($contents->[0]->{'cmdname'}) {
+    #print STDERR "Return command $contents->[0]->{'cmdname'}\n";
+    return ($spaces, shift @{$contents});
+  } else {
+    #print STDERR "Process $contents->[0]->{'text'}\n";
+    $contents->[0]->{'text'} =~ s/^(\s*)//;
+    my $space_text = $1;
+    $spaces = {'text' => $space_text, 'type' => 'spaces'} if ($space_text);
+    $contents->[0]->{'text'} =~ s/^(\S+)//;
+    shift @{$contents} if ($contents->[0]->{'text'} eq '');
+    return ($spaces, {'text' => $1});
+  }
+}
+
+# definition line parsing
+sub _parse_def($$$)
+{
+  my $self = shift;
+  my $command = shift;
+  my $contents = shift;
+  
+  my @contents = @$contents;
+  shift @contents if ($contents[0] and $contents[0]->{'type'}
+                    and $contents[0]->{'type'} eq 'empty_spaces_after_command');
+  if ($def_aliases{$command}) {
+    my $real_command = $def_aliases{$command};
+    my $prepended = $def_map{$command}->{$real_command};
+    my @prepended_content;
+
+    my $text;
+    my $in_bracketed;
+    if ($prepended =~ /^\{/) {
+      $text = $prepended;
+      $text =~ s/\{([^\}]+)\}/$1/;
+      $in_bracketed = 1;
+    } else {
+      $text = $prepended;
+    }
+    my $tree = $self->gdt($text);
+    if ($in_bracketed or @{$tree->{'contents'}} > 1) {
+      my $bracketed = { 'type' => 'bracketed' };
+      $bracketed->{'contents'} = $tree->{'contents'};
+      foreach my $content (@{$tree->{'contents'}}) {
+        $content->{'parent'} = $bracketed;
+      }
+      @prepended_content = ($bracketed);
+    } else {
+      @prepended_content = (@{$tree->{'contents'}});
+    }
+    push @prepended_content, { 'text' => ' ' };
+
+    unshift @contents, @prepended_content;
+
+    $command = $def_aliases{$command};
+  }
+  foreach (my $i = 0; $i < scalar(@contents); $i++) {
+    # copy, to avoid changing the original
+    $contents[$i] = {'text' => $contents[$i]->{'text'}} 
+       if (defined($contents[$i]->{'text'}));
+  }
+  my @result;
+  my @args = @{$def_map{$command}};
+  my $arg_type;
+  # Even when $arg_type is not set, that is for def* that is not documented
+  # to take args, everything is as is arg_type was set to arg.
+  $arg_type = pop @args if ($args[-1] eq 'arg' or $args[-1] eq 'argtype');
+  foreach my $arg (@args) {
+    #print STDERR "$command $arg"._print_current($contents[0]);
+    #foreach my $content (@contents) {print STDERR " "._print_current($content)};
+    #print STDERR " contents ->".Texinfo::Convert::Texinfo::convert ({'contents' => \@contents});
+    my ($spaces, $next) = $self->_next_bracketed_or_word(\@contents);
+    last if (!defined($next));
+    #print STDERR "NEXT[$arg] ".Texinfo::Convert::Texinfo::convert($next)."\n";
+    push @result, ['spaces', $spaces] if (defined($spaces));
+    push @result, [$arg, $next];
+  }
+
+  my @args_results;
+  while (@contents) {
+    my ($spaces, $next) = $self->_next_bracketed_or_word(\@contents);
+    push @args_results, ['spaces', $spaces] if (defined($spaces));
+    last if (!defined($next));
+    if (defined($next->{'text'})) {
+      while (1) {
+        if ($next->{'text'} =~ s/^([^\[\](),]+)//) {
+          push @args_results, ['arg', {'text' => $1}];
+        } elsif ($next->{'text'} =~ s/^([\[\](),])//) {
+          push @args_results, ['delimiter', 
+                      {'text' => $1, 'type' => 'delimiter'}];
+        } else {
+          last;
+        }
+      }
+    } else {
+      push @args_results, [ 'arg', $next ];
+    }
+  }
+  if ($arg_type and $arg_type eq 'argtype') {
+    my $next_is_type = 1;
+    foreach my $arg(@args_results) {
+      if ($arg->[0] eq 'spaces') {
+      } elsif ($arg->[0] eq 'delimiter') {
+        $next_is_type = 1;