contrib/texinfo/makeinfo/xml.c

   1 /* xml.c -- xml output.
   2    $Id: xml.c,v 1.52 2004/12/19 17:02:23 karl Exp $
   3
   4    Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    Originally written by Philippe Martin <feloy@free.fr>.  */
  21
  22 #include "system.h"
  23 #include "makeinfo.h"
  24 #include "insertion.h"
  25 #include "files.h"
  26 #include "float.h"
  27 #include "macro.h"
  28 #include "cmds.h"
  29 #include "lang.h"
  30
  31 #include "xml.h"
  32
  33 /* Options */
  34 int xml_index_divisions = 1;
  35
  36 typedef struct _element
  37 {
  38   char name[32];
  39   int contains_para;
  40   int contained_in_para;
  41   int keep_space;
  42 } element;
  43
  44 element texinfoml_element_list [] = {
  45   { "texinfo",             1, 0, 0 },
  46   { "setfilename",         0, 0, 0 },
  47   { "titlefont",           0, 0, 0 },
  48   { "settitle",            0, 0, 0 },
  49   { "documentdescription", 1, 0, 0 },
  50
  51   { "node",                1, 0, 0 },
  52   { "nodenext",            0, 0, 0 },
  53   { "nodeprev",            0, 0, 0 },
  54   { "nodeup",              0, 0, 0 },
  55
  56   { "chapter",             1, 0, 0 },
  57   { "section",             1, 0, 0 },
  58   { "subsection",          1, 0, 0 },
  59   { "subsubsection",       1, 0, 0 },
  60
  61   { "top",                 1, 0, 0 },
  62   { "unnumbered",          1, 0, 0 },
  63   { "unnumberedsec",       1, 0, 0 },
  64   { "unnumberedsubsec",    1, 0, 0 },
  65   { "unnumberedsubsubsec", 1, 0, 0 },
  66
  67   { "appendix",            1, 0, 0 },
  68   { "appendixsec",         1, 0, 0 },
  69   { "appendixsubsec",      1, 0, 0 },
  70   { "appendixsubsubsec",   1, 0, 0 },
  71
  72   { "majorheading",        0, 0, 0 },
  73   { "chapheading",         0, 0, 0 },
  74   { "heading",             0, 0, 0 },
  75   { "subheading",          0, 0, 0 },
  76   { "subsubheading",       0, 0, 0 },
  77
  78   { "titlepage",           1, 0, 0 },
  79   { "author",              0, 0, 0 },
  80   { "booktitle",           0, 0, 0 },
  81   { "booksubtitle",        0, 0, 0 },
  82
  83   { "menu",                1, 0, 0 },
  84   { "detailmenu",          1, 0, 0 },
  85   { "menuentry",           0, 0, 0 },
  86   { "menutitle",           0, 0, 0 },
  87   { "menucomment",         0, 0, 0 },
  88   { "menunode",            0, 0, 0 },
  89   { "nodename",            0, 0, 0 },
  90
  91   { "acronym",             0, 1, 0 },
  92   { "acronymword",         0, 1, 0 },
  93   { "acronymdesc",         0, 1, 0 },
  94
  95   { "abbrev",              0, 1, 0 },
  96   { "abbrevword",          0, 1, 0 },
  97   { "abbrevdesc",          0, 1, 0 },
  98
  99   { "tt",                  0, 1, 0 },
 100   { "code",                0, 1, 0 },
 101   { "command",             0, 1, 0 },
 102   { "env",                 0, 1, 0 },
 103   { "file",                0, 1, 0 },
 104   { "option",              0, 1, 0 },
 105   { "samp",                0, 1, 0 },
 106   { "kbd",                 0, 1, 0 },
 107   { "url",                 0, 1, 0 },
 108   { "key",                 0, 1, 0 },
 109   { "var",                 0, 1, 0 },
 110   { "sc",                  0, 1, 0 },
 111   { "dfn",                 0, 1, 0 },
 112   { "emph",                0, 1, 0 },
 113   { "strong",              0, 1, 0 },
 114   { "cite",                0, 1, 0 },
 115   { "notfixedwidth",       0, 1, 0 },
 116   { "i",                   0, 1, 0 },
 117   { "b",                   0, 1, 0 },
 118   { "r",                   0, 1, 0 },
 119   { "slanted",             0, 1, 0 },
 120   { "sansserif",           0, 1, 0 },
 121
 122   { "exdent",              0, 0, 0 },
 123
 124   { "title",               0, 0, 0 },
 125   { "ifinfo",              1, 0, 0 },
 126   { "sp",                  0, 0, 0 },
 127   { "center",              1, 0, 0 },
 128   { "dircategory",         0, 0, 0 },
 129   { "quotation",           1, 0, 0 },
 130   { "example",             0, 0, 1 },
 131   { "smallexample",        0, 0, 1 },
 132   { "lisp",                0, 0, 1 },
 133   { "smalllisp",           0, 0, 1 },
 134   { "cartouche",           1, 0, 0 },
 135   { "copying",             1, 0, 0 },
 136   { "format",              0, 0, 1 },
 137   { "smallformat",         0, 0, 1 },
 138   { "display",             0, 0, 1 },
 139   { "smalldisplay",        0, 0, 1 },
 140   { "verbatim",            0, 0, 1 },
 141   { "footnote",            0, 1, 0 },
 142   { "",                    0, 1, 0 }, /* LINEANNOTATION (docbook) */
 143
 144   { "",                    1, 0, 0 }, /* TIP (docbook)       */
 145   { "",                    1, 0, 0 }, /* NOTE (docbook)      */
 146   { "",                    1, 0, 0 }, /* IMPORTANT (docbook) */
 147   { "",                    1, 0, 0 }, /* WARNING (docbook)   */
 148   { "",                    1, 0, 0 }, /* CAUTION (docbook)   */
 149
 150   { "itemize",             0, 0, 0 },
 151   { "itemfunction",        0, 0, 0 },
 152   { "item",                1, 0, 0 },
 153   { "enumerate",           0, 0, 0 },
 154   { "table",               0, 0, 0 },
 155   { "tableitem",           0, 0, 0 },
 156   { "tableterm",           0, 0, 0 },
 157
 158   { "indexterm",           0, 1, 0 },
 159
 160   { "math",                0, 1, 0 },
 161
 162   { "dmn",                 0, 1, 0 },
 163
 164   { "xref",                0, 1, 0 },
 165   { "xrefnodename",        0, 1, 0 },
 166   { "xrefinfoname",        0, 1, 0 },
 167   { "xrefprinteddesc",     0, 1, 0 },
 168   { "xrefinfofile",        0, 1, 0 },
 169   { "xrefprintedname",     0, 1, 0 },
 170
 171   { "inforef",             0, 1, 0 },
 172   { "inforefnodename",     0, 1, 0 },
 173   { "inforefrefname",      0, 1, 0 },
 174   { "inforefinfoname",     0, 1, 0 },
 175
 176   { "uref",                0, 1, 0 },
 177   { "urefurl",             0, 1, 0 },
 178   { "urefdesc",            0, 1, 0 },
 179   { "urefreplacement",     0, 1, 0 },
 180
 181   { "email",               0, 1, 0 },
 182   { "emailaddress",        0, 1, 0 },
 183   { "emailname",           0, 1, 0 },
 184
 185   { "group",               0, 0, 0 },
 186   { "float",               1, 0, 0 },
 187   { "floattype",           0, 0, 0 },
 188   { "floatpos",            0, 0, 0 },
 189   { "caption",             0, 0, 0 },
 190   { "shortcaption",        0, 0, 0 },
 191
 192   { "",                    0, 0, 0 }, /* TABLE (docbook) */
 193   { "",                    0, 0, 0 }, /* FIGURE (docbook) */
 194   { "",                    0, 0, 0 }, /* EXAMPLE (docbook) */
 195   { "",                    1, 0, 0 }, /* SIDEBAR (docbook) */
 196
 197   { "printindex",          0, 0, 0 },
 198   { "listoffloats",        0, 0, 0 },
 199   { "anchor",              0, 1, 0 },
 200
 201   { "image",               0, 0, 0 },
 202   { "inlineimage",         0, 1, 0 },
 203   { "alttext",             0, 1, 0 },
 204
 205   { "",                    0, 1, 0 }, /* PRIMARY (docbook) */
 206   { "",                    0, 1, 0 }, /* SECONDARY (docbook) */
 207   { "",                    0, 0, 0 }, /* INFORMALFIGURE (docbook) */
 208   { "",                    0, 0, 0 }, /* MEDIAOBJECT (docbook) */
 209   { "",                    0, 0, 0 }, /* IMAGEOBJECT (docbook) */
 210   { "",                    0, 0, 0 }, /* IMAGEDATA (docbook) */
 211   { "",                    0, 0, 0 }, /* TEXTOBJECT (docbook) */
 212   { "",                    0, 0, 0 }, /* INDEXENTRY (docbook) */
 213   { "",                    0, 0, 0 }, /* PRIMARYIE (docbook) */
 214   { "",                    0, 0, 0 }, /* SECONDARYIE (docbook) */
 215   { "",                    0, 0, 0 }, /* INDEXDIV (docbook) */
 216   { "multitable",          0, 0, 0 },
 217   { "",                    0, 0, 0 }, /* TGROUP (docbook) */
 218   { "columnfraction",      0, 0, 0 },
 219   { "thead",               0, 0, 0 },
 220   { "tbody",               0, 0, 0 },
 221   { "entry",               0, 0, 0 },
 222   { "row",                 0, 0, 0 },
 223   { "",                    0, 0, 0 }, /* BOOKINFO (docbook) */
 224   { "",                    0, 0, 0 }, /* ABSTRACT (docbook) */
 225   { "",                    0, 0, 0 }, /* REPLACEABLE (docbook) */
 226   { "",                    0, 0, 0 }, /* ENVAR (docbook) */
 227   { "",                    0, 0, 0 }, /* COMMENT (docbook) */
 228   { "",                    0, 0, 0 }, /* FUNCTION (docbook) */
 229   { "",                    0, 0, 0 }, /* LEGALNOTICE (docbook) */
 230
 231   { "contents",            0, 0, 0 },
 232   { "shortcontents",       0, 0, 0 },
 233   { "documentlanguage",    0, 0, 0 },
 234
 235   { "setvalue",            0, 0, 0 },
 236   { "clearvalue",          0, 0, 0 },
 237
 238   { "definition",          0, 0, 0 },
 239   { "definitionterm",      0, 0, 0 },
 240   { "definitionitem",      1, 0, 0 },
 241   { "defcategory",         0, 0, 0 },
 242   { "deffunction",         0, 0, 0 },
 243   { "defvariable",         0, 0, 0 },
 244   { "defparam",            0, 0, 0 },
 245   { "defdelimiter",        0, 0, 0 },
 246   { "deftype",             0, 0, 0 },
 247   { "defparamtype",        0, 0, 0 },
 248   { "defdatatype",         0, 0, 0 },
 249   { "defclass",            0, 0, 0 },
 250   { "defclassvar",         0, 0, 0 },
 251   { "defoperation",        0, 0, 0 },
 252
 253   { "para",                0, 0, 0 } /* Must be last */
 254   /* name / contains para / contained in para / preserve space */
 255 };
 256
 257 element docbook_element_list [] = {
 258   { "book",                0, 0, 0 }, /* TEXINFO */
 259   { "",                    0, 0, 0 }, /* SETFILENAME */
 260   { "",                    0, 0, 0 }, /* TITLEINFO */
 261   { "title",               0, 0, 0 }, /* SETTITLE */
 262   { "",                    1, 0, 0 }, /* DOCUMENTDESCRIPTION (?) */
 263
 264   { "",                    1, 0, 0 }, /* NODE */
 265   { "",                    0, 0, 0 }, /* NODENEXT */
 266   { "",                    0, 0, 0 }, /* NODEPREV */
 267   { "",                    0, 0, 0 }, /* NODEUP */
 268
 269   { "chapter",             1, 0, 0 },
 270   { "sect1",               1, 0, 0 }, /* SECTION */
 271   { "sect2",               1, 0, 0 }, /* SUBSECTION */
 272   { "sect3",               1, 0, 0 }, /* SUBSUBSECTION */
 273
 274   { "chapter",             1, 0, 0 }, /* TOP */
 275   { "chapter",             1, 0, 0 }, /* UNNUMBERED */
 276   { "sect1",               1, 0, 0 }, /* UNNUMBEREDSEC */
 277   { "sect2",               1, 0, 0 }, /* UNNUMBEREDSUBSEC */
 278   { "sect3",               1, 0, 0 }, /* UNNUMBEREDSUBSUBSEC */
 279
 280   { "appendix",            1, 0, 0 },
 281   { "sect1",               1, 0, 0 }, /* APPENDIXSEC */
 282   { "sect2",               1, 0, 0 }, /* APPENDIXSUBSEC */
 283   { "sect3",               1, 0, 0 }, /* APPENDIXSUBSUBSEC */
 284
 285   { "bridgehead",          0, 0, 0 }, /* MAJORHEADING */
 286   { "bridgehead",          0, 0, 0 }, /* CHAPHEADING */
 287   { "bridgehead",          0, 0, 0 }, /* HEADING */
 288   { "bridgehead",          0, 0, 0 }, /* SUBHEADING */
 289   { "bridgehead",          0, 0, 0 }, /* SUBSUBHEADING */
 290
 291   { "",                    0, 0, 0 }, /* TITLEPAGE */
 292   { "",                    0, 0, 0 }, /* AUTHOR */
 293   { "",                    0, 0, 0 }, /* BOOKTITLE */
 294   { "",                    0, 0, 0 }, /* BOOKSUBTITLE */
 295
 296   { "",                    1, 0, 0 }, /* MENU */
 297   { "",                    1, 0, 0 }, /* DETAILMENU */
 298   { "",                    1, 0, 0 }, /* MENUENTRY */
 299   { "",                    0, 0, 0 }, /* MENUTITLE */
 300   { "",                    1, 0, 0 }, /* MENUCOMMENT */
 301   { "",                    0, 0, 0 }, /* MENUNODE */
 302   { "anchor",              0, 0, 0 }, /* NODENAME */
 303
 304   { "acronym",             0, 1, 0 },
 305   { "",                    0, 1, 0 }, /* ACRONYMWORD */
 306   { "",                    0, 1, 0 }, /* ACRONYMDESC */
 307
 308   { "abbrev",              0, 1, 0 },
 309   { "",                    0, 1, 0 }, /* ABBREVWORD */
 310   { "",                    0, 1, 0 }, /* ABBREVDESC */
 311
 312   { "literal",             0, 1, 0 }, /* TT */
 313   { "literal",             0, 1, 0 }, /* CODE */
 314   { "command",             0, 1, 0 }, /* COMMAND */
 315   { "envar",               0, 1, 0 }, /* ENV */
 316   { "filename",            0, 1, 0 }, /* FILE */
 317   { "option",              0, 1, 0 }, /* OPTION */
 318   { "literal",             0, 1, 0 }, /* SAMP */
 319   { "userinput",           0, 1, 0 }, /* KBD */
 320   { "wordasword",          0, 1, 0 }, /* URL */
 321   { "keycap",              0, 1, 0 }, /* KEY */
 322   { "replaceable",         0, 1, 0 }, /* VAR */
 323   { "",                    0, 1, 0 }, /* SC */
 324   { "firstterm",           0, 1, 0 }, /* DFN */
 325   { "emphasis",            0, 1, 0 }, /* EMPH */
 326   { "emphasis",            0, 1, 0 }, /* STRONG */
 327   { "citetitle",           0, 1, 0 }, /* CITE */
 328   { "",                    0, 1, 0 }, /* NOTFIXEDWIDTH */
 329   { "wordasword",          0, 1, 0 }, /* I */
 330   { "emphasis",            0, 1, 0 }, /* B */
 331   { "",                    0, 1, 0 }, /* R */
 332
 333   { "",                    0, 0, 0 }, /* EXDENT */
 334
 335   { "title",               0, 0, 0 },
 336   { "",                    1, 0, 0 }, /* IFINFO */
 337   { "",                    0, 0, 0 }, /* SP */
 338   { "",                    1, 0, 0 }, /* CENTER */
 339   { "",                    0, 0, 0 }, /* DIRCATEGORY */
 340   { "blockquote",          1, 0, 0 }, /* QUOTATION */
 341   { "screen",              0, 0, 1 }, /* EXAMPLE */
 342   { "screen",              0, 0, 1 }, /* SMALLEXAMPLE */
 343   { "programlisting",      0, 0, 1 }, /* LISP */
 344   { "programlisting",      0, 0, 1 }, /* SMALLLISP */
 345   { "",                    1, 0, 0 }, /* CARTOUCHE */
 346   { "",                    1, 0, 0 }, /* COPYING */
 347   { "screen",              0, 1, 1 }, /* FORMAT */
 348   { "screen",              0, 1, 1 }, /* SMALLFORMAT */
 349   { "literallayout",       0, 1, 1 }, /* DISPLAY */
 350   { "literallayout",       0, 1, 1 }, /* SMALLDISPLAY */
 351   { "screen",              0, 0, 1 }, /* VERBATIM */
 352   { "footnote",            0, 1, 0 },
 353   { "lineannotation",      0, 1, 0 },
 354
 355   { "tip",                 1, 0, 0 },
 356   { "note",                1, 0, 0 },
 357   { "important",           1, 0, 0 },
 358   { "warning",             1, 0, 0 },
 359   { "caution",             1, 0, 0 },
 360
 361   { "itemizedlist",        0, 0, 0 }, /* ITEMIZE */
 362   { "",                    0, 0, 0 }, /* ITEMFUNCTION */
 363   { "listitem",            1, 0, 0 }, /* ITEM */
 364   { "orderedlist",         0, 0, 0 }, /* ENUMERATE */
 365   { "variablelist",        0, 0, 0 }, /* TABLE */
 366   { "varlistentry",        0, 0, 0 }, /* TABLEITEM */
 367   { "term",                0, 0, 0 }, /* TABLETERM */
 368
 369   { "indexterm",           0, 1, 0 }, /* INDEXTERM */
 370
 371   { "",                    0, 1, 0 }, /* MATH */
 372
 373   { "",                    0, 1, 0 }, /* DIMENSION */
 374
 375   { "xref",                0, 1, 0 }, /* XREF */
 376   { "link",                0, 1, 0 }, /* XREFNODENAME */
 377   { "",                    0, 1, 0 }, /* XREFINFONAME */
 378   { "",                    0, 1, 0 }, /* XREFPRINTEDDESC */
 379   { "",                    0, 1, 0 }, /* XREFINFOFILE */
 380   { "",                    0, 1, 0 }, /* XREFPRINTEDNAME */
 381
 382   { "",                    0, 1, 0 }, /* INFOREF */
 383   { "",                    0, 1, 0 }, /* INFOREFNODENAME */
 384   { "",                    0, 1, 0 }, /* INFOREFREFNAME */
 385   { "",                    0, 1, 0 }, /* INFOREFINFONAME */
 386
 387   { "ulink",               0, 1, 0 }, /* UREF */
 388   { "",                    0, 1, 0 }, /* UREFURL */
 389   { "",                    0, 1, 0 }, /* UREFDESC */
 390   { "",                    0, 1, 0 }, /* UREFREPLACEMENT */
 391
 392   { "ulink",               0, 1, 0 }, /* EMAIL */
 393   { "",                    0, 1, 0 }, /* EMAILADDRESS */
 394   { "",                    0, 1, 0 }, /* EMAILNAME */
 395
 396   { "",                    0, 0, 0 }, /* GROUP */
 397   { "",                    1, 0, 0 }, /* FLOAT */
 398   { "",                    0, 0, 0 }, /* FLOATTYPE */
 399   { "",                    0, 0, 0 }, /* FLOATPOS */
 400   { "",                    0, 0, 0 }, /* CAPTION */
 401   { "",                    0, 0, 0 }, /* SHORTCAPTION */
 402
 403   { "table",               0, 1, 0 },
 404   { "figure",              0, 1, 0 },
 405   { "example",             1, 1, 0 },
 406   { "sidebar",             1, 0, 0 },
 407
 408   { "index",               0, 1, 0 }, /* PRINTINDEX */
 409   { "",                    0, 1, 0 }, /* LISTOFFLOATS */
 410   { "",                    0, 1, 0 }, /* ANCHOR */
 411
 412   { "",                    0, 0, 0 }, /* IMAGE */
 413   { "inlinemediaobject",   0, 1, 0 }, /* INLINEIMAGE */
 414   { "",                    0, 0, 0 }, /* IMAGEALTTEXT */
 415
 416   { "primary",             0, 1, 0 }, /* PRIMARY */
 417   { "secondary",           0, 1, 0 },
 418   { "informalfigure",      0, 0, 0 },
 419   { "mediaobject",         0, 0, 0 },
 420   { "imageobject",         0, 1, 0 },
 421   { "imagedata",           0, 1, 0 },
 422   { "textobject",          0, 1, 0 },
 423   { "indexentry",          0, 0, 0 },
 424   { "primaryie",           0, 0, 0 },
 425   { "secondaryie",         0, 0, 0 },
 426   { "indexdiv",            0, 0, 0 },
 427   { "informaltable",       0, 0, 0 },
 428   { "tgroup",              0, 0, 0 },
 429   { "colspec",             0, 0, 0 },
 430   { "thead",               0, 0, 0 },
 431   { "tbody",               0, 0, 0 },
 432   { "entry",               0, 0, 0 },
 433   { "row",                 0, 0, 0 },
 434   { "bookinfo",            0, 0, 0 },
 435   { "abstract",            1, 0, 0 },
 436   { "replaceable",         0, 0, 0 },
 437   { "envar",               0, 1, 0 },
 438   { "comment",             0, 0, 0 },
 439   { "function",            0, 1, 0 },
 440   { "legalnotice",         1, 0, 0 },
 441
 442   { "",                    0, 0, 0 }, /* CONTENTS (xml) */
 443   { "",                    0, 0, 0 }, /* SHORTCONTENTS (xml) */
 444   { "",                    0, 0, 0 }, /* DOCUMENT LANGUAGE (xml) */
 445
 446   { "",                    0, 0, 0 }, /* SETVALUE (xml) */
 447   { "",                    0, 0, 0 }, /* CLEARVALUE (xml) */
 448
 449   { "blockquote",          1, 0, 0 }, /* DEFINITION */
 450   { "screen",              0, 0, 1 }, /* DEFINITIONTERM */
 451   { "",                    0, 0, 0 }, /* DEFINITIONITEM (xml) */
 452   { "",                    0, 0, 0 }, /* DEFCATEGORY (xml) */
 453   { "function",            0, 0, 0 }, /* DEFFUNCTION */
 454   { "varname",             0, 0, 0 }, /* DEFVARIABLE */
 455   { "varname",             0, 0, 0 }, /* DEFPARAM */
 456   { "",                    0, 0, 0 }, /* DEFDELIMITER (xml) */
 457   { "returnvalue",         0, 0, 0 }, /* DEFTYPE */
 458   { "type",                0, 0, 0 }, /* DEFPARAMTYPE */
 459   { "structname",          0, 0, 0 }, /* DEFDATATYPE */
 460   { "classname",           0, 0, 0 }, /* DEFCLASS */
 461   { "property",            0, 0, 0 }, /* DEFCLASSVAR */
 462   { "methodname",          0, 0, 0 }, /* DEFOPERATION */
 463
 464   { "para",                0, 0, 0 } /* Must be last */
 465   /* name / contains para / contained in para / preserve space */
 466 };
 467
 468 element *xml_element_list = NULL;
 469
 470
 471 typedef struct _replace_element
 472 {
 473   int element_to_replace;
 474   int element_containing;
 475   int element_replacing;
 476 } replace_element;
 477
 478 /* Elements to replace - Docbook only
 479    -------------------
 480    if `element_to_replace' have to be inserted
 481    as a child of `element_containing,'
 482    use `element_replacing' instead.
 483
 484    A value of `-1' for element_replacing means `do not use any element.'
 485 */
 486
 487 replace_element replace_elements [] = {
 488   { I, TABLETERM, EMPH },
 489   { B, TABLETERM, EMPH },
 490   { TT, CODE, -1 },
 491   { EXAMPLE, DISPLAY, -1 },
 492   { CODE, DFN, -1 },
 493   { CODE, VAR, -1 },
 494   { EMPH, CODE, REPLACEABLE },
 495   { VAR, VAR, -1},
 496   { VAR, B, EMPH},
 497   { B, CODE, ENVAR},
 498   { CODE, I, EMPH},
 499   { SAMP, VAR, -1 },
 500   { FORMAT, BOOKINFO, ABSTRACT },
 501   { QUOTATION, ABSTRACT, -1},
 502   { LINEANNOTATION, LINEANNOTATION, -1 },
 503   { LEGALNOTICE, ABSTRACT, -1 },
 504   { QUOTATION, QUOTATION, -1 },
 505   /* Formal versions of table and image elements.  */
 506   { MULTITABLE, FLOAT, FLOATTABLE },
 507   { INFORMALFIGURE, FLOAT, FLOATFIGURE },
 508   { CARTOUCHE, FLOAT, FLOATCARTOUCHE },
 509   /* Unnecessary markup in @defun blocks.  */
 510   { VAR, DEFPARAM, -1 },
 511   { CODE, DEFTYPE, -1 },
 512   /* Add your elements to replace here */
 513   {-1, 0, 0}
 514 };
 515
 516 int xml_in_menu_entry = 0;
 517 int xml_in_menu_entry_comment = 0;
 518 int xml_node_open = 0;
 519 int xml_node_level = -1;
 520 int xml_in_para = 0;
 521 int xml_just_after_element = 0;
 522 int xml_keep_space = 0;
 523
 524 int xml_no_indent = 0;
 525
 526 int xml_no_para = 0;
 527 char *xml_node_id = NULL;
 528 int xml_sort_index = 0;
 529
 530 int xml_in_xref_token = 0;
 531 int xml_in_bookinfo = 0;
 532 int xml_in_book_title = 0;
 533 int xml_in_abstract = 0;
 534
 535 /* Non-zero if we are handling an element that can appear between
 536    @item and @itemx, @deffn and @deffnx.  */
 537 int xml_dont_touch_items_defs = 0;
 538
 539 /* We need to keep footnote state, because elements inside footnote may try
 540    to close the previous parent para.  */
 541 static int xml_in_footnote = 0;
 542
 543 static int xml_after_table_term = 0;
 544 static int book_started = 0;
 545 static int first_section_opened = 0;
 546
 547 static int xml_in_tableitem[256];
 548 static int xml_in_item[256];
 549 static int xml_table_level = 0;
 550
 551 static int xml_in_def_item[256];
 552 static int xml_definition_level = 0;
 553 int xml_after_def_term = 0;
 554
 555 static int in_table_title = 0;
 556
 557 static int in_indexentry = 0;
 558 static int in_secondary = 0;
 559 static int in_indexterm = 0;
 560 \f
 561 char *
 562 xml_id (char *id)
 563 {
 564   char *tem = xmalloc (strlen (id) + 1);
 565   char *p = tem;
 566   strcpy (tem, id);
 567   while (*p)
 568     { /* Check if a character is allowed in ID attributes.  This list differs
 569          slightly from XML specs that it doesn't contain underscores.
 570          See http://xml.coverpages.org/sgmlsyn/sgmlsyn.htm, ``9.3 Name''  */
 571       if (!strchr ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-.", *p))
 572         *p = '-';
 573       p++;
 574     }
 575   p = tem;
 576   /* First character can only be a letter.  */
 577   if (!strchr ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", *p))
 578     *p = 'i';
 579   return tem;
 580 }
 581
 582 int
 583 xml_element (char *name)
 584 {
 585   int i;
 586   for (i=0; i<=PARA; i++)
 587     {
 588       if (strcasecmp (name, texinfoml_element_list[i].name) == 0)
 589         return i;
 590     }
 591   printf ("Error xml_element\n");
 592   return -1;
 593 }
 594
 595 void
 596 xml_begin_document (char *output_filename)
 597 {
 598   if (book_started)
 599     return;
 600
 601   book_started = 1;
 602
 603   /* Make sure this is the very first string of the output document.  */
 604   output_paragraph_offset = 0;
 605
 606   insert_string ("<?xml version=\"1.0\"");
 607
 608   /* At this point, we register a delayed writing for document encoding,
 609      so in the end, proper encoding attribute will be inserted here.
 610      Since the user is unaware that we are implicitly executing this
 611      command, we should disable warnings temporarily, in order to avoid
 612      possible confusion.  (ie. if the output is not seekable,
 613      register_delayed_write issues a warning.)  */
 614   {
 615     extern int print_warnings;
 616     int save_print_warnings = print_warnings;
 617     print_warnings = 0;
 618     register_delayed_write ("@documentencoding");
 619     print_warnings = save_print_warnings;
 620   }
 621
 622   insert_string ("?>\n");
 623
 624   if (docbook)
 625     {
 626       insert_string ("<!DOCTYPE book PUBLIC \"-//OASIS//DTD DocBook XML V4.2//EN\" \"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\" [\n  <!ENTITY tex \"TeX\">\n  <!ENTITY latex \"LaTeX\">\n]>");
 627       xml_element_list = docbook_element_list;
 628     }
 629   else
 630     {
 631       insert_string ("<!DOCTYPE texinfo PUBLIC \"-//GNU//DTD TexinfoML V");
 632       insert_string (VERSION);
 633       insert_string ("//EN\" \"http://www.gnu.org/software/texinfo/dtd/");
 634       insert_string (VERSION);
 635       insert_string ("/texinfo.dtd\">");
 636       xml_element_list = texinfoml_element_list;
 637     }
 638   if (language_code != last_language_code)
 639     {
 640       if (docbook)
 641         xml_insert_element_with_attribute (TEXINFO, START, "lang=\"%s\"", language_table[language_code].abbrev);
 642       else
 643         xml_insert_element_with_attribute (TEXINFO, START, "xml:lang=\"%s\"", language_table[language_code].abbrev);
 644     }
 645   if (!docbook)
 646     {
 647       xml_insert_element (SETFILENAME, START);
 648       insert_string (output_filename);
 649       xml_insert_element (SETFILENAME, END);
 650     }
 651 }
 652
 653 /* \f */
 654 static int element_stack[256];
 655 static int element_stack_index = 0;
 656
 657 static int
 658 xml_current_element (void)
 659 {
 660   return element_stack[element_stack_index-1];
 661 }
 662
 663 static void
 664 xml_push_current_element (int elt)
 665 {
 666   element_stack[element_stack_index++] = elt;
 667   if (element_stack_index > 200)
 668     printf ("*** stack overflow (%d - %s) ***\n",
 669             element_stack_index,
 670             xml_element_list[elt].name);
 671 }
 672
 673 static void
 674 xml_pop_current_element (void)
 675 {
 676   element_stack_index--;
 677   if (element_stack_index < 0)
 678     printf ("*** stack underflow (%d - %d) ***\n",
 679             element_stack_index,
 680             xml_current_element());
 681 }
 682
 683 int
 684 xml_current_stack_index (void)
 685 {
 686   return element_stack_index;
 687 }
 688
 689 void
 690 xml_end_current_element (void)
 691 {
 692   xml_insert_element (xml_current_element (), END);
 693 }
 694
 695 static void
 696 xml_indent (void)
 697 {
 698   if (xml_indentation_increment > 0)
 699     {
 700       int i;
 701       if (output_paragraph[output_paragraph_offset-1] != '\n')
 702         insert ('\n');
 703       for (i = 0; i < element_stack_index * xml_indentation_increment; i++)
 704         insert (' ');
 705     }
 706 }
 707
 708 void
 709 xml_start_para (void)
 710 {
 711   if (xml_in_para || xml_in_footnote
 712       || !xml_element_list[xml_current_element()].contains_para)
 713     return;
 714
 715   while (output_paragraph[output_paragraph_offset-1] == '\n')
 716     output_paragraph_offset--;
 717   xml_indent ();
 718
 719   insert_string ("<para");
 720   if (xml_no_indent)
 721     insert_string (" role=\"continues\"");
 722   insert_string (">");
 723   xml_no_indent = 0;
 724   xml_in_para = 1;
 725 }
 726
 727 void
 728 xml_end_para (void)
 729 {
 730   if (!xml_in_para || xml_in_footnote)
 731     return;
 732
 733   while (cr_or_whitespace(output_paragraph[output_paragraph_offset-1]))
 734     output_paragraph_offset--;
 735
 736   insert_string ("</para>");
 737   if (xml_indentation_increment > 0)
 738     insert ('\n');
 739   xml_in_para = 0;
 740 }
 741
 742 void
 743 xml_end_document (void)
 744 {
 745   if (xml_node_open)
 746     {
 747       if (xml_node_level != -1)
 748         {
 749           xml_close_sections (xml_node_level);
 750           xml_node_level = -1;
 751         }
 752       xml_insert_element (NODE, END);
 753     }
 754   else
 755     xml_close_sections (xml_node_level);
 756
 757   xml_insert_element (TEXINFO, END);
 758   if (xml_indentation_increment == 0)
 759     insert ('\n');
 760   insert_string ("<!-- Keep this comment at the end of the file\n\
 761 Local variables:\n\
 762 mode: sgml\n\
 763 sgml-indent-step:1\n\
 764 sgml-indent-data:nil\n\
 765 End:\n\
 766 -->\n");
 767   if (element_stack_index != 0)
 768     error ("Element stack index : %d\n", element_stack_index);
 769 }
 770
 771 /* MUST be 0 or 1, not true or false values */
 772 static int start_element_inserted = 1;
 773
 774 /* NOTE: We use `elt' rather than `element' in the argument list of
 775    the next function, since otherwise the Solaris SUNWspro compiler
 776    barfs because `element' is a typedef declared near the beginning of
 777    this file.  */
 778 void
 779 #if defined (VA_FPRINTF) && __STDC__
 780 xml_insert_element_with_attribute (int elt, int arg, char *format, ...)
 781 #else
 782 xml_insert_element_with_attribute (elt, arg, format, va_alist)
 783      int elt;
 784      int arg;
 785      char *format;
 786      va_dcl
 787 #endif
 788 {
 789   /* Look at the replace_elements table to see if we have to change the element */
 790   if (xml_sort_index)
 791       return;
 792   if (docbook)
 793     {
 794       replace_element *element_list = replace_elements;
 795       while (element_list->element_to_replace >= 0)
 796         {
 797           if ( ( (arg == START) &&
 798                  (element_list->element_containing == xml_current_element ()) &&
 799                  (element_list->element_to_replace == elt) ) ||
 800                ( (arg == END) &&
 801                  (element_list->element_containing == element_stack[element_stack_index-1-start_element_inserted]) &&
 802                  (element_list->element_to_replace == elt) ) )
 803             {
 804               elt = element_list->element_replacing;
 805               break;
 806             }
 807           element_list ++;
 808         }
 809
 810       /* Forget the element */
 811       if (elt < 0)
 812         {
 813           if (arg == START)
 814             start_element_inserted = 0;
 815           else
 816             /* Replace the default value, for the next time */
 817             start_element_inserted = 1;
 818           return;
 819         }
 820     }
 821
 822   if (!book_started)
 823     return;
 824
 825   if (!xml_dont_touch_items_defs && arg == START)
 826     {
 827       if (xml_after_table_term && elt != TABLETERM && xml_table_level
 828           && !xml_in_item[xml_table_level])
 829         {
 830           xml_after_table_term = 0;
 831           xml_insert_element (ITEM, START);
 832           xml_in_item[xml_table_level] = 1;
 833         }
 834       else if (xml_after_def_term && elt != DEFINITIONTERM)
 835         {
 836           xml_after_def_term = 0;
 837           xml_insert_element (DEFINITIONITEM, START);
 838           xml_in_def_item[xml_definition_level] = 1;
 839         }
 840     }
 841
 842   if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
 843     return;
 844
 845   if (executing_string && arg == END)
 846     switch (elt)
 847       {
 848       case TABLEITEM:
 849         xml_in_tableitem[xml_table_level] = 0;
 850         break;
 851       case ITEM:
 852         xml_in_item[xml_table_level] = 0;
 853         break;
 854       case DEFINITIONTERM:
 855         xml_in_def_item[xml_definition_level] = 0;
 856         break;
 857       }
 858
 859   /* We are special-casing FIGURE element for docbook.  It does appear in
 860      the tag stack, but not in the output.  This is to make element replacement
 861      work beautifully.  */
 862   if (docbook && elt == FLOAT)
 863     {
 864       if (arg == START)
 865         xml_push_current_element (elt);
 866       else
 867         xml_pop_current_element ();
 868       return;
 869     }
 870
 871   if (!xml_element_list[elt].name || !strlen (xml_element_list[elt].name))
 872     {
 873       /*printf ("Warning: Inserting empty element %d\n", elt);*/
 874       return;
 875     }
 876
 877   if (arg == START && !xml_in_para && !xml_no_para
 878       && xml_element_list[elt].contained_in_para)
 879     xml_start_para ();
 880
 881   if (arg == START && xml_in_para && !xml_element_list[elt].contained_in_para)
 882     xml_end_para ();
 883
 884   if (arg == END && xml_in_para && !xml_element_list[elt].contained_in_para)
 885     xml_end_para ();
 886
 887   if (docbook && xml_table_level && !in_table_title
 888       && !xml_in_tableitem[xml_table_level] && !xml_in_item[xml_table_level]
 889       && arg == START && elt != TABLEITEM && elt != TABLETERM
 890       && !in_indexterm && xml_current_element() == TABLE)
 891     {
 892       in_table_title = 1;
 893       xml_insert_element (TITLE, START);
 894     }
 895
 896   if (arg == START && !xml_in_para && !xml_keep_space
 897       && !xml_element_list[elt].contained_in_para)
 898     xml_indent ();
 899
 900   if (arg == START)
 901     xml_push_current_element (elt);
 902   else
 903     xml_pop_current_element ();
 904
 905   /* Eat one newline before </example> and the like.  */
 906   if (!docbook && arg == END
 907       && (xml_element_list[elt].keep_space || elt == GROUP)
 908       && output_paragraph[output_paragraph_offset-1] == '\n')
 909     output_paragraph_offset--;
 910
 911   /* And eat whitespace before </entry> in @multitables.  */
 912   if (arg == END && elt == ENTRY)
 913       while (cr_or_whitespace(output_paragraph[output_paragraph_offset-1]))
 914     output_paragraph_offset--;
 915
 916   /* Indent elements that can contain <para>.  */
 917   if (arg == END && !xml_in_para && !xml_keep_space
 918       && xml_element_list[elt].contains_para)
 919     xml_indent ();
 920
 921   /* Here are the elements we want indented.  These do not contain <para>
 922      directly.  */
 923   if (arg == END && (elt == MENUENTRY || elt == ITEMIZE || elt == ENUMERATE
 924         || elt == TABLEITEM || elt == TABLE
 925         || elt == MULTITABLE || elt == TGROUP || elt == THEAD || elt == TBODY
 926         || elt == ROW || elt == INFORMALFIGURE
 927         || (!docbook && (elt == DEFINITION || elt == DEFINITIONTERM))))
 928     xml_indent ();
 929
 930   insert ('<');
 931   if (arg == END)
 932     insert ('/');
 933   insert_string (xml_element_list[elt].name);
 934
 935   /*  printf ("%s ", xml_element_list[elt].name);*/
 936
 937   if (format)
 938     {
 939       char temp_string[2000]; /* xx no fixed limits */
 940 #ifdef VA_SPRINTF
 941       va_list ap;
 942 #endif
 943
 944       VA_START (ap, format);
 945 #ifdef VA_SPRINTF
 946       VA_SPRINTF (temp_string, format, ap);
 947 #else
 948       sprintf (temp_string, format, a1, a2, a3, a4, a5, a6, a7, a8);
 949 #endif
 950       insert (' ');
 951       insert_string (temp_string);
 952       va_end (ap);
 953     }
 954
 955   if (arg == START && xml_node_id && elt != NODENAME)
 956     {
 957       insert_string (" id=\"");
 958       insert_string (xml_node_id);
 959       insert ('"');
 960       free (xml_node_id);
 961       xml_node_id = NULL;
 962     }
 963
 964   if (xml_element_list[elt].keep_space)
 965     {
 966       if (arg == START)
 967         {
 968           if (!docbook)
 969             insert_string (" xml:space=\"preserve\"");
 970           xml_keep_space++;
 971         }
 972       else
 973         xml_keep_space--;
 974     }
 975
 976   insert ('>');
 977
 978   if (!xml_in_para && !xml_element_list[elt].contained_in_para
 979       && xml_element_list[elt].contains_para && xml_indentation_increment > 0)
 980     insert ('\n');
 981
 982   xml_just_after_element = 1;
 983 }
 984
 985 /* See the NOTE before xml_insert_element_with_attribute, for why we
 986    use `elt' rather than `element' here.  */
 987 void
 988 xml_insert_element (int elt, int arg)
 989 {
 990   xml_insert_element_with_attribute (elt, arg, NULL);
 991 }
 992
 993 void
 994 xml_insert_entity (char *entity_name)
 995 {
 996   int saved_escape_html = escape_html;
 997
 998   if (!book_started)
 999     return;
1000   if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
1001     return;
1002
1003   if (!xml_in_para && !xml_no_para && !only_macro_expansion
1004       && xml_element_list[xml_current_element ()].contains_para
1005       && !in_fixed_width_font)
1006     xml_start_para ();
1007
1008   escape_html = 0;
1009   add_char ('&');
1010   escape_html = saved_escape_html;
1011   insert_string (entity_name);
1012   add_char (';');
1013 }
1014
1015 typedef struct _xml_section xml_section;
1016 struct _xml_section {
1017   int level;
1018   char *name;
1019   xml_section *prev;
1020 };
1021
1022 xml_section *last_section = NULL;
1023
1024 void
1025 xml_begin_node (void)
1026 {
1027   first_section_opened = 1;
1028   if (xml_in_abstract)
1029     {
1030       xml_insert_element (ABSTRACT, END);
1031       xml_in_abstract = 0;
1032     }
1033   if (xml_in_bookinfo)
1034     {
1035       xml_insert_element (BOOKINFO, END);
1036       xml_in_bookinfo = 0;
1037     }
1038   if (xml_node_open && ! docbook)
1039     {
1040       if (xml_node_level != -1)
1041         {
1042           xml_close_sections (xml_node_level);
1043           xml_node_level = -1;
1044         }
1045       xml_insert_element (NODE, END);
1046     }
1047   xml_insert_element (NODE, START);
1048   xml_node_open = 1;
1049 }
1050
1051 void
1052 xml_close_sections (int level)
1053 {
1054   if (!first_section_opened)
1055     {
1056       if (xml_in_abstract)
1057         {
1058           xml_insert_element (ABSTRACT, END);
1059           xml_in_abstract = 0;
1060         }
1061       if (xml_in_bookinfo)
1062         {
1063           xml_insert_element (BOOKINFO, END);
1064           xml_in_bookinfo = 0;
1065         }
1066       first_section_opened = 1;
1067     }
1068
1069   while (last_section && last_section->level >= level)
1070     {
1071       xml_section *temp = last_section;
1072       xml_insert_element (xml_element(last_section->name), END);
1073       temp = last_section;
1074       last_section = last_section->prev;
1075       free (temp->name);
1076       free (temp);
1077     }
1078 }
1079
1080 void
1081 xml_open_section (int level, char *name)
1082 {
1083   xml_section *sect = (xml_section *) xmalloc (sizeof (xml_section));
1084
1085   sect->level = level;
1086   sect->name = xmalloc (1 + strlen (name));
1087   strcpy (sect->name, name);
1088   sect->prev = last_section;
1089   last_section = sect;
1090
1091   if (xml_node_open && xml_node_level == -1)
1092     xml_node_level = level;
1093 }
1094
1095 void
1096 xml_start_menu_entry (char *tem)
1097 {
1098   char *string;
1099   discard_until ("* ");
1100
1101   /* The line number was already incremented in reader_loop when we
1102      saw the newline, and discard_until has now incremented again.  */
1103   line_number--;
1104
1105   if (xml_in_menu_entry)
1106     {
1107       if (xml_in_menu_entry_comment)
1108         {
1109           xml_insert_element (MENUCOMMENT, END);
1110           xml_in_menu_entry_comment=0;
1111         }
1112       xml_insert_element (MENUENTRY, END);
1113       xml_in_menu_entry=0;
1114     }
1115   xml_insert_element (MENUENTRY, START);
1116   xml_in_menu_entry=1;
1117
1118   xml_insert_element (MENUNODE, START);
1119   string = expansion (tem, 0);
1120   add_word (string);
1121   xml_insert_element (MENUNODE, END);
1122   free (string);
1123
1124   /* The menu item may use macros, so expand them now.  */
1125   xml_insert_element (MENUTITLE, START);
1126   only_macro_expansion++;
1127   get_until_in_line (1, ":", &string);
1128   only_macro_expansion--;
1129   execute_string ("%s", string); /* get escaping done */
1130   xml_insert_element (MENUTITLE, END);
1131   free (string);
1132
1133   if (looking_at ("::"))
1134     discard_until (":");
1135   else
1136     { /* discard the node name */
1137       get_until_in_line (0, ".", &string);
1138       free (string);
1139     }
1140   input_text_offset++;  /* discard the second colon or the period */
1141   skip_whitespace_and_newlines();
1142   xml_insert_element (MENUCOMMENT, START);
1143   xml_in_menu_entry_comment ++;
1144 }
1145
1146 void
1147 xml_end_menu (void)
1148 {
1149   if (xml_in_menu_entry)
1150     {
1151       if (xml_in_menu_entry_comment)
1152         {
1153           xml_insert_element (MENUCOMMENT, END);
1154           xml_in_menu_entry_comment --;
1155         }
1156       xml_insert_element (MENUENTRY, END);
1157       xml_in_menu_entry--;
1158     }
1159   xml_insert_element (MENU, END);
1160 }
1161
1162 static int xml_last_character;
1163
1164 void
1165 xml_add_char (int character)
1166 {
1167   if (!book_started)
1168       return;
1169   if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
1170     return;
1171
1172   if (docbook && xml_table_level && !in_table_title
1173       && !xml_in_item[xml_table_level] && !xml_in_tableitem[xml_table_level]
1174       && !cr_or_whitespace (character) && !in_indexterm)
1175     {
1176       in_table_title = 1;
1177       xml_insert_element (TITLE, START);
1178     }
1179
1180   if (!first_section_opened && !xml_in_abstract && !xml_in_book_title
1181       && !xml_no_para && character != '\r' && character != '\n'
1182       && character != ' ' && !is_in_insertion_of_type (copying))
1183     {
1184       if (!xml_in_bookinfo)
1185         {
1186           xml_insert_element (BOOKINFO, START);
1187           xml_in_bookinfo = 1;
1188         }
1189       xml_insert_element (ABSTRACT, START);
1190       xml_in_abstract = 1;
1191     }
1192
1193   if (!xml_sort_index && !xml_in_xref_token && !xml_dont_touch_items_defs)
1194     {
1195       if (xml_after_table_term && xml_table_level
1196           && !xml_in_item[xml_table_level])
1197         {
1198           xml_after_table_term = 0;
1199           xml_insert_element (ITEM, START);
1200           xml_in_item[xml_table_level] = 1;
1201         }
1202       else if (xml_after_def_term)
1203         {
1204           xml_after_def_term = 0;
1205           xml_insert_element (DEFINITIONITEM, START);
1206           xml_in_def_item[xml_definition_level] = 1;
1207         }
1208     }
1209
1210   if (xml_just_after_element && !xml_in_para && !inhibit_paragraph_indentation)
1211     {
1212       if (character == '\r' || character == '\n' || character == '\t' || character == ' ')
1213         return;
1214       xml_just_after_element = 0;
1215     }
1216
1217   if (xml_element_list[xml_current_element()].contains_para
1218       && !xml_in_para && !only_macro_expansion && !xml_no_para
1219       && !cr_or_whitespace (character) && !in_fixed_width_font)
1220     xml_start_para ();
1221
1222   if (xml_in_para && character == '\n' && xml_last_character == '\n'
1223       && !only_macro_expansion && !xml_no_para
1224       && xml_element_list[xml_current_element()].contains_para )
1225     {
1226       xml_end_para ();
1227       xml_just_after_element = 1;
1228       return;
1229     }
1230
1231   if (xml_in_menu_entry_comment && character == '\n' && xml_last_character == '\n')
1232     {
1233       xml_insert_element (MENUCOMMENT, END);
1234       xml_in_menu_entry_comment = 0;
1235       xml_insert_element (MENUENTRY, END);
1236       xml_in_menu_entry = 0;
1237     }
1238
1239   if (xml_in_menu_entry_comment && whitespace(character)
1240       && cr_or_whitespace(xml_last_character))
1241     return;
1242
1243   if (character == '\n' && !xml_in_para && !inhibit_paragraph_indentation)
1244     return;
1245
1246   xml_last_character = character;
1247
1248   if (character == '&' && escape_html)
1249       insert_string ("&amp;");
1250   else if (character == '<' && escape_html)
1251       insert_string ("&lt;");
1252   else if (character == '\n' && !xml_keep_space)
1253     {
1254       if (!xml_in_para && xml_just_after_element && !multitable_active)
1255         return;
1256       else
1257         insert (docbook ? '\n' : ' ');
1258     }
1259   else
1260     insert (character);
1261
1262   return;
1263 }
1264
1265 void
1266 xml_insert_footnote (char *note)
1267 {
1268   if (!xml_in_para)
1269     xml_start_para ();
1270
1271   xml_in_footnote = 1;
1272   xml_insert_element (FOOTNOTE, START);
1273   insert_string ("<para>");
1274   execute_string ("%s", note);
1275   insert_string ("</para>");
1276   xml_insert_element (FOOTNOTE, END);
1277   xml_in_footnote = 0;
1278 }
1279
1280 /* We need to keep the quotation stack ourself, because insertion_stack
1281    loses item_function when we are closing the block, so we don't know
1282    what to close then.  */
1283 typedef struct quotation_elt
1284 {
1285   struct quotation_elt *next;
1286   char *type;
1287 } QUOTATION_ELT;
1288
1289 static QUOTATION_ELT *quotation_stack = NULL;
1290
1291 void
1292 xml_insert_quotation (char *type, int arg)
1293 {
1294   int quotation_started = 0;
1295
1296   if (arg == START)
1297     {
1298       QUOTATION_ELT *new = xmalloc (sizeof (QUOTATION_ELT));
1299       new->type = xstrdup (type);
1300       new->next = quotation_stack;
1301       quotation_stack = new;
1302     }
1303   else
1304     type = quotation_stack->type;
1305
1306   /* Make use of special quotation styles of Docbook if we can.  */
1307   if (docbook && strlen(type))
1308     {
1309       /* Let's assume it started.  */
1310       quotation_started = 1;
1311
1312       if (strcasecmp (type, "tip") == 0)
1313         xml_insert_element (TIP, arg);
1314       else if (strcasecmp (type, "note") == 0)
1315         xml_insert_element (NOTE, arg);
1316       else if (strcasecmp (type, "important") == 0)
1317         xml_insert_element (IMPORTANT, arg);
1318       else if (strcasecmp (type, "warning") == 0)
1319         xml_insert_element (WARNING, arg);
1320       else if (strcasecmp (type, "caution") == 0)
1321         xml_insert_element (CAUTION, arg);
1322       else
1323         /* Didn't find a known quotation type :\ */
1324         quotation_started = 0;
1325     }
1326
1327   if (!quotation_started)
1328     {
1329       xml_insert_element (QUOTATION, arg);
1330       if (strlen(type) && arg == START)
1331         execute_string ("@b{%s:} ", type);
1332     }
1333
1334   if (arg == END)
1335     {
1336       QUOTATION_ELT *temp = quotation_stack;
1337       if (temp == NULL)
1338         return;
1339       quotation_stack = quotation_stack->next;
1340       free(temp->type);
1341       free(temp);
1342     }
1343 }
1344
1345 /* Starting generic docbook floats.  Just starts elt with correct label
1346    and id attributes, and inserts title.  */
1347 void
1348 xml_begin_docbook_float (int elt)
1349 {
1350   if (current_float_used_title ())      /* in a nested float */
1351     {
1352       xml_insert_element (elt, START);  /* just insert the tag */
1353       return;
1354     }
1355
1356
1357   /* OK, need the title, tag, etc. */
1358   if (elt == CARTOUCHE)    /* no labels on <sidebar> */
1359     {
1360        if (strlen (current_float_id ()) == 0)
1361           xml_insert_element (elt, START);
1362        else
1363           xml_insert_element_with_attribute (elt, START,
1364               "id=\"%s\"", xml_id (current_float_id ()));
1365     }
1366   else if (strlen (current_float_id ()) == 0)
1367     xml_insert_element_with_attribute (elt, START, "label=\"\"");
1368   else
1369     xml_insert_element_with_attribute (elt, START,
1370         "id=\"%s\" label=\"%s\"", xml_id (current_float_id ()),
1371         current_float_number ());
1372
1373   xml_insert_element (TITLE, START);
1374   execute_string ("%s", current_float_title ());
1375   xml_insert_element (TITLE, END);
1376
1377   current_float_set_title_used ();      /* mark this title, tag, etc used */
1378 }
1379
1380 /*
1381  * Lists and Tables
1382  */
1383 void
1384 xml_begin_table (int type, char *item_function)
1385 {
1386   switch (type)
1387     {
1388     case ftable:
1389     case vtable:
1390     case table:
1391       /*if (docbook)*/ /* 05-08 */
1392         {
1393           xml_insert_element (TABLE, START);
1394           xml_table_level ++;
1395           xml_in_tableitem[xml_table_level] = 0;
1396           xml_in_item[xml_table_level] = 0;
1397           xml_after_table_term = 0;
1398         }
1399       break;
1400     case itemize:
1401       if (!docbook)
1402         {
1403           xml_insert_element (ITEMIZE, START);
1404           xml_table_level ++;
1405           xml_in_item[xml_table_level] = 0;
1406           xml_insert_element (ITEMFUNCTION, START);
1407           if (*item_function == COMMAND_PREFIX
1408               && item_function[strlen (item_function) - 1] != '}'
1409               && command_needs_braces (item_function + 1))
1410             execute_string ("%s{}", item_function);
1411           else
1412             execute_string ("%s", item_function);
1413           xml_insert_element (ITEMFUNCTION, END);
1414         }
1415       else
1416         {
1417           xml_insert_element_with_attribute (ITEMIZE, START,
1418                                              "mark=\"%s\"",
1419                                              (*item_function == COMMAND_PREFIX) ?
1420                                              &item_function[1] : item_function);
1421           xml_table_level ++;
1422           xml_in_item[xml_table_level] = 0;
1423         }
1424       break;
1425     }
1426 }
1427
1428 void
1429 xml_end_table (int type)
1430 {
1431   switch (type)
1432     {
1433     case ftable:
1434     case vtable:
1435     case table:
1436       if (xml_in_item[xml_table_level])
1437         {
1438           xml_insert_element (ITEM, END);
1439           xml_in_item[xml_table_level] = 0;
1440         }
1441       if (xml_in_tableitem[xml_table_level])
1442         {
1443           xml_insert_element (TABLEITEM, END);
1444           xml_in_tableitem[xml_table_level] = 0;
1445         }
1446       xml_insert_element (TABLE, END);
1447       xml_after_table_term = 0;
1448       xml_table_level --;
1449
1450       break;
1451     case itemize:
1452       if (xml_in_item[xml_table_level])
1453         {
1454           xml_insert_element (ITEM, END);
1455           xml_in_item[xml_table_level] = 0;
1456         }
1457       /* gnat-style manual contains an itemized list without items! */
1458       if (in_table_title)
1459         {
1460           xml_insert_element (TITLE, END);
1461           in_table_title = 0;
1462         }
1463       xml_insert_element (ITEMIZE, END);
1464       xml_table_level --;
1465       break;
1466     }
1467 }
1468
1469 void
1470 xml_begin_item (void)
1471 {
1472   if (xml_in_item[xml_table_level])
1473     xml_insert_element (ITEM, END);
1474
1475   xml_insert_element (ITEM, START);
1476   xml_in_item[xml_table_level] = 1;
1477 }
1478
1479 void
1480 xml_begin_table_item (void)
1481 {
1482   if (!xml_after_table_term)
1483     {
1484       if (xml_in_item[xml_table_level])
1485         xml_insert_element (ITEM, END);
1486       if (xml_in_tableitem[xml_table_level])
1487         xml_insert_element (TABLEITEM, END);
1488
1489       if (in_table_title)
1490         {
1491           in_table_title = 0;
1492           xml_insert_element (TITLE, END);
1493         }
1494       xml_insert_element (TABLEITEM, START);
1495     }
1496   xml_insert_element (TABLETERM, START);
1497   xml_in_tableitem[xml_table_level] = 1;
1498   xml_in_item[xml_table_level] = 0;
1499   xml_after_table_term = 0;
1500 }
1501
1502 void
1503 xml_continue_table_item (void)
1504 {
1505   xml_insert_element (TABLETERM, END);
1506   xml_after_table_term = 1;
1507   xml_in_item[xml_table_level] = 0;
1508 }
1509
1510 void
1511 xml_begin_enumerate (char *enum_arg)
1512 {
1513   if (!docbook)
1514     xml_insert_element_with_attribute (ENUMERATE, START, "first=\"%s\"", enum_arg);
1515   else
1516     {
1517       if (isdigit (*enum_arg))
1518         {
1519           int enum_val = atoi (enum_arg);
1520
1521           /* Have to check the value, not just the first digit.  */
1522           if (enum_val == 0)
1523             xml_insert_element_with_attribute (ENUMERATE, START,
1524                 "numeration=\"arabic\" role=\"0\"", NULL);
1525           else if (enum_val == 1)
1526             xml_insert_element_with_attribute (ENUMERATE, START,
1527                 "numeration=\"arabic\"", NULL);
1528           else
1529             xml_insert_element_with_attribute (ENUMERATE, START,
1530                 "continuation=\"continues\" numeration=\"arabic\"", NULL);
1531         }
1532       else if (isupper (*enum_arg))
1533         {
1534           if (enum_arg[0] == 'A')
1535             xml_insert_element_with_attribute (ENUMERATE, START,
1536                 "numeration=\"upperalpha\"", NULL);
1537           else
1538             xml_insert_element_with_attribute (ENUMERATE, START,
1539                 "continuation=\"continues\" numeration=\"upperalpha\"", NULL);
1540         }
1541       else
1542         {
1543           if (enum_arg[0] == 'a')
1544             xml_insert_element_with_attribute (ENUMERATE, START,
1545                 "numeration=\"loweralpha\"", NULL);
1546           else
1547             xml_insert_element_with_attribute (ENUMERATE, START,
1548                 "continuation=\"continues\" numeration=\"loweralpha\"", NULL);
1549         }
1550     }
1551   xml_table_level ++;
1552   xml_in_item[xml_table_level] = 0;
1553 }
1554
1555 void
1556 xml_end_enumerate (void)
1557 {
1558   if (xml_in_item[xml_table_level])
1559     {
1560       xml_insert_element (ITEM, END);
1561       xml_in_item[xml_table_level] = 0;
1562     }
1563   xml_insert_element (ENUMERATE, END);
1564   xml_table_level --;
1565 }
1566
1567 static void
1568 xml_insert_text_file (char *name_arg)
1569 {
1570   char *fullname = xmalloc (strlen (name_arg) + 4 + 1);
1571   FILE *image_file;
1572   strcpy (fullname, name_arg);
1573   strcat (fullname, ".txt");
1574   image_file = fopen (fullname, "r");
1575   if (image_file)
1576     {
1577       int ch;
1578       int save_inhibit_indentation = inhibit_paragraph_indentation;
1579       int save_filling_enabled = filling_enabled;
1580
1581       xml_insert_element (TEXTOBJECT, START);
1582       xml_insert_element (DISPLAY, START);
1583
1584       inhibit_paragraph_indentation = 1;
1585       filling_enabled = 0;
1586       last_char_was_newline = 0;
1587
1588       /* Maybe we need to remove the final newline if the image
1589          file is only one line to allow in-line images.  On the
1590          other hand, they could just make the file without a
1591          final newline.  */
1592       while ((ch = getc (image_file)) != EOF)
1593         add_char (ch);
1594
1595       inhibit_paragraph_indentation = save_inhibit_indentation;
1596       filling_enabled = save_filling_enabled;
1597
1598       xml_insert_element (DISPLAY, END);
1599       xml_insert_element (TEXTOBJECT, END);
1600
1601       if (fclose (image_file) != 0)
1602         perror (fullname);
1603     }
1604   else
1605     warning (_("@image file `%s' unreadable: %s"), fullname,
1606              strerror (errno));
1607
1608   free (fullname);
1609 }
1610
1611 /* If NAME.EXT is accessible or FORCE is nonzero, insert a docbook
1612    imagedata element for FMT.  Return 1 if inserted something, 0 else.  */
1613
1614 static int
1615 try_docbook_image (const char *name, const char *ext, const char *fmt,
1616                    int force)
1617 {
1618   int used = 0;
1619   char *fullname = xmalloc (strlen (name) + 1 + strlen (ext) + 1);
1620   sprintf (fullname, "%s.%s", name, ext);
1621
1622   if (force || access (fullname, R_OK) == 0)
1623    {
1624      xml_insert_element (IMAGEOBJECT, START);
1625      xml_insert_element_with_attribute (IMAGEDATA, START,
1626        "fileref=\"%s\" format=\"%s\"", fullname, fmt);
1627      xml_insert_element (IMAGEDATA, END);
1628      xml_insert_element (IMAGEOBJECT, END);
1629      used = 1;
1630    }
1631
1632  free (fullname);
1633  return used;
1634 }
1635
1636
1637 void
1638 xml_insert_docbook_image (char *name_arg)
1639 {
1640   int found = 0;
1641   int elt = xml_in_para ? INLINEIMAGE : MEDIAOBJECT;
1642
1643   if (is_in_insertion_of_type (floatenv))
1644     xml_begin_docbook_float (INFORMALFIGURE);
1645   else if (!xml_in_para)
1646     xml_insert_element (INFORMALFIGURE, START);
1647
1648   xml_no_para++;
1649
1650   xml_insert_element (elt, START);
1651
1652   /* A selected few from http://docbook.org/tdg/en/html/imagedata.html.  */
1653   if (try_docbook_image (name_arg, "eps", "EPS", 0))
1654     found++;
1655   if (try_docbook_image (name_arg, "gif", "GIF", 0))
1656     found++;
1657   if (try_docbook_image (name_arg, "jpg", "JPG", 0))
1658     found++;
1659   if (try_docbook_image (name_arg, "jpeg", "JPEG", 0))
1660     found++;
1661   if (try_docbook_image (name_arg, "pdf", "PDF", 0))
1662     found++;
1663   if (try_docbook_image (name_arg, "png", "PNG", 0))
1664     found++;
1665   if (try_docbook_image (name_arg, "svg", "SVG", 0))
1666     found++;
1667
1668   /* If no luck so far, just assume we'll eventually have a jpg.  */
1669   if (!found)
1670     try_docbook_image (name_arg, "jpg", "JPG", 1);
1671
1672   xml_insert_text_file (name_arg);
1673   xml_insert_element (elt, END);
1674
1675   xml_no_para--;
1676
1677   if (elt == MEDIAOBJECT)
1678     xml_insert_element (INFORMALFIGURE, END);
1679 }
1680
1681 void
1682 xml_asterisk (void)
1683 {
1684 }
1685
1686
1687 /*
1688  *     INDEX
1689  */
1690 /* Used to separate primary and secondary entries in an index -- we need
1691    to have real multilivel indexing support, not just string analysis.  */
1692 #define INDEX_SEP "@this string will never appear@" /* was , */
1693
1694 typedef struct
1695 {
1696   char *from;
1697   char *to;
1698 } XML_SYNONYM;
1699
1700 static XML_SYNONYM **xml_synonyms = NULL;
1701 static int xml_synonyms_count = 0;
1702
1703 void
1704 xml_insert_indexterm (char *indexterm, char *index)
1705 {
1706   /* @index commands can appear between @item and @itemx, @deffn and @deffnx.  */
1707   if (!docbook)
1708     {
1709       /* Check to see if we need to do index redirection per @synindex.  */
1710       int i;
1711       for (i = 0; i < xml_synonyms_count; i++)
1712         {
1713           if (STREQ (xml_synonyms[i]->from, index))
1714             index = xstrdup (xml_synonyms[i]->to);
1715         }
1716
1717       xml_dont_touch_items_defs++;
1718       xml_insert_element_with_attribute (INDEXTERM, START, "index=\"%s\"", index);
1719       in_indexterm = 1;
1720       execute_string ("%s", indexterm);
1721       xml_insert_element (INDEXTERM, END);
1722       in_indexterm = 0;
1723       xml_dont_touch_items_defs--;
1724     }
1725   else
1726     {
1727       char *primary = NULL, *secondary = NULL;
1728       if (strstr (indexterm+1, INDEX_SEP))
1729         {
1730           primary = xmalloc (strlen (indexterm) + 1);
1731           strcpy (primary, indexterm);
1732           secondary = strstr (primary+1, INDEX_SEP);
1733           *secondary = '\0';
1734           secondary += strlen (INDEX_SEP);
1735         }
1736       xml_insert_element_with_attribute (INDEXTERM, START, "role=\"%s\"", index);
1737       in_indexterm = 1;
1738       xml_insert_element (PRIMARY, START);
1739       if (primary)
1740         execute_string ("%s", primary);
1741       else
1742         execute_string ("%s", indexterm);
1743       xml_insert_element (PRIMARY, END);
1744       if (primary)
1745         {
1746           xml_insert_element (SECONDARY, START);
1747           execute_string ("%s", secondary);
1748           xml_insert_element (SECONDARY, END);
1749         }
1750       xml_insert_element (INDEXTERM, END);
1751       in_indexterm = 0;
1752     }
1753 }
1754
1755
1756 int xml_last_section_output_position = 0;
1757 static char last_division_letter = ' ';
1758 static char index_primary[2000]; /** xx no fixed limit */
1759 static int indexdivempty = 0;
1760
1761 static void
1762 xml_close_indexentry (void)
1763 {
1764   if (!in_indexentry)
1765     return;
1766   if (in_secondary)
1767     xml_insert_element (SECONDARYIE, END);
1768   xml_insert_element (INDEXENTRY, END);
1769   in_secondary = 0;
1770   in_indexentry = 0;
1771 }
1772
1773 void
1774 xml_begin_index (void)
1775 {
1776   typedef struct xml_index_title {
1777       struct xml_index_title *next;
1778       char *title;
1779   } XML_INDEX_TITLE;
1780
1781   static XML_INDEX_TITLE *xml_index_titles = NULL;
1782
1783   if (!handling_delayed_writes)
1784     { /* We assume that we just opened a section, and so that the last output is
1785          <SECTION ID="node-name"><TITLE>Title</TITLE>
1786          where SECTION can be CHAPTER, ...  */
1787
1788       XML_INDEX_TITLE *new = xmalloc (sizeof (XML_INDEX_TITLE));
1789       xml_section *temp = last_section;
1790
1791       int l = output_paragraph_offset-xml_last_section_output_position;
1792       char *tmp = xmalloc (l+1);
1793       char *p = tmp;
1794       strncpy (tmp, (char *) output_paragraph, l);
1795
1796       /* We remove <SECTION */
1797       tmp[l] = '\0';
1798       while (*p != '<')
1799         p++;
1800       while (*p != ' ')
1801         p++;
1802       /* ... and its label attribute.  */
1803       if (strncmp (p, " label=", 7) == 0)
1804         {
1805           p++;
1806           while (*p != ' ')
1807             p++;
1808         }
1809
1810       output_paragraph_offset = xml_last_section_output_position;
1811       xml_last_section_output_position = 0;
1812
1813       xml_pop_current_element (); /* remove section element from elements stack */
1814
1815       if (last_section)
1816         last_section = last_section->prev; /* remove section from sections stack */
1817       if (temp)
1818         {
1819           free (temp->name);
1820           free (temp);
1821         }
1822
1823       new->title = xstrdup (p);
1824       new->next = xml_index_titles;
1825       xml_index_titles = new;
1826     }
1827   else
1828     {
1829       static int xml_index_titles_reversed = 0;
1830
1831       if (!xml_index_titles_reversed)
1832         {
1833           xml_index_titles = (XML_INDEX_TITLE *) reverse_list
1834             ((GENERIC_LIST *) xml_index_titles);
1835           xml_index_titles_reversed = 1;
1836         }
1837
1838       /* We put <INDEX> */
1839       xml_insert_element (PRINTINDEX, START);
1840       if (xml_index_titles)
1841         {
1842           /* Remove the final > */
1843           output_paragraph_offset--;
1844           /* and put  ID="node-name"><TITLE>Title</TITLE> */
1845           insert_string (xml_index_titles->title);
1846           free (xml_index_titles->title);
1847           xml_index_titles = xml_index_titles->next;
1848         }
1849
1850       if (xml_index_divisions)
1851         {
1852           xml_insert_element (INDEXDIV, START);
1853           indexdivempty = 1;
1854         }
1855     }
1856 }
1857
1858 void
1859 xml_end_index (void)
1860 {
1861   xml_close_indexentry ();
1862   if (xml_index_divisions)
1863     xml_insert_element (INDEXDIV, END);
1864   xml_insert_element (PRINTINDEX, END);
1865 }
1866
1867 static void
1868 xml_index_divide (char *entry)
1869 {
1870   char c;
1871   if (strlen (entry) > (strlen (xml_element_list[CODE].name) + 2) &&
1872       strncmp (entry+1, xml_element_list[CODE].name, strlen (xml_element_list[CODE].name)) == 0)
1873     c = entry[strlen (xml_element_list[CODE].name)+2];
1874   else
1875     c = entry[0];
1876   if (tolower (c) != last_division_letter && isalpha (c))
1877     {
1878       last_division_letter = tolower (c);
1879       xml_close_indexentry ();
1880       if (!indexdivempty)
1881         {
1882           xml_insert_element (INDEXDIV, END);
1883           xml_insert_element (INDEXDIV, START);
1884         }
1885       xml_insert_element (TITLE, START);
1886       insert (toupper (c));
1887       xml_insert_element (TITLE, END);
1888     }
1889 }
1890
1891 void
1892 xml_insert_indexentry (char *entry, char *node)
1893 {
1894   char *primary = NULL, *secondary;
1895   if (xml_index_divisions)
1896     xml_index_divide (entry);
1897
1898   indexdivempty = 0;
1899   if (strstr (entry+1, INDEX_SEP))
1900     {
1901       primary = xmalloc (strlen (entry) + 1);
1902       strcpy (primary, entry);
1903       secondary = strstr (primary+1, INDEX_SEP);
1904       *secondary = '\0';
1905       secondary += strlen (INDEX_SEP);
1906
1907       if (in_secondary && strcmp (primary, index_primary) == 0)
1908         {
1909           xml_insert_element (SECONDARYIE, END);
1910           xml_insert_element (SECONDARYIE, START);
1911           execute_string ("%s", secondary);
1912         }
1913       else
1914         {
1915           xml_close_indexentry ();
1916           xml_insert_element (INDEXENTRY, START);
1917           in_indexentry = 1;
1918           xml_insert_element (PRIMARYIE, START);
1919           execute_string ("%s", primary);
1920           xml_insert_element (PRIMARYIE, END);
1921           xml_insert_element (SECONDARYIE, START);
1922           execute_string ("%s", secondary);
1923           in_secondary = 1;
1924         }
1925     }
1926   else
1927     {
1928       xml_close_indexentry ();
1929       xml_insert_element (INDEXENTRY, START);
1930       in_indexentry = 1;
1931       xml_insert_element (PRIMARYIE, START);
1932       execute_string ("%s", entry);
1933     }
1934   add_word (", ");
1935
1936   /* Don't link to @unnumbered sections directly.
1937      We are disabling warnings temporarily, otherwise these xrefs
1938      will cause bogus warnings about missing punctuation.  */
1939   {
1940     extern int print_warnings;
1941     int save_print_warnings = print_warnings;
1942     print_warnings = 0;
1943     execute_string ("%cxref{%s}", COMMAND_PREFIX, xstrdup (node));
1944     print_warnings = save_print_warnings;
1945   }
1946
1947   if (primary)
1948     {
1949       strcpy (index_primary, primary);
1950       /*      xml_insert_element (SECONDARYIE, END);*/
1951       /*     *(secondary-1) = ',';*/ /* necessary ? */
1952       free (primary);
1953     }
1954   else
1955     xml_insert_element (PRIMARYIE, END);
1956
1957   /*  xml_insert_element (INDEXENTRY, END); */
1958 }
1959
1960 void
1961 xml_synindex (char *from, char *to)
1962 {
1963   int i, slot;
1964
1965   slot = -1;
1966   for (i = 0; i < xml_synonyms_count; i++)
1967     if (!xml_synonyms[i])
1968       {
1969         slot = i;
1970         break;
1971       }
1972
1973   if (slot < 0)
1974     {
1975       slot = xml_synonyms_count;
1976       xml_synonyms_count++;
1977
1978       xml_synonyms = (XML_SYNONYM **) xrealloc (xml_synonyms,
1979           (xml_synonyms_count + 1) * sizeof (XML_SYNONYM *));
1980     }
1981
1982   xml_synonyms[slot] = xmalloc (sizeof (XML_SYNONYM));
1983   xml_synonyms[slot]->from = xstrdup (from);
1984   xml_synonyms[slot]->to = xstrdup (to);
1985 }
1986
1987 /*
1988  * MULTITABLE
1989  */
1990
1991 static int multitable_columns_count;
1992 static int *multitable_column_widths;
1993
1994 void
1995 xml_begin_multitable (int ncolumns, int *column_widths)
1996 {
1997   int i;
1998   if (docbook)
1999     {
2000       if (is_in_insertion_of_type (floatenv))
2001         xml_begin_docbook_float (MULTITABLE);
2002       else
2003         xml_insert_element (MULTITABLE, START);
2004
2005       multitable_columns_count = ncolumns;
2006       multitable_column_widths = xmalloc (sizeof (int) * ncolumns);
2007       memcpy (multitable_column_widths, column_widths,
2008           sizeof (int) * ncolumns);
2009
2010       xml_no_para = 1;
2011     }
2012   else
2013     {
2014       xml_insert_element (MULTITABLE, START);
2015       for (i=0; i<ncolumns; i++)
2016         {
2017           xml_insert_element (COLSPEC, START);
2018           add_word_args ("%d", column_widths[i]);
2019           xml_insert_element (COLSPEC, END);
2020         }
2021       xml_no_para = 1;
2022     }
2023 }
2024
2025 static void
2026 xml_begin_multitable_group (void)
2027 {
2028   int i;
2029
2030   xml_insert_element_with_attribute (TGROUP, START, "cols=\"%d\"",
2031       multitable_columns_count);
2032
2033   for (i=0; i < multitable_columns_count; i++)
2034     {
2035       xml_insert_element_with_attribute (COLSPEC, START,
2036           "colwidth=\"%d*\"", multitable_column_widths[i]);
2037       xml_insert_element (COLSPEC, END);
2038     }
2039 }
2040
2041 void
2042 xml_end_multitable_row (int first_row)
2043 {
2044   if (!first_row)
2045     {
2046       xml_insert_element (ENTRY, END);
2047       xml_insert_element (ROW, END);
2048     }
2049
2050   if (headitem_flag)
2051     {
2052       if (!first_row)
2053         {
2054           if (after_headitem)
2055             xml_insert_element (THEAD, END);
2056           else
2057             xml_insert_element (TBODY, END);
2058           xml_insert_element (TGROUP, END);
2059         }
2060
2061       xml_begin_multitable_group ();
2062       xml_insert_element (THEAD, START);
2063     }
2064   else if (first_row)
2065     {
2066       xml_begin_multitable_group ();
2067       xml_insert_element (TBODY, START);
2068     }
2069   else if (after_headitem)
2070     {
2071       xml_insert_element (THEAD, END);
2072       xml_insert_element (TBODY, START);
2073     }
2074   else if (first_row)
2075     xml_insert_element (TBODY, START);
2076
2077   xml_insert_element (ROW, START);
2078   xml_insert_element (ENTRY, START);
2079 }
2080
2081 void
2082 xml_end_multitable_column (void)
2083 {
2084   xml_insert_element (ENTRY, END);
2085   xml_insert_element (ENTRY, START);
2086 }
2087
2088 void
2089 xml_end_multitable (void)
2090 {
2091   xml_insert_element (ENTRY, END);
2092   xml_insert_element (ROW, END);
2093
2094   if (after_headitem)
2095     {
2096       if (docbook)
2097         warning (_("@headitem as the last item of @multitable produces invalid Docbook documents"));
2098       xml_insert_element (THEAD, END);
2099     }
2100   else
2101     xml_insert_element (TBODY, END);
2102
2103   if (docbook)
2104     xml_insert_element (TGROUP, END);
2105
2106   xml_insert_element (MULTITABLE, END);
2107   xml_no_para = 0;
2108 }
2109
2110 /*
2111  * Parameters in @def definitions
2112  */
2113
2114 #define DEFUN_SELF_DELIMITING(c) \
2115   ((c) == '(' || (c) == ')' || (c) == '[' || (c) == ']')
2116
2117 void
2118 xml_process_defun_args (char **defun_args, int auto_var_p)
2119 {
2120   int pending_space = 0;
2121   int just_after_paramtype = 0;
2122
2123   for (;;)
2124     {
2125       char *defun_arg = *defun_args++;
2126
2127       if (defun_arg == NULL)
2128         break;
2129
2130       if (defun_arg[0] == ' ')
2131         {
2132           pending_space = 1;
2133           continue;
2134         }
2135
2136       if (pending_space)
2137         {
2138           add_char (' ');
2139           pending_space = 0;
2140         }
2141
2142       if (DEFUN_SELF_DELIMITING (defun_arg[0]))
2143         {
2144           xml_insert_element (DEFDELIMITER, START);
2145           add_char (defun_arg[0]);
2146           xml_insert_element (DEFDELIMITER, END);
2147           just_after_paramtype = 0;
2148         }
2149       else if (defun_arg[0] == '&')
2150         {
2151           xml_insert_element (DEFPARAM, START);
2152           add_word (defun_arg);
2153           xml_insert_element (DEFPARAM, END);
2154           just_after_paramtype = 0;
2155         }
2156       else if (defun_arg[0] == COMMAND_PREFIX || just_after_paramtype)
2157         {
2158           xml_insert_element (DEFPARAM, START);
2159           execute_string ("%s", defun_arg);
2160           xml_insert_element (DEFPARAM, END);
2161           just_after_paramtype = 0;
2162         }
2163       else if (defun_arg[0] == ',' || defun_arg[0] == ';')
2164         {
2165           xml_insert_element (DEFDELIMITER, START);
2166           add_word (defun_arg);
2167           xml_insert_element (DEFDELIMITER, END);
2168           just_after_paramtype = 0;
2169         }
2170       else if (auto_var_p)
2171         {
2172           xml_insert_element (DEFPARAM, START);
2173           add_word (defun_arg);
2174           xml_insert_element (DEFPARAM, END);
2175           just_after_paramtype = 0;
2176         }
2177       else
2178         {
2179           xml_insert_element (DEFPARAMTYPE, START);
2180           add_word (defun_arg);
2181           xml_insert_element (DEFPARAMTYPE, END);
2182           just_after_paramtype = 1;
2183         }
2184     }
2185 }
2186
2187 void
2188 xml_begin_definition (void)
2189 {
2190   xml_insert_element (DEFINITION, START);
2191   xml_definition_level ++;
2192   xml_in_def_item[xml_definition_level] = 0;
2193 }
2194
2195 void
2196 xml_end_definition (void)
2197 {
2198   if (xml_in_def_item[xml_definition_level])
2199     {
2200       xml_insert_element (DEFINITIONITEM, END);
2201       xml_in_def_item[xml_definition_level] = 0;
2202     }
2203   xml_after_def_term = 0;
2204   xml_insert_element (DEFINITION, END);
2205   xml_definition_level --;
2206 }
2207
2208 void
2209 xml_begin_def_term (int base_type, const char *category,
2210     char *defined_name, char *type_name, char *type_name2)
2211 {
2212   xml_after_def_term = 0;
2213   xml_insert_element (DEFINITIONTERM, START);
2214
2215   /* Index entry */
2216   switch (base_type)
2217     {
2218     case deffn:
2219     case deftypefn:
2220       execute_string ("@findex %s\n", defined_name);
2221       break;
2222     case defvr:
2223     case deftypevr:
2224     case defcv:
2225       execute_string ("@vindex %s\n", defined_name);
2226       break;
2227     case deftypecv:
2228     case deftypeivar:
2229       execute_string ("@vindex %s %s %s\n", defined_name, _("of"), type_name);
2230       break;
2231     case deftypemethod:
2232     case defop:
2233     case deftypeop:
2234       execute_string ("@findex %s %s %s\n", defined_name, _("on"), type_name);
2235       break;
2236     case deftp:
2237       execute_string ("@tindex %s\n", defined_name);
2238       break;
2239     }
2240
2241   /* Start with category.  */
2242   xml_insert_element (DEFCATEGORY, START);
2243   execute_string (docbook ? "--- %s:" : "%s", category);
2244   xml_insert_element (DEFCATEGORY, END);
2245   add_char(' ');
2246
2247   /* Output type name first for typed definitions.  */
2248   switch (base_type)
2249     {
2250     case deffn:
2251     case defvr:
2252     case deftp:
2253       break;
2254
2255     case deftypefn:
2256     case deftypevr:
2257       xml_insert_element (DEFTYPE, START);
2258       execute_string ("%s", type_name);
2259       xml_insert_element (DEFTYPE, END);
2260       add_char (' ');
2261       break;
2262
2263     case deftypecv:
2264     case deftypeivar:
2265     case deftypemethod:
2266     case deftypeop:
2267       xml_insert_element (DEFTYPE, START);
2268       execute_string ("%s", type_name2);
2269       xml_insert_element (DEFTYPE, END);
2270       add_char (' ');
2271       break;
2272
2273     default:
2274       xml_insert_element (DEFCLASS, START);
2275       execute_string ("%s", type_name);
2276       xml_insert_element (DEFCLASS, END);
2277       add_char (' ');
2278       break;
2279     }
2280
2281   /* Categorize rest of the definitions.  */
2282   switch (base_type)
2283     {
2284     case deffn:
2285     case deftypefn:
2286       xml_insert_element (DEFFUNCTION, START);
2287       execute_string ("%s", defined_name);
2288       xml_insert_element (DEFFUNCTION, END);
2289       break;
2290
2291     case defvr:
2292     case deftypevr:
2293       xml_insert_element (DEFVARIABLE, START);
2294       execute_string ("%s", defined_name);
2295       xml_insert_element (DEFVARIABLE, END);
2296       break;
2297
2298     case deftp:
2299       xml_insert_element (DEFDATATYPE, START);
2300       execute_string ("%s", defined_name);
2301       xml_insert_element (DEFDATATYPE, END);
2302       break;
2303
2304     case defcv:
2305     case deftypecv:
2306     case deftypeivar:
2307       xml_insert_element (DEFCLASSVAR, START);
2308       execute_string ("%s", defined_name);
2309       xml_insert_element (DEFCLASSVAR, END);
2310       break;
2311
2312     case defop:
2313     case deftypeop:
2314     case deftypemethod:
2315       /* Operation / Method */
2316       xml_insert_element (DEFOPERATION, START);
2317       execute_string ("%s", defined_name);
2318       xml_insert_element (DEFOPERATION, END);
2319       break;
2320     }
2321 }
2322
2323 void
2324 xml_end_def_term (void)
2325 {
2326   xml_insert_element (DEFINITIONTERM, END);
2327   xml_after_def_term = 1;
2328 }