1193 lines
34 KiB
C
1193 lines
34 KiB
C
/* install-info -- create Info directory entry(ies) for an Info file.
|
||
$Id: install-info.c,v 1.1.1.3 1998/03/24 18:20:30 law Exp $
|
||
|
||
Copyright (C) 1996, 97, 98 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 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.*/
|
||
|
||
#include "system.h"
|
||
#include <getopt.h>
|
||
|
||
#ifdef HAVE_LIBZ
|
||
#include <zlib.h>
|
||
#endif
|
||
|
||
/* Name this program was invoked with. */
|
||
char *progname;
|
||
|
||
char *readfile ();
|
||
struct line_data *findlines ();
|
||
void fatal ();
|
||
void insert_entry_here ();
|
||
int compare_section_names ();
|
||
|
||
struct spec_entry;
|
||
|
||
/* Data structures. */
|
||
|
||
|
||
/* Record info about a single line from a file as read into core. */
|
||
struct line_data
|
||
{
|
||
/* The start of the line. */
|
||
char *start;
|
||
/* The number of characters in the line,
|
||
excluding the terminating newline. */
|
||
int size;
|
||
/* Vector containing pointers to the entries to add before this line.
|
||
The vector is null-terminated. */
|
||
struct spec_entry **add_entries_before;
|
||
/* 1 means output any needed new sections before this line. */
|
||
int add_sections_before;
|
||
/* 1 means don't output this line. */
|
||
int delete;
|
||
};
|
||
|
||
|
||
/* This is used for a list of the specified menu section names
|
||
in which entries should be added. */
|
||
struct spec_section
|
||
{
|
||
struct spec_section *next;
|
||
char *name;
|
||
/* 1 means we have not yet found an existing section with this name
|
||
in the dir file--so we will need to add a new section. */
|
||
int missing;
|
||
};
|
||
|
||
|
||
/* This is used for a list of the entries specified to be added. */
|
||
struct spec_entry
|
||
{
|
||
struct spec_entry *next;
|
||
char *text;
|
||
};
|
||
|
||
|
||
/* This is used for a list of nodes found by parsing the dir file. */
|
||
struct node
|
||
{
|
||
struct node *next;
|
||
/* The node name. */
|
||
char *name;
|
||
/* The line number of the line where the node starts.
|
||
This is the line that contains control-underscore. */
|
||
int start_line;
|
||
/* The line number of the line where the node ends,
|
||
which is the end of the file or where the next line starts. */
|
||
int end_line;
|
||
/* Start of first line in this node's menu
|
||
(the line after the * Menu: line). */
|
||
char *menu_start;
|
||
/* The start of the chain of sections in this node's menu. */
|
||
struct menu_section *sections;
|
||
/* The last menu section in the chain. */
|
||
struct menu_section *last_section;
|
||
};
|
||
|
||
|
||
/* This is used for a list of sections found in a node's menu.
|
||
Each struct node has such a list in the sections field. */
|
||
struct menu_section
|
||
{
|
||
struct menu_section *next;
|
||
char *name;
|
||
/* Line number of start of section. */
|
||
int start_line;
|
||
/* Line number of end of section. */
|
||
int end_line;
|
||
};
|
||
|
||
/* Memory allocation and string operations. */
|
||
|
||
/* Like malloc but get fatal error if memory is exhausted. */
|
||
void *
|
||
xmalloc (size)
|
||
unsigned int size;
|
||
{
|
||
extern void *malloc ();
|
||
void *result = malloc (size);
|
||
if (result == NULL)
|
||
fatal (_("virtual memory exhausted"), 0);
|
||
return result;
|
||
}
|
||
|
||
/* Like realloc but get fatal error if memory is exhausted. */
|
||
void *
|
||
xrealloc (obj, size)
|
||
void *obj;
|
||
unsigned int size;
|
||
{
|
||
extern void *realloc ();
|
||
void *result = realloc (obj, size);
|
||
if (result == NULL)
|
||
fatal (_("virtual memory exhausted"), 0);
|
||
return result;
|
||
}
|
||
|
||
/* Return a newly-allocated string
|
||
whose contents concatenate those of S1, S2, S3. */
|
||
char *
|
||
concat (s1, s2, s3)
|
||
char *s1, *s2, *s3;
|
||
{
|
||
int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
|
||
char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
|
||
|
||
strcpy (result, s1);
|
||
strcpy (result + len1, s2);
|
||
strcpy (result + len1 + len2, s3);
|
||
*(result + len1 + len2 + len3) = 0;
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Return a string containing SIZE characters
|
||
copied from starting at STRING. */
|
||
|
||
char *
|
||
copy_string (string, size)
|
||
char *string;
|
||
int size;
|
||
{
|
||
int i;
|
||
char *copy = (char *) xmalloc (size + 1);
|
||
for (i = 0; i < size; i++)
|
||
copy[i] = string[i];
|
||
copy[size] = 0;
|
||
return copy;
|
||
}
|
||
|
||
/* Error message functions. */
|
||
|
||
/* Print error message. S1 is printf control string, S2 and S3 args for it. */
|
||
|
||
/* VARARGS1 */
|
||
void
|
||
error (s1, s2, s3)
|
||
char *s1, *s2, *s3;
|
||
{
|
||
fprintf (stderr, "%s: ", progname);
|
||
fprintf (stderr, s1, s2, s3);
|
||
putc ('\n', stderr);
|
||
}
|
||
|
||
/* VARARGS1 */
|
||
void
|
||
warning (s1, s2, s3)
|
||
char *s1, *s2, *s3;
|
||
{
|
||
fprintf (stderr, _("%s: warning: "), progname);
|
||
fprintf (stderr, s1, s2, s3);
|
||
putc ('\n', stderr);
|
||
}
|
||
|
||
/* Print error message and exit. */
|
||
|
||
void
|
||
fatal (s1, s2, s3)
|
||
char *s1, *s2, *s3;
|
||
{
|
||
error (s1, s2, s3);
|
||
exit (1);
|
||
}
|
||
|
||
/* Print fatal error message based on errno, with file name NAME. */
|
||
|
||
void
|
||
pfatal_with_name (name)
|
||
char *name;
|
||
{
|
||
char *s = concat ("", strerror (errno), _(" for %s"));
|
||
fatal (s, name);
|
||
}
|
||
|
||
/* Given the full text of a menu entry, null terminated,
|
||
return just the menu item name (copied). */
|
||
|
||
char *
|
||
extract_menu_item_name (item_text)
|
||
char *item_text;
|
||
{
|
||
char *p;
|
||
|
||
if (*item_text == '*')
|
||
item_text++;
|
||
while (*item_text == ' ')
|
||
item_text++;
|
||
|
||
p = item_text;
|
||
while (*p && *p != ':') p++;
|
||
return copy_string (item_text, p - item_text);
|
||
}
|
||
|
||
/* Given the full text of a menu entry, terminated by null or newline,
|
||
return just the menu item file (copied). */
|
||
|
||
char *
|
||
extract_menu_file_name (item_text)
|
||
char *item_text;
|
||
{
|
||
char *p = item_text;
|
||
|
||
/* If we have text that looks like * ITEM: (FILE)NODE...,
|
||
extract just FILE. Otherwise return "(none)". */
|
||
|
||
if (*p == '*')
|
||
p++;
|
||
while (*p == ' ')
|
||
p++;
|
||
|
||
/* Skip to and past the colon. */
|
||
while (*p && *p != '\n' && *p != ':') p++;
|
||
if (*p == ':') p++;
|
||
|
||
/* Skip past the open-paren. */
|
||
while (1)
|
||
{
|
||
if (*p == '(')
|
||
break;
|
||
else if (*p == ' ' || *p == '\t')
|
||
p++;
|
||
else
|
||
return "(none)";
|
||
}
|
||
p++;
|
||
|
||
item_text = p;
|
||
|
||
/* File name ends just before the close-paren. */
|
||
while (*p && *p != '\n' && *p != ')') p++;
|
||
if (*p != ')')
|
||
return "(none)";
|
||
|
||
return copy_string (item_text, p - item_text);
|
||
}
|
||
|
||
void
|
||
suggest_asking_for_help ()
|
||
{
|
||
fprintf (stderr, _("\tTry `%s --help' for a complete list of options.\n"),
|
||
progname);
|
||
exit (1);
|
||
}
|
||
|
||
void
|
||
print_help ()
|
||
{
|
||
printf (_("Usage: %s [OPTION]... [INFO-FILE [DIR-FILE]]\n\
|
||
\n\
|
||
Install INFO-FILE in the Info directory file DIR-FILE.\n\
|
||
\n\
|
||
Options:\n\
|
||
--delete Delete existing entries in INFO-FILE;\n\
|
||
don't insert any new entries.\n\
|
||
--dir-file=NAME Specify file name of Info directory file.\n\
|
||
This is equivalent to using the DIR-FILE argument.\n\
|
||
--entry=TEXT Insert TEXT as an Info directory entry.\n\
|
||
TEXT should have the form of an Info menu item line\n\
|
||
plus zero or more extra lines starting with whitespace.\n\
|
||
If you specify more than one entry, they are all added.\n\
|
||
If you don't specify any entries, they are determined\n\
|
||
from information in the Info file itself.\n\
|
||
--help Display this help and exit.\n\
|
||
--info-file=FILE Specify Info file to install in the directory.\n\
|
||
This is equivalent to using the INFO-FILE argument.\n\
|
||
--info-dir=DIR Same as --dir-file=DIR/dir.\n\
|
||
--item=TEXT Same as --entry TEXT.\n\
|
||
An Info directory entry is actually a menu item.\n\
|
||
--quiet Suppress warnings.\n\
|
||
--remove Same as --delete.\n\
|
||
--section=SEC Put this file's entries in section SEC of the directory.\n\
|
||
If you specify more than one section, all the entries\n\
|
||
are added in each of the sections.\n\
|
||
If you don't specify any sections, they are determined\n\
|
||
from information in the Info file itself.\n\
|
||
--version Display version information and exit.\n\
|
||
\n\
|
||
Email bug reports to bug-texinfo@gnu.org.\n\
|
||
"), progname);
|
||
}
|
||
|
||
|
||
/* If DIRFILE does not exist, create a minimal one (or abort). If it
|
||
already exists, do nothing. */
|
||
|
||
void
|
||
ensure_dirfile_exists (dirfile)
|
||
char *dirfile;
|
||
{
|
||
int desc = open (dirfile, O_RDONLY);
|
||
if (desc < 0 && errno == ENOENT)
|
||
{
|
||
FILE *f;
|
||
char *readerr = strerror (errno);
|
||
close (desc);
|
||
f = fopen (dirfile, "w");
|
||
if (f)
|
||
{
|
||
fputs (_("This is the file .../info/dir, which contains the\n\
|
||
topmost node of the Info hierarchy, called (dir)Top.\n\
|
||
The first time you invoke Info you start off looking at this node.\n\
|
||
\n\
|
||
File: dir,\tNode: Top,\tThis is the top of the INFO tree\n\
|
||
\n\
|
||
This (the Directory node) gives a menu of major topics.\n\
|
||
Typing \"q\" exits, \"?\" lists all Info commands, \"d\" returns here,\n\
|
||
\"h\" gives a primer for first-timers,\n\
|
||
\"mEmacs<Return>\" visits the Emacs manual, etc.\n\
|
||
\n\
|
||
In Emacs, you can click mouse button 2 on a menu item or cross reference\n\
|
||
to select it.\n\
|
||
\n\
|
||
* Menu:\n\
|
||
"), f);
|
||
if (fclose (f) < 0)
|
||
pfatal_with_name (dirfile);
|
||
}
|
||
else
|
||
{
|
||
/* Didn't exist, but couldn't open for writing. */
|
||
fprintf (stderr,
|
||
_("%s: could not read (%s) and could not create (%s)\n"),
|
||
dirfile, readerr, strerror (errno));
|
||
exit (1);
|
||
}
|
||
}
|
||
else
|
||
close (desc); /* It already existed, so fine. */
|
||
}
|
||
|
||
/* This table defines all the long-named options, says whether they
|
||
use an argument, and maps them into equivalent single-letter options. */
|
||
|
||
struct option longopts[] =
|
||
{
|
||
{ "delete", no_argument, NULL, 'r' },
|
||
{ "dir-file", required_argument, NULL, 'd' },
|
||
{ "entry", required_argument, NULL, 'e' },
|
||
{ "help", no_argument, NULL, 'h' },
|
||
{ "info-dir", required_argument, NULL, 'D' },
|
||
{ "info-file", required_argument, NULL, 'i' },
|
||
{ "item", required_argument, NULL, 'e' },
|
||
{ "quiet", no_argument, NULL, 'q' },
|
||
{ "remove", no_argument, NULL, 'r' },
|
||
{ "section", required_argument, NULL, 's' },
|
||
{ "version", no_argument, NULL, 'V' },
|
||
{ 0 }
|
||
};
|
||
|
||
|
||
int
|
||
main (argc, argv)
|
||
int argc;
|
||
char **argv;
|
||
{
|
||
char *infile = 0, *dirfile = 0;
|
||
char *infile_sans_info;
|
||
unsigned infilelen_sans_info;
|
||
FILE *output;
|
||
|
||
/* Record the text of the Info file, as a sequence of characters
|
||
and as a sequence of lines. */
|
||
char *input_data;
|
||
int input_size;
|
||
struct line_data *input_lines;
|
||
int input_nlines;
|
||
|
||
/* Record here the specified section names and directory entries. */
|
||
struct spec_section *input_sections = NULL;
|
||
struct spec_entry *entries_to_add = NULL;
|
||
int n_entries_to_add = 0;
|
||
|
||
/* Record the old text of the dir file, as plain characters,
|
||
as lines, and as nodes. */
|
||
char *dir_data;
|
||
int dir_size;
|
||
int dir_nlines;
|
||
struct line_data *dir_lines;
|
||
struct node *dir_nodes;
|
||
|
||
/* Nonzero means --delete was specified (just delete existing entries). */
|
||
int delete_flag = 0;
|
||
int something_deleted = 0;
|
||
/* Nonzero means -q was specified. */
|
||
int quiet_flag = 0;
|
||
|
||
int node_header_flag;
|
||
int prefix_length;
|
||
int i;
|
||
|
||
progname = argv[0];
|
||
|
||
#ifdef HAVE_SETLOCALE
|
||
/* Set locale via LC_ALL. */
|
||
setlocale (LC_ALL, "");
|
||
#endif
|
||
|
||
/* Set the text message domain. */
|
||
bindtextdomain (PACKAGE, LOCALEDIR);
|
||
textdomain (PACKAGE);
|
||
|
||
while (1)
|
||
{
|
||
int opt = getopt_long (argc, argv, "i:d:e:s:hHr", longopts, 0);
|
||
|
||
if (opt == EOF)
|
||
break;
|
||
|
||
switch (opt)
|
||
{
|
||
case 0:
|
||
/* If getopt returns 0, then it has already processed a
|
||
long-named option. We should do nothing. */
|
||
break;
|
||
|
||
case 1:
|
||
abort ();
|
||
|
||
case 'd':
|
||
if (dirfile)
|
||
{
|
||
fprintf (stderr, _("%s: Specify the Info directory only once.\n"),
|
||
progname);
|
||
suggest_asking_for_help ();
|
||
}
|
||
dirfile = optarg;
|
||
break;
|
||
|
||
case 'D':
|
||
if (dirfile)
|
||
{
|
||
fprintf (stderr, _("%s: Specify the Info directory only once.\n"),
|
||
progname);
|
||
suggest_asking_for_help ();
|
||
}
|
||
dirfile = concat (optarg, "", "/dir");
|
||
break;
|
||
|
||
case 'e':
|
||
{
|
||
struct spec_entry *next
|
||
= (struct spec_entry *) xmalloc (sizeof (struct spec_entry));
|
||
if (! (*optarg != 0 && optarg[strlen (optarg) - 1] == '\n'))
|
||
optarg = concat (optarg, "\n", "");
|
||
next->text = optarg;
|
||
next->next = entries_to_add;
|
||
entries_to_add = next;
|
||
n_entries_to_add++;
|
||
}
|
||
break;
|
||
|
||
case 'h':
|
||
case 'H':
|
||
print_help ();
|
||
exit (0);
|
||
|
||
case 'i':
|
||
if (infile)
|
||
{
|
||
fprintf (stderr, _("%s: Specify the Info file only once.\n"),
|
||
progname);
|
||
suggest_asking_for_help ();
|
||
}
|
||
infile = optarg;
|
||
break;
|
||
|
||
case 'q':
|
||
quiet_flag = 1;
|
||
break;
|
||
|
||
case 'r':
|
||
delete_flag = 1;
|
||
break;
|
||
|
||
case 's':
|
||
{
|
||
struct spec_section *next
|
||
= (struct spec_section *) xmalloc (sizeof (struct spec_section));
|
||
next->name = optarg;
|
||
next->next = input_sections;
|
||
next->missing = 1;
|
||
input_sections = next;
|
||
}
|
||
break;
|
||
|
||
case 'V':
|
||
printf ("install-info (GNU %s) %s\n", PACKAGE, VERSION);
|
||
printf (_("Copyright (C) %s Free Software Foundation, Inc.\n\
|
||
There is NO warranty. You may redistribute this software\n\
|
||
under the terms of the GNU General Public License.\n\
|
||
For more information about these matters, see the files named COPYING.\n"),
|
||
"1998");
|
||
exit (0);
|
||
|
||
default:
|
||
suggest_asking_for_help ();
|
||
}
|
||
}
|
||
|
||
/* Interpret the non-option arguments as file names. */
|
||
for (; optind < argc; ++optind)
|
||
{
|
||
if (infile == 0)
|
||
infile = argv[optind];
|
||
else if (dirfile == 0)
|
||
dirfile = argv[optind];
|
||
else
|
||
error (_("excess command line argument `%s'"), argv[optind]);
|
||
}
|
||
|
||
if (!infile)
|
||
fatal (_("No input file specified; try --help for more information."));
|
||
if (!dirfile)
|
||
fatal (_("No dir file specified; try --help for more information."));
|
||
|
||
/* Read the Info file and parse it into lines. */
|
||
|
||
input_data = readfile (infile, &input_size);
|
||
input_lines = findlines (input_data, input_size, &input_nlines);
|
||
|
||
/* Parse the input file to find the section names it specifies. */
|
||
|
||
if (input_sections == 0)
|
||
{
|
||
prefix_length = strlen ("INFO-DIR-SECTION ");
|
||
for (i = 0; i < input_nlines; i++)
|
||
{
|
||
if (!strncmp ("INFO-DIR-SECTION ", input_lines[i].start,
|
||
prefix_length))
|
||
{
|
||
struct spec_section *next
|
||
= (struct spec_section *) xmalloc (sizeof (struct spec_section));
|
||
next->name = copy_string (input_lines[i].start + prefix_length,
|
||
input_lines[i].size - prefix_length);
|
||
next->next = input_sections;
|
||
next->missing = 1;
|
||
input_sections = next;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Default to section "Miscellaneous" if no sections specified. */
|
||
if (input_sections == 0)
|
||
{
|
||
input_sections
|
||
= (struct spec_section *) xmalloc (sizeof (struct spec_section));
|
||
input_sections->name = "Miscellaneous";
|
||
input_sections->next = 0;
|
||
input_sections->missing = 1;
|
||
}
|
||
|
||
/* Now find the directory entries specified in the file
|
||
and put them on entries_to_add. But not if entries
|
||
were specified explicitly with command options. */
|
||
|
||
if (entries_to_add == 0)
|
||
{
|
||
char *start_of_this_entry = 0;
|
||
for (i = 0; i < input_nlines; i++)
|
||
{
|
||
if (!strncmp ("START-INFO-DIR-ENTRY", input_lines[i].start,
|
||
input_lines[i].size)
|
||
&& sizeof ("START-INFO-DIR-ENTRY") - 1 == input_lines[i].size)
|
||
{
|
||
if (start_of_this_entry != 0)
|
||
fatal (_("START-INFO-DIR-ENTRY without matching END-INFO-DIR-ENTRY"));
|
||
start_of_this_entry = input_lines[i + 1].start;
|
||
}
|
||
if (!strncmp ("END-INFO-DIR-ENTRY", input_lines[i].start,
|
||
input_lines[i].size)
|
||
&& sizeof ("END-INFO-DIR-ENTRY") - 1 == input_lines[i].size)
|
||
{
|
||
if (start_of_this_entry != 0)
|
||
{
|
||
struct spec_entry *next
|
||
= (struct spec_entry *) xmalloc (sizeof (struct spec_entry));
|
||
next->text = copy_string (start_of_this_entry,
|
||
input_lines[i].start - start_of_this_entry);
|
||
next->next = entries_to_add;
|
||
entries_to_add = next;
|
||
n_entries_to_add++;
|
||
start_of_this_entry = 0;
|
||
}
|
||
else
|
||
fatal (_("END-INFO-DIR-ENTRY without matching START-INFO-DIR-ENTRY"));
|
||
}
|
||
}
|
||
if (start_of_this_entry != 0)
|
||
fatal (_("START-INFO-DIR-ENTRY without matching END-INFO-DIR-ENTRY"));
|
||
}
|
||
|
||
if (!delete_flag)
|
||
if (entries_to_add == 0)
|
||
{ /* No need to abort here, the original info file may not have
|
||
the requisite Texinfo commands. This is not something an
|
||
installer should have to correct (it's a problem for the
|
||
maintainer), and there's no need to cause subsequent parts of
|
||
`make install' to fail. */
|
||
warning (_("no info dir entry in `%s'"), infile);
|
||
exit (0);
|
||
}
|
||
|
||
/* Now read in the Info dir file. */
|
||
ensure_dirfile_exists (dirfile);
|
||
dir_data = readfile (dirfile, &dir_size);
|
||
dir_lines = findlines (dir_data, dir_size, &dir_nlines);
|
||
|
||
/* We will be comparing the entries in the dir file against the
|
||
current filename, so need to strip off any directory prefix and any
|
||
.info suffix. */
|
||
{
|
||
unsigned basename_len;
|
||
char *infile_basename = strrchr (infile, '/');
|
||
if (infile_basename)
|
||
infile_basename++;
|
||
else
|
||
infile_basename = infile;
|
||
|
||
basename_len = strlen (infile_basename);
|
||
infile_sans_info
|
||
= (strlen (infile_basename) > 5
|
||
&& strcmp (infile_basename + basename_len - 5, ".info") == 0)
|
||
? copy_string (infile_basename, basename_len - 5)
|
||
: infile_basename;
|
||
|
||
infilelen_sans_info = strlen (infile_sans_info);
|
||
}
|
||
|
||
/* Parse the dir file. Find all the nodes, and their menus,
|
||
and the sections of their menus. */
|
||
|
||
dir_nodes = 0;
|
||
node_header_flag = 0;
|
||
for (i = 0; i < dir_nlines; i++)
|
||
{
|
||
/* Parse node header lines. */
|
||
if (node_header_flag)
|
||
{
|
||
int j, end;
|
||
for (j = 0; j < dir_lines[i].size; j++)
|
||
/* Find the node name and store it in the `struct node'. */
|
||
if (!strncmp ("Node:", dir_lines[i].start + j, 5))
|
||
{
|
||
char *line = dir_lines[i].start;
|
||
/* Find the start of the node name. */
|
||
j += 5;
|
||
while (line[j] == ' ' || line[j] == '\t')
|
||
j++;
|
||
/* Find the end of the node name. */
|
||
end = j;
|
||
while (line[end] != 0 && line[end] != ',' && line[end] != '\n'
|
||
&& line[end] != '\t')
|
||
end++;
|
||
dir_nodes->name = copy_string (line + j, end - j);
|
||
}
|
||
node_header_flag = 0;
|
||
}
|
||
|
||
/* Notice the start of a node. */
|
||
if (*dir_lines[i].start == 037)
|
||
{
|
||
struct node *next
|
||
= (struct node *) xmalloc (sizeof (struct node));
|
||
next->next = dir_nodes;
|
||
next->name = NULL;
|
||
next->start_line = i;
|
||
next->end_line = 0;
|
||
next->menu_start = NULL;
|
||
next->sections = NULL;
|
||
next->last_section = NULL;
|
||
|
||
if (dir_nodes != 0)
|
||
dir_nodes->end_line = i;
|
||
/* Fill in the end of the last menu section
|
||
of the previous node. */
|
||
if (dir_nodes != 0 && dir_nodes->last_section != 0)
|
||
dir_nodes->last_section->end_line = i;
|
||
|
||
dir_nodes = next;
|
||
|
||
/* The following line is the header of this node;
|
||
parse it. */
|
||
node_header_flag = 1;
|
||
}
|
||
|
||
/* Notice the lines that start menus. */
|
||
if (dir_nodes != 0
|
||
&& !strncmp ("* Menu:", dir_lines[i].start, 7))
|
||
dir_nodes->menu_start = dir_lines[i + 1].start;
|
||
|
||
/* Notice sections in menus. */
|
||
if (dir_nodes != 0
|
||
&& dir_nodes->menu_start != 0
|
||
&& *dir_lines[i].start != '\n'
|
||
&& *dir_lines[i].start != '*'
|
||
&& *dir_lines[i].start != ' '
|
||
&& *dir_lines[i].start != '\t')
|
||
{
|
||
/* Add this menu section to the node's list.
|
||
This list grows in forward order. */
|
||
struct menu_section *next
|
||
= (struct menu_section *) xmalloc (sizeof (struct menu_section));
|
||
next->start_line = i + 1;
|
||
next->next = 0;
|
||
next->end_line = 0;
|
||
next->name = copy_string (dir_lines[i].start, dir_lines[i].size);
|
||
if (dir_nodes->sections)
|
||
{
|
||
dir_nodes->last_section->next = next;
|
||
dir_nodes->last_section->end_line = i;
|
||
}
|
||
else
|
||
dir_nodes->sections = next;
|
||
dir_nodes->last_section = next;
|
||
}
|
||
|
||
/* Check for an existing entry that should be deleted.
|
||
Delete all entries which specify this file name. */
|
||
if (*dir_lines[i].start == '*')
|
||
{
|
||
char *p = dir_lines[i].start;
|
||
|
||
while (*p != 0 && *p != ':')
|
||
p++;
|
||
p++;
|
||
while (*p == ' ') p++;
|
||
if (*p == '(')
|
||
{
|
||
p++;
|
||
if ((dir_lines[i].size
|
||
> (p - dir_lines[i].start + infilelen_sans_info))
|
||
&& !strncmp (p, infile_sans_info, infilelen_sans_info)
|
||
&& (p[infilelen_sans_info] == ')'
|
||
|| !strncmp (p + infilelen_sans_info, ".info)", 6)))
|
||
{
|
||
dir_lines[i].delete = 1;
|
||
something_deleted = 1;
|
||
}
|
||
}
|
||
}
|
||
/* Treat lines that start with whitespace
|
||
as continuations; if we are deleting an entry,
|
||
delete all its continuations as well. */
|
||
else if (i > 0
|
||
&& (*dir_lines[i].start == ' '
|
||
|| *dir_lines[i].start == '\t'))
|
||
{
|
||
dir_lines[i].delete = dir_lines[i - 1].delete;
|
||
something_deleted = 1;
|
||
}
|
||
}
|
||
|
||
/* Finish the info about the end of the last node. */
|
||
if (dir_nodes != 0)
|
||
{
|
||
dir_nodes->end_line = dir_nlines;
|
||
if (dir_nodes->last_section != 0)
|
||
dir_nodes->last_section->end_line = dir_nlines;
|
||
}
|
||
|
||
/* Decide where to add the new entries (unless --delete was used).
|
||
Find the menu sections to add them in.
|
||
In each section, find the proper alphabetical place to add
|
||
each of the entries. */
|
||
|
||
if (!delete_flag)
|
||
{
|
||
struct node *node;
|
||
struct menu_section *section;
|
||
struct spec_section *spec;
|
||
|
||
for (node = dir_nodes; node; node = node->next)
|
||
for (section = node->sections; section; section = section->next)
|
||
{
|
||
for (i = section->end_line; i > section->start_line; i--)
|
||
if (dir_lines[i - 1].size != 0)
|
||
break;
|
||
section->end_line = i;
|
||
|
||
for (spec = input_sections; spec; spec = spec->next)
|
||
if (!strcmp (spec->name, section->name))
|
||
break;
|
||
if (spec)
|
||
{
|
||
int add_at_line = section->end_line;
|
||
struct spec_entry *entry;
|
||
/* Say we have found at least one section with this name,
|
||
so we need not add such a section. */
|
||
spec->missing = 0;
|
||
/* For each entry, find the right place in this section
|
||
to add it. */
|
||
for (entry = entries_to_add; entry; entry = entry->next)
|
||
{
|
||
int textlen = strlen (entry->text);
|
||
/* Subtract one because dir_lines is zero-based,
|
||
but the `end_line' and `start_line' members are
|
||
one-based. */
|
||
for (i = section->end_line - 1;
|
||
i >= section->start_line - 1; i--)
|
||
{
|
||
/* If an entry exists with the same name,
|
||
and was not marked for deletion
|
||
(which means it is for some other file),
|
||
we are in trouble. */
|
||
if (dir_lines[i].start[0] == '*'
|
||
&& menu_line_equal (entry->text, textlen,
|
||
dir_lines[i].start,
|
||
dir_lines[i].size)
|
||
&& !dir_lines[i].delete)
|
||
fatal (_("menu item `%s' already exists, for file `%s'"),
|
||
extract_menu_item_name (entry->text),
|
||
extract_menu_file_name (dir_lines[i].start));
|
||
if (dir_lines[i].start[0] == '*'
|
||
&& menu_line_lessp (entry->text, textlen,
|
||
dir_lines[i].start,
|
||
dir_lines[i].size))
|
||
add_at_line = i;
|
||
}
|
||
insert_entry_here (entry, add_at_line,
|
||
dir_lines, n_entries_to_add);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* Mark the end of the Top node as the place to add any
|
||
new sections that are needed. */
|
||
for (node = dir_nodes; node; node = node->next)
|
||
if (node->name && strcmp (node->name, "Top") == 0)
|
||
dir_lines[node->end_line].add_sections_before = 1;
|
||
}
|
||
|
||
if (delete_flag && !something_deleted && !quiet_flag)
|
||
warning (_("no entries found for `%s'; nothing deleted"), infile);
|
||
|
||
/* Output the old dir file, interpolating the new sections
|
||
and/or new entries where appropriate. */
|
||
|
||
output = fopen (dirfile, "w");
|
||
if (!output)
|
||
{
|
||
perror (dirfile);
|
||
exit (1);
|
||
}
|
||
|
||
for (i = 0; i <= dir_nlines; i++)
|
||
{
|
||
int j;
|
||
|
||
/* If we decided to output some new entries before this line,
|
||
output them now. */
|
||
if (dir_lines[i].add_entries_before)
|
||
for (j = 0; j < n_entries_to_add; j++)
|
||
{
|
||
struct spec_entry *this = dir_lines[i].add_entries_before[j];
|
||
if (this == 0)
|
||
break;
|
||
fputs (this->text, output);
|
||
}
|
||
/* If we decided to add some sections here
|
||
because there are no such sections in the file,
|
||
output them now. */
|
||
if (dir_lines[i].add_sections_before)
|
||
{
|
||
struct spec_section *spec;
|
||
struct spec_section **sections;
|
||
int n_sections = 0;
|
||
|
||
/* Count the sections and allocate a vector for all of them. */
|
||
for (spec = input_sections; spec; spec = spec->next)
|
||
n_sections++;
|
||
sections = ((struct spec_section **)
|
||
xmalloc (n_sections * sizeof (struct spec_section *)));
|
||
|
||
/* Fill the vector SECTIONS with pointers to all the sections,
|
||
and sort them. */
|
||
j = 0;
|
||
for (spec = input_sections; spec; spec = spec->next)
|
||
sections[j++] = spec;
|
||
qsort (sections, n_sections, sizeof (struct spec_section *),
|
||
compare_section_names);
|
||
|
||
/* Generate the new sections in alphabetical order.
|
||
In each new section, output all of our entries. */
|
||
for (j = 0; j < n_sections; j++)
|
||
{
|
||
spec = sections[j];
|
||
if (spec->missing)
|
||
{
|
||
struct spec_entry *entry;
|
||
|
||
putc ('\n', output);
|
||
fputs (spec->name, output);
|
||
putc ('\n', output);
|
||
for (entry = entries_to_add; entry; entry = entry->next)
|
||
fputs (entry->text, output);
|
||
}
|
||
}
|
||
|
||
free (sections);
|
||
}
|
||
|
||
/* Output the original dir lines unless marked for deletion. */
|
||
if (i < dir_nlines && !dir_lines[i].delete)
|
||
{
|
||
fwrite (dir_lines[i].start, 1, dir_lines[i].size, output);
|
||
putc ('\n', output);
|
||
}
|
||
}
|
||
|
||
fclose (output);
|
||
|
||
exit (0);
|
||
}
|
||
|
||
/* Read all of file FILNAME into memory
|
||
and return the address of the data.
|
||
Store the size into SIZEP.
|
||
If there is trouble, do a fatal error. */
|
||
|
||
char *
|
||
readfile (filename, sizep)
|
||
char *filename;
|
||
int *sizep;
|
||
{
|
||
int desc;
|
||
int data_size = 1024;
|
||
char *data = (char *) xmalloc (data_size);
|
||
int filled = 0;
|
||
int nread = 0;
|
||
#ifdef HAVE_LIBZ
|
||
int isGZ = 0;
|
||
gzFile zdesc;
|
||
#endif
|
||
|
||
desc = open (filename, O_RDONLY);
|
||
if (desc < 0)
|
||
pfatal_with_name (filename);
|
||
|
||
#ifdef HAVE_LIBZ
|
||
/* The file should always be two bytes long. */
|
||
if (read (desc, data, 2) != 2)
|
||
pfatal_with_name (filename);
|
||
|
||
/* Undo that read. */
|
||
lseek (desc, 0, SEEK_SET);
|
||
|
||
/* If we see gzip magic, use gzdopen. */
|
||
if (data[0] == '\x1f' && data[1] == '\x8b')
|
||
{
|
||
isGZ = 1;
|
||
zdesc = gzdopen (desc, "r");
|
||
if (zdesc == NULL) {
|
||
close (desc);
|
||
pfatal_with_name (filename);
|
||
}
|
||
}
|
||
#endif /* HAVE_LIBZ */
|
||
|
||
while (1)
|
||
{
|
||
#ifdef HAVE_LIBZ
|
||
if (isGZ)
|
||
nread = gzread (zdesc, data + filled, data_size - filled);
|
||
else
|
||
#endif
|
||
nread = read (desc, data + filled, data_size - filled);
|
||
|
||
if (nread < 0)
|
||
pfatal_with_name (filename);
|
||
if (nread == 0)
|
||
break;
|
||
|
||
filled += nread;
|
||
if (filled == data_size)
|
||
{
|
||
data_size *= 2;
|
||
data = (char *) xrealloc (data, data_size);
|
||
}
|
||
}
|
||
|
||
*sizep = filled;
|
||
|
||
#ifdef HAVE_LIBZ
|
||
if (isGZ)
|
||
gzclose (zdesc);
|
||
else
|
||
#endif
|
||
close(desc);
|
||
|
||
return data;
|
||
}
|
||
|
||
/* Divide the text at DATA (of SIZE bytes) into lines.
|
||
Return a vector of struct line_data describing the lines.
|
||
Store the length of that vector into *NLINESP. */
|
||
|
||
struct line_data *
|
||
findlines (data, size, nlinesp)
|
||
char *data;
|
||
int size;
|
||
int *nlinesp;
|
||
{
|
||
struct line_data *lines;
|
||
int lines_allocated = 512;
|
||
int filled = 0;
|
||
int i = 0;
|
||
int lineflag;
|
||
|
||
lines = (struct line_data *) xmalloc (lines_allocated * sizeof (struct line_data));
|
||
|
||
lineflag = 1;
|
||
for (i = 0; i < size; i++)
|
||
{
|
||
if (lineflag)
|
||
{
|
||
if (filled == lines_allocated)
|
||
{
|
||
lines_allocated *= 2;
|
||
lines = (struct line_data *) xrealloc (lines, lines_allocated * sizeof (struct line_data));
|
||
}
|
||
lines[filled].start = &data[i];
|
||
lines[filled].add_entries_before = 0;
|
||
lines[filled].add_sections_before = 0;
|
||
lines[filled].delete = 0;
|
||
if (filled > 0)
|
||
lines[filled - 1].size
|
||
= lines[filled].start - lines[filled - 1].start - 1;
|
||
filled++;
|
||
}
|
||
lineflag = (data[i] == '\n');
|
||
}
|
||
if (filled > 0)
|
||
lines[filled - 1].size = &data[i] - lines[filled - 1].start - lineflag;
|
||
|
||
/* Do not leave garbage in the last element. */
|
||
lines[filled].start = NULL;
|
||
lines[filled].add_entries_before = NULL;
|
||
lines[filled].add_sections_before = 0;
|
||
lines[filled].delete = 0;
|
||
lines[filled].size = 0;
|
||
|
||
*nlinesp = filled;
|
||
return lines;
|
||
}
|
||
|
||
/* Compare the menu item names in LINE1 (line length LEN1)
|
||
and LINE2 (line length LEN2). Return 1 if the item name
|
||
in LINE1 is less, 0 otherwise. */
|
||
|
||
int
|
||
menu_line_lessp (line1, len1, line2, len2)
|
||
char *line1;
|
||
int len1;
|
||
char *line2;
|
||
int len2;
|
||
{
|
||
int minlen = (len1 < len2 ? len1 : len2);
|
||
int i;
|
||
|
||
for (i = 0; i < minlen; i++)
|
||
{
|
||
/* If one item name is a prefix of the other,
|
||
the former one is less. */
|
||
if (line1[i] == ':' && line2[i] != ':')
|
||
return 1;
|
||
if (line2[i] == ':' && line1[i] != ':')
|
||
return 0;
|
||
/* If they both continue and differ, one is less. */
|
||
if (line1[i] < line2[i])
|
||
return 1;
|
||
if (line1[i] > line2[i])
|
||
return 0;
|
||
}
|
||
/* With a properly formatted dir file,
|
||
we can only get here if the item names are equal. */
|
||
return 0;
|
||
}
|
||
|
||
/* Compare the menu item names in LINE1 (line length LEN1)
|
||
and LINE2 (line length LEN2). Return 1 if the item names are equal,
|
||
0 otherwise. */
|
||
|
||
int
|
||
menu_line_equal (line1, len1, line2, len2)
|
||
char *line1;
|
||
int len1;
|
||
char *line2;
|
||
int len2;
|
||
{
|
||
int minlen = (len1 < len2 ? len1 : len2);
|
||
int i;
|
||
|
||
for (i = 0; i < minlen; i++)
|
||
{
|
||
/* If both item names end here, they are equal. */
|
||
if (line1[i] == ':' && line2[i] == ':')
|
||
return 1;
|
||
/* If they both continue and differ, one is less. */
|
||
if (line1[i] != line2[i])
|
||
return 0;
|
||
}
|
||
/* With a properly formatted dir file,
|
||
we can only get here if the item names are equal. */
|
||
return 1;
|
||
}
|
||
|
||
/* This is the comparison function for qsort
|
||
for a vector of pointers to struct spec_section.
|
||
Compare the section names. */
|
||
|
||
int
|
||
compare_section_names (sec1, sec2)
|
||
struct spec_section **sec1, **sec2;
|
||
{
|
||
char *name1 = (*sec1)->name;
|
||
char *name2 = (*sec2)->name;
|
||
return strcmp (name1, name2);
|
||
}
|
||
|
||
/* Insert ENTRY into the add_entries_before vector
|
||
for line number LINE_NUMBER of the dir file.
|
||
DIR_LINES and N_ENTRIES carry information from like-named variables
|
||
in main. */
|
||
|
||
void
|
||
insert_entry_here (entry, line_number, dir_lines, n_entries)
|
||
struct spec_entry *entry;
|
||
int line_number;
|
||
struct line_data *dir_lines;
|
||
int n_entries;
|
||
{
|
||
int i;
|
||
|
||
if (dir_lines[line_number].add_entries_before == 0)
|
||
{
|
||
dir_lines[line_number].add_entries_before
|
||
= (struct spec_entry **) xmalloc (n_entries * sizeof (struct spec_entry *));
|
||
for (i = 0; i < n_entries; i++)
|
||
dir_lines[line_number].add_entries_before[i] = 0;
|
||
}
|
||
|
||
for (i = 0; i < n_entries; i++)
|
||
if (dir_lines[line_number].add_entries_before[i] == 0)
|
||
break;
|
||
|
||
if (i == n_entries)
|
||
abort ();
|
||
|
||
dir_lines[line_number].add_entries_before[i] = entry;
|
||
}
|