Back to index

tetex-bin  3.0
Classes | Defines | Typedefs | Functions | Variables
xml.c File Reference
#include "system.h"
#include "makeinfo.h"
#include "insertion.h"
#include "files.h"
#include "float.h"
#include "macro.h"
#include "cmds.h"
#include "lang.h"
#include "xml.h"

Go to the source code of this file.

Classes

struct  _element
struct  _replace_element
struct  _xml_section
struct  quotation_elt
struct  XML_SYNONYM

Defines

#define INDEX_SEP   "@this string will never appear@" /* was , */
#define DEFUN_SELF_DELIMITING(c)   ((c) == '(' || (c) == ')' || (c) == '[' || (c) == ']')

Typedefs

typedef struct _element element
typedef struct _replace_element replace_element
typedef struct _xml_section
typedef struct quotation_elt QUOTATION_ELT

Functions

char * xml_id (char *id)
int xml_element (char *name)
void xml_begin_document (char *output_filename)
static int xml_current_element (void)
static void xml_push_current_element (int elt)
static void xml_pop_current_element (void)
int xml_current_stack_index (void)
void xml_end_current_element (void)
static void xml_indent (void)
void xml_start_para (void)
void xml_end_para (void)
void xml_end_document (void)
void xml_insert_element_with_attribute (int elt, int arg, char *format, va_alist)
void xml_insert_element (int elt, int arg)
void xml_insert_entity (char *entity_name)
void xml_begin_node (void)
void xml_close_sections (int level)
void xml_open_section (int level, char *name)
void xml_start_menu_entry (char *tem)
void xml_end_menu (void)
void xml_add_char (int character)
void xml_insert_footnote (char *note)
void xml_insert_quotation (char *type, int arg)
void xml_begin_docbook_float (int elt)
void xml_begin_table (int type, char *item_function)
void xml_end_table (int type)
void xml_begin_item (void)
void xml_begin_table_item (void)
void xml_continue_table_item (void)
void xml_begin_enumerate (char *enum_arg)
void xml_end_enumerate (void)
static void xml_insert_text_file (char *name_arg)
static int try_docbook_image (const char *name, const char *ext, const char *fmt, int force)
void xml_insert_docbook_image (char *name_arg)
void xml_asterisk (void)
void xml_insert_indexterm (char *indexterm, char *index)
static void xml_close_indexentry (void)
void xml_begin_index (void)
void xml_end_index (void)
static void xml_index_divide (char *entry)
void xml_insert_indexentry (char *entry, char *node)
void xml_synindex (char *from, char *to)
void xml_begin_multitable (int ncolumns, int *column_widths)
static void xml_begin_multitable_group (void)
void xml_end_multitable_row (int first_row)
void xml_end_multitable_column (void)
void xml_end_multitable (void)
void xml_process_defun_args (char **defun_args, int auto_var_p)
void xml_begin_definition (void)
void xml_end_definition (void)
void xml_begin_def_term (int base_type, const char *category, char *defined_name, char *type_name, char *type_name2)
void xml_end_def_term (void)

Variables

int xml_index_divisions = 1
element texinfoml_element_list []
element docbook_element_list []
elementxml_element_list = NULL
replace_element replace_elements []
int xml_in_menu_entry = 0
int xml_in_menu_entry_comment = 0
int xml_node_open = 0
int xml_node_level = -1
int xml_in_para = 0
int xml_just_after_element = 0
int xml_keep_space = 0
int xml_no_indent = 0
int xml_no_para = 0
char * xml_node_id = NULL
int xml_sort_index = 0
int xml_in_xref_token = 0
int xml_in_bookinfo = 0
int xml_in_book_title = 0
int xml_in_abstract = 0
int xml_dont_touch_items_defs = 0
static int xml_in_footnote = 0
static int xml_after_table_term = 0
static int book_started = 0
static int first_section_opened = 0
static int xml_in_tableitem [256]
static int xml_in_item [256]
static int xml_table_level = 0
static int xml_in_def_item [256]
static int xml_definition_level = 0
int xml_after_def_term = 0
static int in_table_title = 0
static int in_indexentry = 0
static int in_secondary = 0
static int in_indexterm = 0
static int element_stack [256]
static int element_stack_index = 0
static int start_element_inserted = 1
xml_section * last_section = NULL
static int xml_last_character
static QUOTATION_ELTquotation_stack = NULL
static XML_SYNONYM ** xml_synonyms = NULL
static int xml_synonyms_count = 0
int xml_last_section_output_position = 0
static char last_division_letter = ' '
static char index_primary [2000]
static int indexdivempty = 0
 xx no fixed limit
static int multitable_columns_count
static intmultitable_column_widths

Class Documentation

struct _element

Definition at line 36 of file xml.c.

Class Members
int contained_in_para
int contains_para
int keep_space
char name
struct _replace_element

Definition at line 471 of file xml.c.

Class Members
int element_containing
int element_replacing
int element_to_replace
struct _xml_section

Definition at line 1016 of file xml.c.

Class Members
int level
char * name
xml_section * prev
struct quotation_elt

Definition at line 1283 of file xml.c.

Collaboration diagram for quotation_elt:
Class Members
struct quotation_elt * next
char * type
struct XML_SYNONYM

Definition at line 1694 of file xml.c.

Class Members
char * from
char * to

Define Documentation

#define DEFUN_SELF_DELIMITING (   c)    ((c) == '(' || (c) == ')' || (c) == '[' || (c) == ']')

Definition at line 2114 of file xml.c.

#define INDEX_SEP   "@this string will never appear@" /* was , */

Definition at line 1692 of file xml.c.


Typedef Documentation

typedef struct _xml_section

Definition at line 1015 of file xml.c.

typedef struct _element element
typedef struct quotation_elt QUOTATION_ELT

Function Documentation

static int try_docbook_image ( const char *  name,
const char *  ext,
const char *  fmt,
int  force 
) [static]

Definition at line 1615 of file xml.c.

{
  int used = 0;
  char *fullname = xmalloc (strlen (name) + 1 + strlen (ext) + 1);
  sprintf (fullname, "%s.%s", name, ext);

  if (force || access (fullname, R_OK) == 0)
   {
     xml_insert_element (IMAGEOBJECT, START);
     xml_insert_element_with_attribute (IMAGEDATA, START,
       "fileref=\"%s\" format=\"%s\"", fullname, fmt);
     xml_insert_element (IMAGEDATA, END);
     xml_insert_element (IMAGEOBJECT, END);
     used = 1;
   }
 
 free (fullname);
 return used;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_add_char ( int  character)

Definition at line 1165 of file xml.c.

{
  if (!book_started)
      return;
  if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
    return;

  if (docbook && xml_table_level && !in_table_title
      && !xml_in_item[xml_table_level] && !xml_in_tableitem[xml_table_level]
      && !cr_or_whitespace (character) && !in_indexterm)
    {
      in_table_title = 1;
      xml_insert_element (TITLE, START);
    }

  if (!first_section_opened && !xml_in_abstract && !xml_in_book_title
      && !xml_no_para && character != '\r' && character != '\n'
      && character != ' ' && !is_in_insertion_of_type (copying))
    {
      if (!xml_in_bookinfo)
       {
         xml_insert_element (BOOKINFO, START);
         xml_in_bookinfo = 1;
       }
      xml_insert_element (ABSTRACT, START);
      xml_in_abstract = 1;
    }

  if (!xml_sort_index && !xml_in_xref_token && !xml_dont_touch_items_defs)
    {
      if (xml_after_table_term && xml_table_level
          && !xml_in_item[xml_table_level])
        {
          xml_after_table_term = 0;
          xml_insert_element (ITEM, START);
          xml_in_item[xml_table_level] = 1;
        }
      else if (xml_after_def_term)
        {
          xml_after_def_term = 0;
          xml_insert_element (DEFINITIONITEM, START);
          xml_in_def_item[xml_definition_level] = 1;
        }
    }

  if (xml_just_after_element && !xml_in_para && !inhibit_paragraph_indentation)
    {
      if (character == '\r' || character == '\n' || character == '\t' || character == ' ')
        return;
      xml_just_after_element = 0;
    }

  if (xml_element_list[xml_current_element()].contains_para
      && !xml_in_para && !only_macro_expansion && !xml_no_para
      && !cr_or_whitespace (character) && !in_fixed_width_font)
    xml_start_para ();

  if (xml_in_para && character == '\n' && xml_last_character == '\n'
      && !only_macro_expansion && !xml_no_para
      && xml_element_list[xml_current_element()].contains_para )
    {
      xml_end_para ();
      xml_just_after_element = 1;
      return;
    }

  if (xml_in_menu_entry_comment && character == '\n' && xml_last_character == '\n')
    {
      xml_insert_element (MENUCOMMENT, END);
      xml_in_menu_entry_comment = 0;
      xml_insert_element (MENUENTRY, END);
      xml_in_menu_entry = 0;
    }

  if (xml_in_menu_entry_comment && whitespace(character)
      && cr_or_whitespace(xml_last_character))
    return;

  if (character == '\n' && !xml_in_para && !inhibit_paragraph_indentation)
    return;

  xml_last_character = character;

  if (character == '&' && escape_html)
      insert_string ("&");
  else if (character == '<' && escape_html)
      insert_string ("&lt;");
  else if (character == '\n' && !xml_keep_space)
    {
      if (!xml_in_para && xml_just_after_element && !multitable_active)
       return;
      else
       insert (docbook ? '\n' : ' ');
    }
  else
    insert (character);

  return;
}

Here is the call graph for this function:

Definition at line 1682 of file xml.c.

{
}

Here is the caller graph for this function:

void xml_begin_def_term ( int  base_type,
const char *  category,
char *  defined_name,
char *  type_name,
char *  type_name2 
)

Definition at line 2209 of file xml.c.

{
  xml_after_def_term = 0;
  xml_insert_element (DEFINITIONTERM, START);

  /* Index entry */
  switch (base_type)
    {
    case deffn:
    case deftypefn:
      execute_string ("@findex %s\n", defined_name);
      break;
    case defvr:
    case deftypevr:
    case defcv:
      execute_string ("@vindex %s\n", defined_name);
      break;
    case deftypecv:
    case deftypeivar:
      execute_string ("@vindex %s %s %s\n", defined_name, _("of"), type_name);
      break;
    case deftypemethod:
    case defop:
    case deftypeop:
      execute_string ("@findex %s %s %s\n", defined_name, _("on"), type_name);
      break;
    case deftp:
      execute_string ("@tindex %s\n", defined_name);
      break;
    }

  /* Start with category.  */
  xml_insert_element (DEFCATEGORY, START);
  execute_string (docbook ? "--- %s:" : "%s", category);
  xml_insert_element (DEFCATEGORY, END);
  add_char(' ');

  /* Output type name first for typed definitions.  */
  switch (base_type)
    {
    case deffn:
    case defvr:
    case deftp:
      break;

    case deftypefn:
    case deftypevr:
      xml_insert_element (DEFTYPE, START);
      execute_string ("%s", type_name);
      xml_insert_element (DEFTYPE, END);
      add_char (' ');
      break;

    case deftypecv:
    case deftypeivar:
    case deftypemethod:
    case deftypeop:
      xml_insert_element (DEFTYPE, START);
      execute_string ("%s", type_name2);
      xml_insert_element (DEFTYPE, END);
      add_char (' ');
      break;

    default:
      xml_insert_element (DEFCLASS, START);
      execute_string ("%s", type_name);
      xml_insert_element (DEFCLASS, END);
      add_char (' ');
      break;
    }

  /* Categorize rest of the definitions.  */
  switch (base_type)
    {
    case deffn:
    case deftypefn:
      xml_insert_element (DEFFUNCTION, START);
      execute_string ("%s", defined_name);
      xml_insert_element (DEFFUNCTION, END);
      break;

    case defvr:
    case deftypevr:
      xml_insert_element (DEFVARIABLE, START);
      execute_string ("%s", defined_name);
      xml_insert_element (DEFVARIABLE, END);
      break;

    case deftp:
      xml_insert_element (DEFDATATYPE, START);
      execute_string ("%s", defined_name);
      xml_insert_element (DEFDATATYPE, END);
      break;

    case defcv:
    case deftypecv:
    case deftypeivar:
      xml_insert_element (DEFCLASSVAR, START);
      execute_string ("%s", defined_name);
      xml_insert_element (DEFCLASSVAR, END);
      break;

    case defop:
    case deftypeop:
    case deftypemethod:
      /* Operation / Method */
      xml_insert_element (DEFOPERATION, START);
      execute_string ("%s", defined_name);
      xml_insert_element (DEFOPERATION, END);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2188 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1348 of file xml.c.

{
  if (current_float_used_title ()) /* in a nested float */
    {
      xml_insert_element (elt, START);    /* just insert the tag */
      return;
    }


  /* OK, need the title, tag, etc. */
  if (elt == CARTOUCHE)    /* no labels on <sidebar> */
    {
       if (strlen (current_float_id ()) == 0)
          xml_insert_element (elt, START);
       else
          xml_insert_element_with_attribute (elt, START,
              "id=\"%s\"", xml_id (current_float_id ()));
    }
  else if (strlen (current_float_id ()) == 0)
    xml_insert_element_with_attribute (elt, START, "label=\"\"");
  else
    xml_insert_element_with_attribute (elt, START,
        "id=\"%s\" label=\"%s\"", xml_id (current_float_id ()),
        current_float_number ());

  xml_insert_element (TITLE, START);
  execute_string ("%s", current_float_title ());
  xml_insert_element (TITLE, END);

  current_float_set_title_used (); /* mark this title, tag, etc used */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_begin_document ( char *  output_filename)

Definition at line 596 of file xml.c.

{
  if (book_started)
    return;

  book_started = 1;

  /* Make sure this is the very first string of the output document.  */
  output_paragraph_offset = 0;

  insert_string ("<?xml version=\"1.0\"");

  /* At this point, we register a delayed writing for document encoding,
     so in the end, proper encoding attribute will be inserted here.
     Since the user is unaware that we are implicitly executing this
     command, we should disable warnings temporarily, in order to avoid
     possible confusion.  (ie. if the output is not seekable,
     register_delayed_write issues a warning.)  */
  {
    extern int print_warnings;
    int save_print_warnings = print_warnings;
    print_warnings = 0;
    register_delayed_write ("@documentencoding");
    print_warnings = save_print_warnings;
  }

  insert_string ("?>\n");

  if (docbook)
    {
      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]>");
      xml_element_list = docbook_element_list;
    }
  else
    {
      insert_string ("<!DOCTYPE texinfo PUBLIC \"-//GNU//DTD TexinfoML V");
      insert_string (VERSION);
      insert_string ("//EN\" \"http://www.gnu.org/software/texinfo/dtd/");
      insert_string (VERSION);
      insert_string ("/texinfo.dtd\">");
      xml_element_list = texinfoml_element_list;
    }
  if (language_code != last_language_code)
    {
      if (docbook)
        xml_insert_element_with_attribute (TEXINFO, START, "lang=\"%s\"", language_table[language_code].abbrev);
      else
       xml_insert_element_with_attribute (TEXINFO, START, "xml:lang=\"%s\"", language_table[language_code].abbrev);
    }
  if (!docbook)
    {
      xml_insert_element (SETFILENAME, START);
      insert_string (output_filename);
      xml_insert_element (SETFILENAME, END);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_begin_enumerate ( char *  enum_arg)

Definition at line 1511 of file xml.c.

{
  if (!docbook)
    xml_insert_element_with_attribute (ENUMERATE, START, "first=\"%s\"", enum_arg);
  else
    {
      if (isdigit (*enum_arg))
        {
          int enum_val = atoi (enum_arg);

          /* Have to check the value, not just the first digit.  */
          if (enum_val == 0)
            xml_insert_element_with_attribute (ENUMERATE, START,
                "numeration=\"arabic\" role=\"0\"", NULL);
          else if (enum_val == 1)
            xml_insert_element_with_attribute (ENUMERATE, START,
                "numeration=\"arabic\"", NULL);
          else
            xml_insert_element_with_attribute (ENUMERATE, START,
                "continuation=\"continues\" numeration=\"arabic\"", NULL);
        }
      else if (isupper (*enum_arg))
        {
          if (enum_arg[0] == 'A')
            xml_insert_element_with_attribute (ENUMERATE, START,
                "numeration=\"upperalpha\"", NULL);
          else
            xml_insert_element_with_attribute (ENUMERATE, START,
                "continuation=\"continues\" numeration=\"upperalpha\"", NULL);
        }
      else
        {
          if (enum_arg[0] == 'a')
            xml_insert_element_with_attribute (ENUMERATE, START,
                "numeration=\"loweralpha\"", NULL);
          else
            xml_insert_element_with_attribute (ENUMERATE, START,
                "continuation=\"continues\" numeration=\"loweralpha\"", NULL);
        }
    }
  xml_table_level ++;
  xml_in_item[xml_table_level] = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1774 of file xml.c.

{
  typedef struct xml_index_title {
      struct xml_index_title *next;
      char *title;
  } XML_INDEX_TITLE;

  static XML_INDEX_TITLE *xml_index_titles = NULL;

  if (!handling_delayed_writes)
    { /* We assume that we just opened a section, and so that the last output is
         <SECTION ID="node-name"><TITLE>Title</TITLE>
         where SECTION can be CHAPTER, ...  */

      XML_INDEX_TITLE *new = xmalloc (sizeof (XML_INDEX_TITLE));
      xml_section *temp = last_section;

      int l = output_paragraph_offset-xml_last_section_output_position;
      char *tmp = xmalloc (l+1);
      char *p = tmp;
      strncpy (tmp, (char *) output_paragraph, l);

      /* We remove <SECTION */
      tmp[l] = '\0';
      while (*p != '<')
        p++;
      while (*p != ' ')
        p++;
      /* ... and its label attribute.  */
      if (strncmp (p, " label=", 7) == 0)
        {
          p++;
          while (*p != ' ')
            p++;
        }

      output_paragraph_offset = xml_last_section_output_position;
      xml_last_section_output_position = 0;

      xml_pop_current_element (); /* remove section element from elements stack */

      if (last_section)
        last_section = last_section->prev; /* remove section from sections stack */
      if (temp)
        {
          free (temp->name);
          free (temp);
        }

      new->title = xstrdup (p);
      new->next = xml_index_titles;
      xml_index_titles = new;
    }
  else
    {
      static int xml_index_titles_reversed = 0;

      if (!xml_index_titles_reversed)
        {
          xml_index_titles = (XML_INDEX_TITLE *) reverse_list
            ((GENERIC_LIST *) xml_index_titles);
          xml_index_titles_reversed = 1;
        }

      /* We put <INDEX> */
      xml_insert_element (PRINTINDEX, START);
      if (xml_index_titles)
        {
          /* Remove the final > */
          output_paragraph_offset--;
          /* and put  ID="node-name"><TITLE>Title</TITLE> */
          insert_string (xml_index_titles->title);
          free (xml_index_titles->title);
          xml_index_titles = xml_index_titles->next;
        }

      if (xml_index_divisions)
        {
          xml_insert_element (INDEXDIV, START);
          indexdivempty = 1;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1470 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_begin_multitable ( int  ncolumns,
int column_widths 
)

Definition at line 1995 of file xml.c.

{
  int i;
  if (docbook)
    {
      if (is_in_insertion_of_type (floatenv))
        xml_begin_docbook_float (MULTITABLE);
      else
        xml_insert_element (MULTITABLE, START);

      multitable_columns_count = ncolumns;
      multitable_column_widths = xmalloc (sizeof (int) * ncolumns);
      memcpy (multitable_column_widths, column_widths,
          sizeof (int) * ncolumns);

      xml_no_para = 1;
    }
  else
    {
      xml_insert_element (MULTITABLE, START);
      for (i=0; i<ncolumns; i++)
        {
          xml_insert_element (COLSPEC, START);
          add_word_args ("%d", column_widths[i]);
          xml_insert_element (COLSPEC, END);
        }
      xml_no_para = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_begin_multitable_group ( void  ) [static]

Definition at line 2026 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1025 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_begin_table ( int  type,
char *  item_function 
)

Definition at line 1384 of file xml.c.

{
  switch (type)
    {
    case ftable:
    case vtable:
    case table:
      /*if (docbook)*/ /* 05-08 */
        {
          xml_insert_element (TABLE, START);
          xml_table_level ++;
          xml_in_tableitem[xml_table_level] = 0;
          xml_in_item[xml_table_level] = 0;
          xml_after_table_term = 0;
        }
      break;
    case itemize:
      if (!docbook)
        {
          xml_insert_element (ITEMIZE, START);
          xml_table_level ++;
          xml_in_item[xml_table_level] = 0;
          xml_insert_element (ITEMFUNCTION, START);
          if (*item_function == COMMAND_PREFIX
              && item_function[strlen (item_function) - 1] != '}'
              && command_needs_braces (item_function + 1))
            execute_string ("%s{}", item_function);
          else
            execute_string ("%s", item_function);
          xml_insert_element (ITEMFUNCTION, END);
        }
      else
        {
          xml_insert_element_with_attribute (ITEMIZE, START,
                                             "mark=\"%s\"",
                                             (*item_function == COMMAND_PREFIX) ?
                                             &item_function[1] : item_function);
          xml_table_level ++;
          xml_in_item[xml_table_level] = 0;
        }
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1480 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_close_indexentry ( void  ) [static]

Definition at line 1762 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1052 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1503 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static int xml_current_element ( void  ) [static]

Definition at line 658 of file xml.c.

Here is the caller graph for this function:

Definition at line 684 of file xml.c.

{
  return element_stack_index;
}
int xml_element ( char *  name)

Definition at line 583 of file xml.c.

{
  int i;
  for (i=0; i<=PARA; i++)
    {
      if (strcasecmp (name, texinfoml_element_list[i].name) == 0)
        return i;
    }
  printf ("Error xml_element\n");
  return -1;
}

Here is the call graph for this function:

Definition at line 690 of file xml.c.

Here is the call graph for this function:

Definition at line 2324 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2196 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 743 of file xml.c.

{
  if (xml_node_open)
    {
      if (xml_node_level != -1)
        {
          xml_close_sections (xml_node_level);
          xml_node_level = -1;
        }
      xml_insert_element (NODE, END);
    }
  else
    xml_close_sections (xml_node_level);

  xml_insert_element (TEXINFO, END);
  if (xml_indentation_increment == 0)
    insert ('\n');
  insert_string ("<!-- Keep this comment at the end of the file\n\
Local variables:\n\
mode: sgml\n\
sgml-indent-step:1\n\
sgml-indent-data:nil\n\
End:\n\
-->\n");
  if (element_stack_index != 0)
    error ("Element stack index : %d\n", element_stack_index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1556 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1859 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1147 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2089 of file xml.c.

{
  xml_insert_element (ENTRY, END);
  xml_insert_element (ROW, END);

  if (after_headitem)
    {
      if (docbook)
        warning (_("@headitem as the last item of @multitable produces invalid Docbook documents"));
      xml_insert_element (THEAD, END);
    }
  else
    xml_insert_element (TBODY, END);

  if (docbook)
    xml_insert_element (TGROUP, END);

  xml_insert_element (MULTITABLE, END);
  xml_no_para = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2082 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 728 of file xml.c.

{
  if (!xml_in_para || xml_in_footnote)
    return;

  while (cr_or_whitespace(output_paragraph[output_paragraph_offset-1]))
    output_paragraph_offset--;

  insert_string ("</para>");
  if (xml_indentation_increment > 0)
    insert ('\n');
  xml_in_para = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_end_table ( int  type)

Definition at line 1429 of file xml.c.

{
  switch (type)
    {
    case ftable:
    case vtable:
    case table:
      if (xml_in_item[xml_table_level])
        {
          xml_insert_element (ITEM, END);
          xml_in_item[xml_table_level] = 0;
        }
      if (xml_in_tableitem[xml_table_level])
        {
          xml_insert_element (TABLEITEM, END);
          xml_in_tableitem[xml_table_level] = 0;
        }
      xml_insert_element (TABLE, END);
      xml_after_table_term = 0;
      xml_table_level --;

      break;
    case itemize:
      if (xml_in_item[xml_table_level])
        {
          xml_insert_element (ITEM, END);
          xml_in_item[xml_table_level] = 0;
        }
      /* gnat-style manual contains an itemized list without items! */
      if (in_table_title)
       {
         xml_insert_element (TITLE, END);
         in_table_title = 0;
       }
      xml_insert_element (ITEMIZE, END);
      xml_table_level --;
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* xml_id ( char *  id)

Definition at line 562 of file xml.c.

{
  char *tem = xmalloc (strlen (id) + 1);
  char *p = tem;
  strcpy (tem, id);
  while (*p)
    { /* Check if a character is allowed in ID attributes.  This list differs
         slightly from XML specs that it doesn't contain underscores.
         See http://xml.coverpages.org/sgmlsyn/sgmlsyn.htm, ``9.3 Name''  */
      if (!strchr ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-.", *p))
        *p = '-';
      p++;
    }
  p = tem;
  /* First character can only be a letter.  */
  if (!strchr ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", *p))
    *p = 'i';
  return tem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_indent ( void  ) [static]

Definition at line 696 of file xml.c.

{
  if (xml_indentation_increment > 0)
    {
      int i;
      if (output_paragraph[output_paragraph_offset-1] != '\n')
        insert ('\n');
      for (i = 0; i < element_stack_index * xml_indentation_increment; i++)
        insert (' ');
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_index_divide ( char *  entry) [static]

Definition at line 1868 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_docbook_image ( char *  name_arg)

Definition at line 1638 of file xml.c.

{
  int found = 0;
  int elt = xml_in_para ? INLINEIMAGE : MEDIAOBJECT;

  if (is_in_insertion_of_type (floatenv))
    xml_begin_docbook_float (INFORMALFIGURE);
  else if (!xml_in_para)
    xml_insert_element (INFORMALFIGURE, START);

  xml_no_para++;

  xml_insert_element (elt, START);

  /* A selected few from http://docbook.org/tdg/en/html/imagedata.html.  */
  if (try_docbook_image (name_arg, "eps", "EPS", 0))
    found++;
  if (try_docbook_image (name_arg, "gif", "GIF", 0))
    found++;
  if (try_docbook_image (name_arg, "jpg", "JPG", 0))
    found++;
  if (try_docbook_image (name_arg, "jpeg", "JPEG", 0))
    found++;
  if (try_docbook_image (name_arg, "pdf", "PDF", 0))
    found++;
  if (try_docbook_image (name_arg, "png", "PNG", 0))
    found++;
  if (try_docbook_image (name_arg, "svg", "SVG", 0))
    found++;

  /* If no luck so far, just assume we'll eventually have a jpg.  */
  if (!found)
    try_docbook_image (name_arg, "jpg", "JPG", 1);
 
  xml_insert_text_file (name_arg);
  xml_insert_element (elt, END);

  xml_no_para--;

  if (elt == MEDIAOBJECT)
    xml_insert_element (INFORMALFIGURE, END);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_element ( int  elt,
int  arg 
)

Definition at line 988 of file xml.c.

Here is the call graph for this function:

void xml_insert_element_with_attribute ( int  elt,
int  arg,
char *  format,
va_alist   
)

Definition at line 782 of file xml.c.

{
  /* Look at the replace_elements table to see if we have to change the element */
  if (xml_sort_index)
      return;
  if (docbook)
    {
      replace_element *element_list = replace_elements;
      while (element_list->element_to_replace >= 0)
        {
          if ( ( (arg == START) &&
                 (element_list->element_containing == xml_current_element ()) &&
                 (element_list->element_to_replace == elt) ) ||
               ( (arg == END) &&
                 (element_list->element_containing == element_stack[element_stack_index-1-start_element_inserted]) &&
                 (element_list->element_to_replace == elt) ) )
            {
              elt = element_list->element_replacing;
              break;
            }
          element_list ++;
        }

      /* Forget the element */
      if (elt < 0)
        {
          if (arg == START)
            start_element_inserted = 0;
          else
            /* Replace the default value, for the next time */
            start_element_inserted = 1;
          return;
        }
    }

  if (!book_started)
    return;

  if (!xml_dont_touch_items_defs && arg == START)
    {
      if (xml_after_table_term && elt != TABLETERM && xml_table_level
          && !xml_in_item[xml_table_level])
        {
          xml_after_table_term = 0;
          xml_insert_element (ITEM, START);
          xml_in_item[xml_table_level] = 1;
        }
      else if (xml_after_def_term && elt != DEFINITIONTERM)
        {
          xml_after_def_term = 0;
          xml_insert_element (DEFINITIONITEM, START);
          xml_in_def_item[xml_definition_level] = 1;
        }
    }

  if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
    return;

  if (executing_string && arg == END)
    switch (elt)
      {
      case TABLEITEM:
        xml_in_tableitem[xml_table_level] = 0;
        break;
      case ITEM:
        xml_in_item[xml_table_level] = 0;
        break;
      case DEFINITIONTERM:
        xml_in_def_item[xml_definition_level] = 0;
        break;
      }

  /* We are special-casing FIGURE element for docbook.  It does appear in
     the tag stack, but not in the output.  This is to make element replacement
     work beautifully.  */
  if (docbook && elt == FLOAT)
    {
      if (arg == START)
        xml_push_current_element (elt);
      else
        xml_pop_current_element ();
      return;
    }

  if (!xml_element_list[elt].name || !strlen (xml_element_list[elt].name))
    {
      /*printf ("Warning: Inserting empty element %d\n", elt);*/
      return;
    }

  if (arg == START && !xml_in_para && !xml_no_para
      && xml_element_list[elt].contained_in_para)
    xml_start_para ();

  if (arg == START && xml_in_para && !xml_element_list[elt].contained_in_para)
    xml_end_para ();

  if (arg == END && xml_in_para && !xml_element_list[elt].contained_in_para)
    xml_end_para ();

  if (docbook && xml_table_level && !in_table_title
      && !xml_in_tableitem[xml_table_level] && !xml_in_item[xml_table_level]
      && arg == START && elt != TABLEITEM && elt != TABLETERM
      && !in_indexterm && xml_current_element() == TABLE)
    {
      in_table_title = 1;
      xml_insert_element (TITLE, START);
    }

  if (arg == START && !xml_in_para && !xml_keep_space
      && !xml_element_list[elt].contained_in_para)
    xml_indent ();

  if (arg == START)
    xml_push_current_element (elt);
  else
    xml_pop_current_element ();

  /* Eat one newline before </example> and the like.  */
  if (!docbook && arg == END
      && (xml_element_list[elt].keep_space || elt == GROUP)
      && output_paragraph[output_paragraph_offset-1] == '\n')
    output_paragraph_offset--;

  /* And eat whitespace before </entry> in @multitables.  */
  if (arg == END && elt == ENTRY)
      while (cr_or_whitespace(output_paragraph[output_paragraph_offset-1]))
    output_paragraph_offset--;

  /* Indent elements that can contain <para>.  */
  if (arg == END && !xml_in_para && !xml_keep_space
      && xml_element_list[elt].contains_para)
    xml_indent ();

  /* Here are the elements we want indented.  These do not contain <para>
     directly.  */
  if (arg == END && (elt == MENUENTRY || elt == ITEMIZE || elt == ENUMERATE
        || elt == TABLEITEM || elt == TABLE
        || elt == MULTITABLE || elt == TGROUP || elt == THEAD || elt == TBODY
        || elt == ROW || elt == INFORMALFIGURE
        || (!docbook && (elt == DEFINITION || elt == DEFINITIONTERM))))
    xml_indent ();

  insert ('<');
  if (arg == END)
    insert ('/');
  insert_string (xml_element_list[elt].name);

  /*  printf ("%s ", xml_element_list[elt].name);*/

  if (format)
    {
      char temp_string[2000]; /* xx no fixed limits */
#ifdef VA_SPRINTF
      va_list ap;
#endif

      VA_START (ap, format);
#ifdef VA_SPRINTF
      VA_SPRINTF (temp_string, format, ap);
#else
      sprintf (temp_string, format, a1, a2, a3, a4, a5, a6, a7, a8);
#endif
      insert (' ');
      insert_string (temp_string);
      va_end (ap);
    }

  if (arg == START && xml_node_id && elt != NODENAME)
    {
      insert_string (" id=\"");
      insert_string (xml_node_id);
      insert ('"');
      free (xml_node_id);
      xml_node_id = NULL;
    }

  if (xml_element_list[elt].keep_space)
    {
      if (arg == START)
       {
          if (!docbook)
            insert_string (" xml:space=\"preserve\"");
         xml_keep_space++;
       }
      else
       xml_keep_space--;
    }

  insert ('>');

  if (!xml_in_para && !xml_element_list[elt].contained_in_para
      && xml_element_list[elt].contains_para && xml_indentation_increment > 0)
    insert ('\n');

  xml_just_after_element = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_entity ( char *  entity_name)

Definition at line 994 of file xml.c.

{
  int saved_escape_html = escape_html;

  if (!book_started)
    return;
  if (docbook && !only_macro_expansion && (in_menu || in_detailmenu))
    return;

  if (!xml_in_para && !xml_no_para && !only_macro_expansion
      && xml_element_list[xml_current_element ()].contains_para
      && !in_fixed_width_font)
    xml_start_para ();

  escape_html = 0;
  add_char ('&');
  escape_html = saved_escape_html;
  insert_string (entity_name);
  add_char (';');
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_footnote ( char *  note)

Definition at line 1266 of file xml.c.

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_indexentry ( char *  entry,
char *  node 
)

Definition at line 1892 of file xml.c.

{
  char *primary = NULL, *secondary;
  if (xml_index_divisions)
    xml_index_divide (entry);

  indexdivempty = 0;
  if (strstr (entry+1, INDEX_SEP))
    {
      primary = xmalloc (strlen (entry) + 1);
      strcpy (primary, entry);
      secondary = strstr (primary+1, INDEX_SEP);
      *secondary = '\0';
      secondary += strlen (INDEX_SEP);

      if (in_secondary && strcmp (primary, index_primary) == 0)
        {
          xml_insert_element (SECONDARYIE, END);
          xml_insert_element (SECONDARYIE, START);
          execute_string ("%s", secondary);
        }
      else
        {
          xml_close_indexentry ();
          xml_insert_element (INDEXENTRY, START);
          in_indexentry = 1;
          xml_insert_element (PRIMARYIE, START);
          execute_string ("%s", primary);
          xml_insert_element (PRIMARYIE, END);
          xml_insert_element (SECONDARYIE, START);
          execute_string ("%s", secondary);
          in_secondary = 1;
        }
    }
  else
    {
      xml_close_indexentry ();
      xml_insert_element (INDEXENTRY, START);
      in_indexentry = 1;
      xml_insert_element (PRIMARYIE, START);
      execute_string ("%s", entry);
    }
  add_word (", ");

  /* Don't link to @unnumbered sections directly.
     We are disabling warnings temporarily, otherwise these xrefs
     will cause bogus warnings about missing punctuation.  */
  {
    extern int print_warnings;
    int save_print_warnings = print_warnings;
    print_warnings = 0;
    execute_string ("%cxref{%s}", COMMAND_PREFIX, xstrdup (node));
    print_warnings = save_print_warnings;
  }

  if (primary)
    {
      strcpy (index_primary, primary);
      /*      xml_insert_element (SECONDARYIE, END);*/
      /*     *(secondary-1) = ',';*/ /* necessary ? */
      free (primary);
    }
  else
    xml_insert_element (PRIMARYIE, END);

  /*  xml_insert_element (INDEXENTRY, END); */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_indexterm ( char *  indexterm,
char *  index 
)

Definition at line 1704 of file xml.c.

{
  /* @index commands can appear between @item and @itemx, @deffn and @deffnx.  */
  if (!docbook)
    {
      /* Check to see if we need to do index redirection per @synindex.  */
      int i;
      for (i = 0; i < xml_synonyms_count; i++)
        {
          if (STREQ (xml_synonyms[i]->from, index))
            index = xstrdup (xml_synonyms[i]->to);
        }

      xml_dont_touch_items_defs++;
      xml_insert_element_with_attribute (INDEXTERM, START, "index=\"%s\"", index);
      in_indexterm = 1;
      execute_string ("%s", indexterm);
      xml_insert_element (INDEXTERM, END);
      in_indexterm = 0;
      xml_dont_touch_items_defs--;
    }
  else
    {
      char *primary = NULL, *secondary = NULL;
      if (strstr (indexterm+1, INDEX_SEP))
        {
          primary = xmalloc (strlen (indexterm) + 1);
          strcpy (primary, indexterm);
          secondary = strstr (primary+1, INDEX_SEP);
          *secondary = '\0';
          secondary += strlen (INDEX_SEP);
        }
      xml_insert_element_with_attribute (INDEXTERM, START, "role=\"%s\"", index);
      in_indexterm = 1;
      xml_insert_element (PRIMARY, START);
      if (primary)
        execute_string ("%s", primary);
      else
        execute_string ("%s", indexterm);
      xml_insert_element (PRIMARY, END);
      if (primary)
        {
          xml_insert_element (SECONDARY, START);
          execute_string ("%s", secondary);
          xml_insert_element (SECONDARY, END);
        }
      xml_insert_element (INDEXTERM, END);
      in_indexterm = 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_insert_quotation ( char *  type,
int  arg 
)

Definition at line 1292 of file xml.c.

{
  int quotation_started = 0;

  if (arg == START)
    {
      QUOTATION_ELT *new = xmalloc (sizeof (QUOTATION_ELT));
      new->type = xstrdup (type);
      new->next = quotation_stack;
      quotation_stack = new;
    }
  else
    type = quotation_stack->type;

  /* Make use of special quotation styles of Docbook if we can.  */
  if (docbook && strlen(type))
    {
      /* Let's assume it started.  */
      quotation_started = 1;

      if (strcasecmp (type, "tip") == 0)
        xml_insert_element (TIP, arg);
      else if (strcasecmp (type, "note") == 0)
        xml_insert_element (NOTE, arg);
      else if (strcasecmp (type, "important") == 0)
        xml_insert_element (IMPORTANT, arg);
      else if (strcasecmp (type, "warning") == 0)
        xml_insert_element (WARNING, arg);
      else if (strcasecmp (type, "caution") == 0)
        xml_insert_element (CAUTION, arg);
      else
        /* Didn't find a known quotation type :\ */
        quotation_started = 0;
    }

  if (!quotation_started)
    {
      xml_insert_element (QUOTATION, arg);
      if (strlen(type) && arg == START)
        execute_string ("@b{%s:} ", type);
    }

  if (arg == END)
    {
      QUOTATION_ELT *temp = quotation_stack;
      if (temp == NULL)
        return;
      quotation_stack = quotation_stack->next;
      free(temp->type);
      free(temp);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_insert_text_file ( char *  name_arg) [static]

Definition at line 1568 of file xml.c.

{
  char *fullname = xmalloc (strlen (name_arg) + 4 + 1);
  FILE *image_file;
  strcpy (fullname, name_arg);
  strcat (fullname, ".txt");
  image_file = fopen (fullname, "r");
  if (image_file)
    {
      int ch;
      int save_inhibit_indentation = inhibit_paragraph_indentation;
      int save_filling_enabled = filling_enabled;

      xml_insert_element (TEXTOBJECT, START);
      xml_insert_element (DISPLAY, START);

      inhibit_paragraph_indentation = 1;
      filling_enabled = 0;
      last_char_was_newline = 0;

      /* Maybe we need to remove the final newline if the image
         file is only one line to allow in-line images.  On the
         other hand, they could just make the file without a
         final newline.  */
      while ((ch = getc (image_file)) != EOF)
        add_char (ch);

      inhibit_paragraph_indentation = save_inhibit_indentation;
      filling_enabled = save_filling_enabled;

      xml_insert_element (DISPLAY, END);
      xml_insert_element (TEXTOBJECT, END);

      if (fclose (image_file) != 0)
        perror (fullname);
    }
  else
    warning (_("@image file `%s' unreadable: %s"), fullname,
             strerror (errno));

  free (fullname);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_open_section ( int  level,
char *  name 
)

Definition at line 1081 of file xml.c.

{
  xml_section *sect = (xml_section *) xmalloc (sizeof (xml_section));

  sect->level = level;
  sect->name = xmalloc (1 + strlen (name));
  strcpy (sect->name, name);
  sect->prev = last_section;
  last_section = sect;

  if (xml_node_open && xml_node_level == -1)
    xml_node_level = level;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_pop_current_element ( void  ) [static]

Definition at line 674 of file xml.c.

{
  element_stack_index--;
  if (element_stack_index < 0)
    printf ("*** stack underflow (%d - %d) ***\n",
            element_stack_index,
            xml_current_element());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_process_defun_args ( char **  defun_args,
int  auto_var_p 
)

Definition at line 2118 of file xml.c.

{
  int pending_space = 0;
  int just_after_paramtype = 0;

  for (;;)
    {
      char *defun_arg = *defun_args++;

      if (defun_arg == NULL)
        break;

      if (defun_arg[0] == ' ')
        {
          pending_space = 1;
          continue;
        }

      if (pending_space)
        {
          add_char (' ');
          pending_space = 0;
        }

      if (DEFUN_SELF_DELIMITING (defun_arg[0]))
        {
         xml_insert_element (DEFDELIMITER, START);
          add_char (defun_arg[0]);
         xml_insert_element (DEFDELIMITER, END);
         just_after_paramtype = 0;
        }
      else if (defun_arg[0] == '&')
       {
         xml_insert_element (DEFPARAM, START);
         add_word (defun_arg);
         xml_insert_element (DEFPARAM, END);
         just_after_paramtype = 0;
       }
      else if (defun_arg[0] == COMMAND_PREFIX || just_after_paramtype)
       {
         xml_insert_element (DEFPARAM, START);
         execute_string ("%s", defun_arg);
         xml_insert_element (DEFPARAM, END);
         just_after_paramtype = 0;
       }
      else if (defun_arg[0] == ',' || defun_arg[0] == ';')
       {
         xml_insert_element (DEFDELIMITER, START);
         add_word (defun_arg);
         xml_insert_element (DEFDELIMITER, END);
         just_after_paramtype = 0;
       }
      else if (auto_var_p)
       {
         xml_insert_element (DEFPARAM, START);
         add_word (defun_arg);
         xml_insert_element (DEFPARAM, END);
         just_after_paramtype = 0;
       }
      else
       {
         xml_insert_element (DEFPARAMTYPE, START);
         add_word (defun_arg);
         xml_insert_element (DEFPARAMTYPE, END);
         just_after_paramtype = 1;
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void xml_push_current_element ( int  elt) [static]

Definition at line 664 of file xml.c.

{
  element_stack[element_stack_index++] = elt;
  if (element_stack_index > 200)
    printf ("*** stack overflow (%d - %s) ***\n",
            element_stack_index,
            xml_element_list[elt].name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_start_menu_entry ( char *  tem)

Definition at line 1096 of file xml.c.

{
  char *string;
  discard_until ("* ");

  /* The line number was already incremented in reader_loop when we
     saw the newline, and discard_until has now incremented again.  */
  line_number--;

  if (xml_in_menu_entry)
    {
      if (xml_in_menu_entry_comment)
        {
          xml_insert_element (MENUCOMMENT, END);
          xml_in_menu_entry_comment=0;
        }
      xml_insert_element (MENUENTRY, END);
      xml_in_menu_entry=0;
    }
  xml_insert_element (MENUENTRY, START);
  xml_in_menu_entry=1;

  xml_insert_element (MENUNODE, START);
  string = expansion (tem, 0);
  add_word (string);
  xml_insert_element (MENUNODE, END);
  free (string);

  /* The menu item may use macros, so expand them now.  */
  xml_insert_element (MENUTITLE, START);
  only_macro_expansion++;
  get_until_in_line (1, ":", &string);
  only_macro_expansion--;
  execute_string ("%s", string); /* get escaping done */
  xml_insert_element (MENUTITLE, END);
  free (string);

  if (looking_at ("::"))
    discard_until (":");
  else
    { /* discard the node name */
      get_until_in_line (0, ".", &string);
      free (string);
    }
  input_text_offset++;  /* discard the second colon or the period */
  skip_whitespace_and_newlines();
  xml_insert_element (MENUCOMMENT, START);
  xml_in_menu_entry_comment ++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 709 of file xml.c.

{
  if (xml_in_para || xml_in_footnote
      || !xml_element_list[xml_current_element()].contains_para)
    return;

  while (output_paragraph[output_paragraph_offset-1] == '\n')
    output_paragraph_offset--;
  xml_indent ();

  insert_string ("<para");
  if (xml_no_indent)
    insert_string (" role=\"continues\"");
  insert_string (">");
  xml_no_indent = 0;
  xml_in_para = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xml_synindex ( char *  from,
char *  to 
)

Definition at line 1961 of file xml.c.

{
  int i, slot;

  slot = -1;
  for (i = 0; i < xml_synonyms_count; i++)
    if (!xml_synonyms[i])
      {
        slot = i;
        break;
      }

  if (slot < 0)
    {
      slot = xml_synonyms_count;
      xml_synonyms_count++;

      xml_synonyms = (XML_SYNONYM **) xrealloc (xml_synonyms,
          (xml_synonyms_count + 1) * sizeof (XML_SYNONYM *));
    }

  xml_synonyms[slot] = xmalloc (sizeof (XML_SYNONYM));
  xml_synonyms[slot]->from = xstrdup (from);
  xml_synonyms[slot]->to = xstrdup (to);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

int book_started = 0 [static]

Definition at line 544 of file xml.c.

Definition at line 257 of file xml.c.

int element_stack[256] [static]

Definition at line 654 of file xml.c.

int element_stack_index = 0 [static]

Definition at line 655 of file xml.c.

int first_section_opened = 0 [static]

Definition at line 545 of file xml.c.

int in_indexentry = 0 [static]

Definition at line 557 of file xml.c.

int in_indexterm = 0 [static]

Definition at line 559 of file xml.c.

int in_secondary = 0 [static]

Definition at line 558 of file xml.c.

int in_table_title = 0 [static]

Definition at line 555 of file xml.c.

char index_primary[2000] [static]

Definition at line 1758 of file xml.c.

int indexdivempty = 0 [static]

xx no fixed limit

Definition at line 1759 of file xml.c.

char last_division_letter = ' ' [static]

Definition at line 1757 of file xml.c.

xml_section* last_section = NULL

Definition at line 1022 of file xml.c.

Definition at line 1992 of file xml.c.

Definition at line 1991 of file xml.c.

Definition at line 1289 of file xml.c.

Initial value:
 {
  { I, TABLETERM, EMPH },
  { B, TABLETERM, EMPH },
  { TT, CODE, -1 },
  { EXAMPLE, DISPLAY, -1 },
  { CODE, DFN, -1 },
  { CODE, VAR, -1 },
  { EMPH, CODE, REPLACEABLE },
  { VAR, VAR, -1},
  { VAR, B, EMPH},
  { B, CODE, ENVAR},
  { CODE, I, EMPH},
  { SAMP, VAR, -1 },
  { FORMAT, BOOKINFO, ABSTRACT },
  { QUOTATION, ABSTRACT, -1},
  { LINEANNOTATION, LINEANNOTATION, -1 },
  { LEGALNOTICE, ABSTRACT, -1 },
  { QUOTATION, QUOTATION, -1 },
  
  { MULTITABLE, FLOAT, FLOATTABLE },
  { INFORMALFIGURE, FLOAT, FLOATFIGURE },
  { CARTOUCHE, FLOAT, FLOATCARTOUCHE },
  
  { VAR, DEFPARAM, -1 },
  { CODE, DEFTYPE, -1 },
  
  {-1, 0, 0}
}

Definition at line 487 of file xml.c.

Definition at line 772 of file xml.c.

Definition at line 44 of file xml.c.

Definition at line 553 of file xml.c.

int xml_after_table_term = 0 [static]

Definition at line 543 of file xml.c.

int xml_definition_level = 0 [static]

Definition at line 552 of file xml.c.

Definition at line 537 of file xml.c.

Definition at line 468 of file xml.c.

Definition at line 533 of file xml.c.

Definition at line 532 of file xml.c.

Definition at line 531 of file xml.c.

int xml_in_def_item[256] [static]

Definition at line 551 of file xml.c.

int xml_in_footnote = 0 [static]

Definition at line 541 of file xml.c.

int xml_in_item[256] [static]

Definition at line 548 of file xml.c.

Definition at line 516 of file xml.c.

Definition at line 517 of file xml.c.

Definition at line 520 of file xml.c.

int xml_in_tableitem[256] [static]

Definition at line 547 of file xml.c.

Definition at line 530 of file xml.c.

Definition at line 34 of file xml.c.

Definition at line 521 of file xml.c.

Definition at line 522 of file xml.c.

Definition at line 1162 of file xml.c.

Definition at line 1756 of file xml.c.

Definition at line 524 of file xml.c.

Definition at line 526 of file xml.c.

char* xml_node_id = NULL

Definition at line 527 of file xml.c.

Definition at line 519 of file xml.c.

Definition at line 518 of file xml.c.

Definition at line 528 of file xml.c.

Definition at line 1700 of file xml.c.

int xml_synonyms_count = 0 [static]

Definition at line 1701 of file xml.c.

int xml_table_level = 0 [static]

Definition at line 549 of file xml.c.