| Current Path : /usr/src/contrib/texinfo/makeinfo/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //usr/src/contrib/texinfo/makeinfo/index.c |
/* index.c -- indexing for Texinfo.
$Id: index.c,v 1.17 2004/11/30 02:03:23 karl Exp $
Copyright (C) 1998, 1999, 2002, 2003, 2004 Free Software Foundation,
Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "system.h"
#include "files.h"
#include "footnote.h"
#include "html.h"
#include "index.h"
#include "lang.h"
#include "macro.h"
#include "sectioning.h"
#include "toc.h"
#include "xml.h"
INDEX_ALIST **name_index_alist = NULL;
/* An array of pointers. Each one is for a different index. The
"synindex" command changes which array slot is pointed to by a
given "index". */
INDEX_ELT **the_indices = NULL;
/* The number of defined indices. */
int defined_indices = 0;
/* This is the order of the index. */
int index_counter = 0;
/* Stuff for defining commands on the fly. */
COMMAND **user_command_array = NULL;
int user_command_array_len = 0;
/* How to compare index entries for sorting. May be set to strcoll. */
int (*index_compare_fn) (const char *a, const char *b) = strcasecmp;
/* Function to compare index entries for sorting. (Calls
`index_compare_fn' above.) */
int index_element_compare (const void *element1, const void *element2);
/* Find which element in the known list of indices has this name.
Returns -1 if NAME isn't found. */
static int
find_index_offset (char *name)
{
int i;
for (i = 0; i < defined_indices; i++)
if (name_index_alist[i] && STREQ (name, name_index_alist[i]->name))
return i;
return -1;
}
/* Return a pointer to the entry of (name . index) for this name.
Return NULL if the index doesn't exist. */
static INDEX_ALIST *
find_index (char *name)
{
int offset = find_index_offset (name);
if (offset > -1)
return name_index_alist[offset];
else
return NULL;
}
/* User-defined commands, which happens only from user-defined indexes.
Used to initialize the builtin indices, too. */
static void
define_user_command (char *name, COMMAND_FUNCTION (*proc), int needs_braces_p)
{
int slot = user_command_array_len;
user_command_array_len++;
if (!user_command_array)
user_command_array = xmalloc (1 * sizeof (COMMAND *));
user_command_array = xrealloc (user_command_array,
(1 + user_command_array_len) * sizeof (COMMAND *));
user_command_array[slot] = xmalloc (sizeof (COMMAND));
user_command_array[slot]->name = xstrdup (name);
user_command_array[slot]->proc = proc;
user_command_array[slot]->argument_in_braces = needs_braces_p;
}
/* Please release me, let me go... */
static void
free_index (INDEX_ELT *index)
{
INDEX_ELT *temp;
while ((temp = index))
{
free (temp->entry);
free (temp->entry_text);
/* Do not free the node, because we already freed the tag table,
which freed all the node names. */
/* free (temp->node); */
index = index->next;
free (temp);
}
}
/* Flush an index by name. This will delete the list of entries that
would be written by a @printindex command for this index. */
static void
undefindex (char *name)
{
int i;
int which = find_index_offset (name);
/* The index might have already been freed if this was the target of
an @synindex. */
if (which < 0 || !name_index_alist[which])
return;
i = name_index_alist[which]->read_index;
free_index (the_indices[i]);
the_indices[i] = NULL;
free (name_index_alist[which]->name);
free (name_index_alist[which]);
name_index_alist[which] = NULL;
}
/* Add the arguments to the current index command to the index NAME. */
static void
index_add_arg (char *name)
{
int which;
char *index_entry;
INDEX_ALIST *tem;
tem = find_index (name);
which = tem ? tem->write_index : -1;
if (macro_expansion_output_stream && !executing_string)
append_to_expansion_output (input_text_offset + 1);
get_rest_of_line (0, &index_entry);
ignore_blank_line ();
if (macro_expansion_output_stream && !executing_string)
{
char *index_line = xmalloc (strlen (index_entry) + 2);
sprintf (index_line, "%s\n", index_entry);
me_execute_string_keep_state (index_line, NULL);
free (index_line);
}
if (which < 0)
{
line_error (_("Unknown index `%s'"), name);
free (index_entry);
}
else
{
INDEX_ELT *new = xmalloc (sizeof (INDEX_ELT));
index_counter++;
/* Get output line number updated before doing anything. */
if (!html && !xml)
flush_output ();
new->next = the_indices[which];
new->entry = NULL;
new->entry_text = index_entry;
/* Since footnotes are handled at the very end of the document,
node name in the non-split HTML outputs always show the last
node. We artificially make it ``Footnotes''. */
if (html && !splitting && already_outputting_pending_notes)
new->node = xstrdup (_("Footnotes"));
else
new->node = current_node ? current_node : xstrdup ("");
if (!html && !xml && no_headers)
{
new->section = current_sectioning_number ();
if (strlen (new->section) == 0)
new->section_name = current_sectioning_name ();
else
new->section_name = "";
}
else
{
new->section = NULL;
new->section_name = NULL;
}
new->code = tem->code;
new->defining_line = line_number - 1;
new->output_line = no_headers ? output_line_number : node_line_number;
/* We need to make a copy since input_filename may point to
something that goes away, for example, inside a macro.
(see the findexerr test). */
new->defining_file = xstrdup (input_filename);
if (html && splitting)
{
if (current_output_filename && *current_output_filename)
new->output_file = filename_part (current_output_filename);
else
new->output_file = xstrdup ("");
}
else
new->output_file = NULL;
new->entry_number = index_counter;
the_indices[which] = new;
#if 0
/* The index breaks if there are colons in the entry.
-- This is true, but it's too painful to force changing index
entries to use `colon', and too confusing for users. The real
fix is to change Info support to support arbitrary characters
in node names, and we're not ready to do that. --karl,
19mar02. */
if (strchr (new->entry_text, ':'))
warning (_("Info cannot handle `:' in index entry `%s'"),
new->entry_text);
#endif
if (html)
{
/* Anchor. */
int removed_empty_elt = 0;
/* We must put the anchor outside the <dl> and <ul> blocks. */
if (rollback_empty_tag ("dl"))
removed_empty_elt = 1;
else if (rollback_empty_tag ("ul"))
removed_empty_elt = 2;
add_word ("<a name=\"index-");
add_escaped_anchor_name (index_entry, 0);
add_word_args ("-%d\"></a>", index_counter);
if (removed_empty_elt == 1)
add_html_block_elt_args ("\n<dl>");
else if (removed_empty_elt == 2)
add_html_block_elt_args ("\n<ul>");
}
}
if (xml)
xml_insert_indexterm (index_entry, name);
}
/* The function which user defined index commands call. */
static void
gen_index (void)
{
char *name = xstrdup (command);
if (strlen (name) >= strlen ("index"))
name[strlen (name) - strlen ("index")] = 0;
index_add_arg (name);
free (name);
}
/* Define an index known as NAME. We assign the slot number.
If CODE is nonzero, make this a code index. */
static void
defindex (char *name, int code)
{
int i, slot;
/* If it already exists, flush it. */
undefindex (name);
/* Try to find an empty slot. */
slot = -1;
for (i = 0; i < defined_indices; i++)
if (!name_index_alist[i])
{
slot = i;
break;
}
if (slot < 0)
{ /* No such luck. Make space for another index. */
slot = defined_indices;
defined_indices++;
name_index_alist = (INDEX_ALIST **)
xrealloc (name_index_alist, (1 + defined_indices)
* sizeof (INDEX_ALIST *));
the_indices = (INDEX_ELT **)
xrealloc (the_indices, (1 + defined_indices) * sizeof (INDEX_ELT *));
}
/* We have a slot. Start assigning. */
name_index_alist[slot] = xmalloc (sizeof (INDEX_ALIST));
name_index_alist[slot]->name = xstrdup (name);
name_index_alist[slot]->read_index = slot;
name_index_alist[slot]->write_index = slot;
name_index_alist[slot]->code = code;
the_indices[slot] = NULL;
}
/* Define an index NAME, implicitly @code if CODE is nonzero. */
static void
top_defindex (char *name, int code)
{
char *temp;
temp = xmalloc (1 + strlen (name) + strlen ("index"));
sprintf (temp, "%sindex", name);
define_user_command (temp, gen_index, 0);
defindex (name, code);
free (temp);
}
/* Set up predefined indices. */
void
init_indices (void)
{
int i;
/* Create the default data structures. */
/* Initialize data space. */
if (!the_indices)
{
the_indices = xmalloc ((1 + defined_indices) * sizeof (INDEX_ELT *));
the_indices[defined_indices] = NULL;
name_index_alist = xmalloc ((1 + defined_indices)
* sizeof (INDEX_ALIST *));
name_index_alist[defined_indices] = NULL;
}
/* If there were existing indices, get rid of them now. */
for (i = 0; i < defined_indices; i++)
{
if (name_index_alist[i])
{ /* Suppose we're called with two input files, and the first
does a @synindex pg cp. Then, when we get here to start
the second file, the "pg" element won't get freed by
undefindex (because it's pointing to "cp"). So free it
here; otherwise, when we try to define the pg index again
just below, it will still point to cp. */
undefindex (name_index_alist[i]->name);
/* undefindex sets all this to null in some cases. */
if (name_index_alist[i])
{
free (name_index_alist[i]->name);
free (name_index_alist[i]);
name_index_alist[i] = NULL;
}
}
}
/* Add the default indices. */
top_defindex ("cp", 0); /* cp is the only non-code index. */
top_defindex ("fn", 1);
top_defindex ("ky", 1);
top_defindex ("pg", 1);
top_defindex ("tp", 1);
top_defindex ("vr", 1);
}
/* Given an index name, return the offset in the_indices of this index,
or -1 if there is no such index. */
static int
translate_index (char *name)
{
INDEX_ALIST *which = find_index (name);
if (which)
return which->read_index;
else
return -1;
}
/* Return the index list which belongs to NAME. */
INDEX_ELT *
index_list (char *name)
{
int which = translate_index (name);
if (which < 0)
return (INDEX_ELT *) -1;
else
return the_indices[which];
}
/* Define a new index command. Arg is name of index. */
static void
gen_defindex (int code)
{
char *name;
get_rest_of_line (0, &name);
if (find_index (name))
{
line_error (_("Index `%s' already exists"), name);
}
else
{
char *temp = xmalloc (strlen (name) + sizeof ("index"));
sprintf (temp, "%sindex", name);
define_user_command (temp, gen_index, 0);
defindex (name, code);
free (temp);
}
free (name);
}
void
cm_defindex (void)
{
gen_defindex (0);
}
void
cm_defcodeindex (void)
{
gen_defindex (1);
}
/* Expects 2 args, on the same line. Both are index abbreviations.
Make the first one be a synonym for the second one, i.e. make the
first one have the same index as the second one. */
void
cm_synindex (void)
{
int source, target;
char *abbrev1, *abbrev2;
skip_whitespace ();
get_until_in_line (0, " ", &abbrev1);
target = find_index_offset (abbrev1);
skip_whitespace ();
get_until_in_line (0, " ", &abbrev2);
source = find_index_offset (abbrev2);
if (source < 0 || target < 0)
{
line_error (_("Unknown index `%s' and/or `%s' in @synindex"),
abbrev1, abbrev2);
}
else
{
if (xml && !docbook)
xml_synindex (abbrev1, abbrev2);
else
name_index_alist[target]->write_index
= name_index_alist[source]->write_index;
}
free (abbrev1);
free (abbrev2);
}
void
cm_pindex (void) /* Pinhead index. */
{
index_add_arg ("pg");
}
void
cm_vindex (void) /* Variable index. */
{
index_add_arg ("vr");
}
void
cm_kindex (void) /* Key index. */
{
index_add_arg ("ky");
}
void
cm_cindex (void) /* Concept index. */
{
index_add_arg ("cp");
}
void
cm_findex (void) /* Function index. */
{
index_add_arg ("fn");
}
void
cm_tindex (void) /* Data Type index. */
{
index_add_arg ("tp");
}
int
index_element_compare (const void *element1, const void *element2)
{
INDEX_ELT **elt1 = (INDEX_ELT **) element1;
INDEX_ELT **elt2 = (INDEX_ELT **) element2;
return index_compare_fn ((*elt1)->entry, (*elt2)->entry);
}
/* Force all index entries to be unique. */
static void
make_index_entries_unique (INDEX_ELT **array, int count)
{
int i, j;
INDEX_ELT **copy;
int counter = 1;
copy = xmalloc ((1 + count) * sizeof (INDEX_ELT *));
for (i = 0, j = 0; i < count; i++)
{
if (i == (count - 1)
|| array[i]->node != array[i + 1]->node
|| !STREQ (array[i]->entry, array[i + 1]->entry))
copy[j++] = array[i];
else
{
free (array[i]->entry);
free (array[i]->entry_text);
free (array[i]);
}
}
copy[j] = NULL;
/* Now COPY contains only unique entries. Duplicated entries in the
original array have been freed. Replace the current array with
the copy, fixing the NEXT pointers. */
for (i = 0; copy[i]; i++)
{
copy[i]->next = copy[i + 1];
/* Fix entry names which are the same. They point to different nodes,
so we make the entry name unique. */
if (copy[i+1]
&& STREQ (copy[i]->entry, copy[i + 1]->entry)
&& !html)
{
char *new_entry_name;
new_entry_name = xmalloc (10 + strlen (copy[i]->entry));
sprintf (new_entry_name, "%s <%d>", copy[i]->entry, counter);
free (copy[i]->entry);
copy[i]->entry = new_entry_name;
counter++;
}
else
counter = 1;
array[i] = copy[i];
}
array[i] = NULL;
/* Free the storage used only by COPY. */
free (copy);
}
/* Sort the index passed in INDEX, returning an array of pointers to
elements. The array is terminated with a NULL pointer. */
static INDEX_ELT **
sort_index (INDEX_ELT *index)
{
INDEX_ELT **array;
INDEX_ELT *temp;
int count = 0;
int save_line_number = line_number;
char *save_input_filename = input_filename;
int save_html = html;
/* Pretend we are in non-HTML mode, for the purpose of getting the
expanded index entry that lacks any markup and other HTML escape
characters which could produce a wrong sort order. */
/* fixme: html: this still causes some markup, such as non-ASCII
characters @AE{} etc., to sort incorrectly. */
html = 0;
for (temp = index, count = 0; temp; temp = temp->next, count++)
;
/* We have the length, now we can allocate an array. */
array = xmalloc ((count + 1) * sizeof (INDEX_ELT *));
for (temp = index, count = 0; temp; temp = temp->next, count++)
{
/* Allocate new memory for the return array, since parts of the
original INDEX get freed. Otherwise, if the document calls
@printindex twice on the same index, with duplicate entries,
we'll have garbage the second time. There are cleaner ways to
deal, but this will suffice for now. */
array[count] = xmalloc (sizeof (INDEX_ELT));
*(array[count]) = *(temp); /* struct assignment, hope it's ok */
/* Adjust next pointers to use the new memory. */
if (count > 0)
array[count-1]->next = array[count];
/* Set line number and input filename to the source line for this
index entry, as this expansion finds any errors. */
line_number = array[count]->defining_line;
input_filename = array[count]->defining_file;
/* If this particular entry should be printed as a "code" index,
then expand it as @code{entry}, i.e., as in fixed-width font. */
array[count]->entry = expansion (temp->entry_text, array[count]->code);
}
array[count] = NULL; /* terminate the array. */
line_number = save_line_number;
input_filename = save_input_filename;
html = save_html;
#ifdef HAVE_STRCOLL
/* This is not perfect. We should set (then restore) the locale to the
documentlanguage, so strcoll operates according to the document's
locale, not the user's. For now, I'm just going to assume that
those few new documents which use @documentlanguage will be
processed in the appropriate locale. In any case, don't use
strcoll in the C (aka POSIX) locale, that is the ASCII ordering. */
if (language_code != en)
{
char *lang_env = getenv ("LANG");
if (lang_env && !STREQ (lang_env, "C") && !STREQ (lang_env, "POSIX"))
index_compare_fn = strcoll;
}
#endif /* HAVE_STRCOLL */
/* Sort the array. */
qsort (array, count, sizeof (INDEX_ELT *), index_element_compare);
/* Remove duplicate entries. */
make_index_entries_unique (array, count);
/* Replace the original index with the sorted one, in case the
document wants to print it again. If the index wasn't empty. */
if (index)
*index = **array;
return array;
}
static void
insert_index_output_line_no (int line_number, int output_line_number_len)
{
int last_column;
int str_size = output_line_number_len + strlen (_("(line )"))
+ sizeof (NULL);
char *out_line_no_str = (char *) xmalloc (str_size + 1);
/* Do not translate ``(line NNN)'' below for !no_headers case (Info output),
because it's something like the ``* Menu'' strings. For plaintext output
it should be translated though. */
sprintf (out_line_no_str,
no_headers ? _("(line %*d)") : "(line %*d)",
output_line_number_len, line_number);
{
int i = output_paragraph_offset;
while (0 < i && output_paragraph[i-1] != '\n')
i--;
last_column = output_paragraph_offset - i;
}
if (last_column + strlen (out_line_no_str) > fill_column)
{
insert ('\n');
last_column = 0;
}
while (last_column + strlen (out_line_no_str) < fill_column)
{
insert (' ');
last_column++;
}
insert_string (out_line_no_str);
insert ('\n');
free (out_line_no_str);
}
/* Nonzero means that we are in the middle of printing an index. */
int printing_index = 0;
/* Takes one arg, a short name of an index to print.
Outputs a menu of the sorted elements of the index. */
void
cm_printindex (void)
{
char *index_name;
get_rest_of_line (0, &index_name);
/* get_rest_of_line increments the line number by one,
so to make warnings/errors point to the correct line,
we decrement the line_number again. */
if (!handling_delayed_writes)
line_number--;
if (xml && !docbook)
{
xml_insert_element (PRINTINDEX, START);
insert_string (index_name);
xml_insert_element (PRINTINDEX, END);
}
else if (!handling_delayed_writes)
{
int command_len = sizeof ("@ ") + strlen (command) + strlen (index_name);
char *index_command = xmalloc (command_len + 1);
close_paragraph ();
if (docbook)
xml_begin_index ();
sprintf (index_command, "@%s %s", command, index_name);
register_delayed_write (index_command);
free (index_command);
}
else
{
int item;
INDEX_ELT *index;
INDEX_ELT *last_index = 0;
INDEX_ELT **array;
unsigned line_length;
char *line;
int saved_inhibit_paragraph_indentation = inhibit_paragraph_indentation;
int saved_filling_enabled = filling_enabled;
int saved_line_number = line_number;
char *saved_input_filename = input_filename;
unsigned output_line_number_len;
index = index_list (index_name);
if (index == (INDEX_ELT *)-1)
{
line_error (_("Unknown index `%s' in @printindex"), index_name);
free (index_name);
return;
}
/* Do this before sorting, so execute_string is in the good environment */
if (xml && docbook)
xml_begin_index ();
/* Do this before sorting, so execute_string in index_element_compare
will give the same results as when we actually print. */
printing_index = 1;
filling_enabled = 0;
inhibit_paragraph_indentation = 1;
xml_sort_index = 1;
array = sort_index (index);
xml_sort_index = 0;
close_paragraph ();
if (html)
add_html_block_elt_args ("<ul class=\"index-%s\" compact>",
index_name);
else if (!no_headers && !docbook)
{ /* Info. Add magic cookie for info readers (to treat this
menu differently), and the usual start-of-menu. */
add_char ('\0');
add_word ("\010[index");
add_char ('\0');
add_word ("\010]\n");
add_word ("* Menu:\n\n");
}
me_inhibit_expansion++;
/* This will probably be enough. */
line_length = 100;
line = xmalloc (line_length);
{
char *max_output_line_number = (char *) xmalloc (25 * sizeof (char));
if (no_headers)
sprintf (max_output_line_number, "%d", output_line_number);
else
{
INDEX_ELT *tmp_entry = index;
unsigned tmp = 0;
for (tmp_entry = index; tmp_entry; tmp_entry = tmp_entry->next)
tmp = tmp_entry->output_line > tmp ? tmp_entry->output_line : tmp;
sprintf (max_output_line_number, "%d", tmp);
}
output_line_number_len = strlen (max_output_line_number);
free (max_output_line_number);
}
for (item = 0; (index = array[item]); item++)
{
/* A pathological document might have an index entry outside of any
node. Don't crash; try using the section name instead. */
char *index_node = index->node;
line_number = index->defining_line;
input_filename = index->defining_file;
if ((!index_node || !*index_node) && html)
index_node = toc_find_section_of_node (index_node);
if (!index_node || !*index_node)
{
line_error (_("Entry for index `%s' outside of any node"),
index_name);
if (html || !no_headers)
index_node = (char *) _("(outside of any node)");
}
if (html)
{
/* For HTML, we need to expand and HTML-escape the
original entry text, at the same time. Consider
@cindex J@"urgen. We want Jüurgen. We can't
expand and then escape since we'll end up with
J&uuml;rgen. We can't escape and then expand
because then `expansion' will see J@"urgen, and
@"urgen is not a command. */
char *html_entry =
maybe_escaped_expansion (index->entry_text, index->code, 1);
add_html_block_elt_args ("\n<li><a href=\"%s#index-",
(splitting && index->output_file) ? index->output_file : "");
add_escaped_anchor_name (index->entry_text, 0);
add_word_args ("-%d\">%s</a>: ", index->entry_number,
html_entry);
free (html_entry);
add_word ("<a href=\"");
if (index->node && *index->node)
{
/* Ensure any non-macros in the node name are expanded. */
char *expanded_index;
in_fixed_width_font++;
expanded_index = expansion (index_node, 0);
in_fixed_width_font--;
add_anchor_name (expanded_index, 1);
expanded_index = escape_string (expanded_index);
add_word_args ("\">%s</a>", expanded_index);
free (expanded_index);
}
else if (STREQ (index_node, _("(outside of any node)")))
{
add_anchor_name (index_node, 1);
add_word_args ("\">%s</a>", index_node);
}
else
/* If we use the section instead of the (missing) node, then
index_node already includes all we need except the #. */
add_word_args ("#%s</a>", index_node);
add_html_block_elt ("</li>");
}
else if (xml && docbook)
{
/* In the DocBook case, the expanded index entry is not
good for us, since it was expanded for non-DocBook mode
inside sort_index. So we send the original entry text
to be used with execute_string. */
xml_insert_indexentry (index->entry_text, index_node);
}
else
{
unsigned new_length = strlen (index->entry);
if (new_length < 50) /* minimum length used below */
new_length = 50;
new_length += strlen (index_node) + 7; /* * : .\n\0 */
if (new_length > line_length)
{
line_length = new_length;
line = xrealloc (line, line_length);
}
/* Print the entry, nicely formatted. We've already
expanded any commands in index->entry, including any
implicit @code. Thus, can't call execute_string, since
@@ has turned into @. */
if (!no_headers)
{
sprintf (line, "* %-37s ", index->entry);
line[2 + strlen (index->entry)] = ':';
insert_string (line);
/* Make sure any non-macros in the node name are expanded. */
in_fixed_width_font++;
execute_string ("%s. ", index_node);
insert_index_output_line_no (index->output_line,
output_line_number_len);
in_fixed_width_font--;
}
else
{
/* With --no-headers, the @node lines are gone, so
there's little sense in referring to them in the
index. Instead, output the number or name of the
section that corresponds to that node. */
sprintf (line, "%-*s ", number_sections ? 46 : 1, index->entry);
line[strlen (index->entry)] = ':';
insert_string (line);
if (strlen (index->section) > 0)
{ /* We got your number. */
insert_string ((char *) _("See "));
insert_string (index->section);
}
else
{ /* Sigh, index in an @unnumbered. :-\ */
insert_string ("\n ");
insert_string ((char *) _("See "));
insert_string ("``");
insert_string (expansion (index->section_name, 0));
insert_string ("''");
}
insert_string (". ");
insert_index_output_line_no (index->output_line,
output_line_number_len);
}
}
/* Prevent `output_paragraph' from growing to the size of the
whole index. */
flush_output ();
last_index = index;
}
free (line);
me_inhibit_expansion--;
printing_index = 0;
close_single_paragraph ();
filling_enabled = saved_filling_enabled;
inhibit_paragraph_indentation = saved_inhibit_paragraph_indentation;
input_filename = saved_input_filename;
line_number = saved_line_number;
if (html)
add_html_block_elt ("</ul>");
else if (xml && docbook)
xml_end_index ();
}
free (index_name);
/* Re-increment the line number, because get_rest_of_line
left us looking at the next line after the command. */
line_number++;
}