697 lines
18 KiB
C
697 lines
18 KiB
C
/* info-utils.c -- miscellanous.
|
||
$Id: info-utils.c,v 1.2 2003/03/06 23:22:23 karl Exp $
|
||
|
||
Copyright (C) 1993, 1998, 2003 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.
|
||
|
||
Written by Brian Fox (bfox@ai.mit.edu). */
|
||
|
||
#include "info.h"
|
||
#include "info-utils.h"
|
||
#if defined (HANDLE_MAN_PAGES)
|
||
# include "man.h"
|
||
#endif /* HANDLE_MAN_PAGES */
|
||
|
||
/* When non-zero, various display and input functions handle ISO Latin
|
||
character sets correctly. */
|
||
int ISO_Latin_p = 1;
|
||
|
||
/* Variable which holds the most recent filename parsed as a result of
|
||
calling info_parse_xxx (). */
|
||
char *info_parsed_filename = (char *)NULL;
|
||
|
||
/* Variable which holds the most recent nodename parsed as a result of
|
||
calling info_parse_xxx (). */
|
||
char *info_parsed_nodename = (char *)NULL;
|
||
|
||
/* Functions to remember a filename or nodename for later return. */
|
||
static void save_filename (), saven_filename ();
|
||
static void save_nodename (), saven_nodename ();
|
||
|
||
/* How to get a reference (either menu or cross). */
|
||
static REFERENCE **info_references_internal ();
|
||
|
||
/* Parse the filename and nodename out of STRING. If STRING doesn't
|
||
contain a filename (i.e., it is NOT (FILENAME)NODENAME) then set
|
||
INFO_PARSED_FILENAME to NULL. If second argument NEWLINES_OKAY is
|
||
non-zero, it says to allow the nodename specification to cross a
|
||
newline boundary (i.e., only `,', `.', or `TAB' can end the spec). */
|
||
void
|
||
info_parse_node (string, newlines_okay)
|
||
char *string;
|
||
int newlines_okay;
|
||
{
|
||
register int i = 0;
|
||
|
||
/* Default the answer. */
|
||
save_filename ((char *)NULL);
|
||
save_nodename ((char *)NULL);
|
||
|
||
/* Special case of nothing passed. Return nothing. */
|
||
if (!string || !*string)
|
||
return;
|
||
|
||
string += skip_whitespace (string);
|
||
|
||
/* Check for (FILENAME)NODENAME. */
|
||
if (*string == '(')
|
||
{
|
||
i = 0;
|
||
/* Advance past the opening paren. */
|
||
string++;
|
||
|
||
/* Find the closing paren. */
|
||
while (string[i] && string[i] != ')')
|
||
i++;
|
||
|
||
/* Remember parsed filename. */
|
||
saven_filename (string, i);
|
||
|
||
/* Point directly at the nodename. */
|
||
string += i;
|
||
|
||
if (*string)
|
||
string++;
|
||
}
|
||
|
||
/* Parse out nodename. */
|
||
i = skip_node_characters (string, newlines_okay);
|
||
saven_nodename (string, i);
|
||
canonicalize_whitespace (info_parsed_nodename);
|
||
if (info_parsed_nodename && !*info_parsed_nodename)
|
||
{
|
||
free (info_parsed_nodename);
|
||
info_parsed_nodename = (char *)NULL;
|
||
}
|
||
}
|
||
|
||
/* Return the node addressed by LABEL in NODE (usually one of "Prev:",
|
||
"Next:", "Up:", "File:", or "Node:". After a call to this function,
|
||
the global INFO_PARSED_NODENAME and INFO_PARSED_FILENAME contain
|
||
the information. */
|
||
void
|
||
info_parse_label (label, node)
|
||
char *label;
|
||
NODE *node;
|
||
{
|
||
register int i;
|
||
char *nodeline;
|
||
|
||
/* Default answer to failure. */
|
||
save_nodename ((char *)NULL);
|
||
save_filename ((char *)NULL);
|
||
|
||
/* Find the label in the first line of this node. */
|
||
nodeline = node->contents;
|
||
i = string_in_line (label, nodeline);
|
||
|
||
if (i == -1)
|
||
return;
|
||
|
||
nodeline += i;
|
||
nodeline += skip_whitespace (nodeline);
|
||
info_parse_node (nodeline, DONT_SKIP_NEWLINES);
|
||
}
|
||
|
||
/* **************************************************************** */
|
||
/* */
|
||
/* Finding and Building Menus */
|
||
/* */
|
||
/* **************************************************************** */
|
||
|
||
/* Return a NULL terminated array of REFERENCE * which represents the menu
|
||
found in NODE. If there is no menu in NODE, just return a NULL pointer. */
|
||
REFERENCE **
|
||
info_menu_of_node (node)
|
||
NODE *node;
|
||
{
|
||
long position;
|
||
SEARCH_BINDING search;
|
||
REFERENCE **menu = (REFERENCE **)NULL;
|
||
|
||
search.buffer = node->contents;
|
||
search.start = 0;
|
||
search.end = node->nodelen;
|
||
search.flags = S_FoldCase;
|
||
|
||
/* Find the start of the menu. */
|
||
position = search_forward (INFO_MENU_LABEL, &search);
|
||
|
||
if (position == -1)
|
||
return ((REFERENCE **) NULL);
|
||
|
||
/* We have the start of the menu now. Glean menu items from the rest
|
||
of the node. */
|
||
search.start = position + strlen (INFO_MENU_LABEL);
|
||
search.start += skip_line (search.buffer + search.start);
|
||
search.start--;
|
||
menu = info_menu_items (&search);
|
||
return (menu);
|
||
}
|
||
|
||
/* Return a NULL terminated array of REFERENCE * which represents the cross
|
||
refrences found in NODE. If there are no cross references in NODE, just
|
||
return a NULL pointer. */
|
||
REFERENCE **
|
||
info_xrefs_of_node (node)
|
||
NODE *node;
|
||
{
|
||
SEARCH_BINDING search;
|
||
|
||
#if defined (HANDLE_MAN_PAGES)
|
||
if (node->flags & N_IsManPage)
|
||
return (xrefs_of_manpage (node));
|
||
#endif
|
||
|
||
search.buffer = node->contents;
|
||
search.start = 0;
|
||
search.end = node->nodelen;
|
||
search.flags = S_FoldCase;
|
||
|
||
return (info_xrefs (&search));
|
||
}
|
||
|
||
/* Glean menu entries from BINDING->buffer + BINDING->start until we
|
||
have looked at the entire contents of BINDING. Return an array
|
||
of REFERENCE * that represents each menu item in this range. */
|
||
REFERENCE **
|
||
info_menu_items (binding)
|
||
SEARCH_BINDING *binding;
|
||
{
|
||
return (info_references_internal (INFO_MENU_ENTRY_LABEL, binding));
|
||
}
|
||
|
||
/* Glean cross references from BINDING->buffer + BINDING->start until
|
||
BINDING->end. Return an array of REFERENCE * that represents each
|
||
cross reference in this range. */
|
||
REFERENCE **
|
||
info_xrefs (binding)
|
||
SEARCH_BINDING *binding;
|
||
{
|
||
return (info_references_internal (INFO_XREF_LABEL, binding));
|
||
}
|
||
|
||
/* Glean cross references or menu items from BINDING. Return an array
|
||
of REFERENCE * that represents the items found. */
|
||
static REFERENCE **
|
||
info_references_internal (label, binding)
|
||
char *label;
|
||
SEARCH_BINDING *binding;
|
||
{
|
||
SEARCH_BINDING search;
|
||
REFERENCE **refs = (REFERENCE **)NULL;
|
||
int refs_index = 0, refs_slots = 0;
|
||
int searching_for_menu_items = 0;
|
||
long position;
|
||
|
||
search.buffer = binding->buffer;
|
||
search.start = binding->start;
|
||
search.end = binding->end;
|
||
search.flags = S_FoldCase | S_SkipDest;
|
||
|
||
searching_for_menu_items = (strcasecmp (label, INFO_MENU_ENTRY_LABEL) == 0);
|
||
|
||
while ((position = search_forward (label, &search)) != -1)
|
||
{
|
||
int offset, start;
|
||
char *refdef;
|
||
REFERENCE *entry;
|
||
|
||
search.start = position;
|
||
search.start += skip_whitespace (search.buffer + search.start);
|
||
start = search.start - binding->start;
|
||
refdef = search.buffer + search.start;
|
||
offset = string_in_line (":", refdef);
|
||
|
||
/* When searching for menu items, if no colon, there is no
|
||
menu item on this line. */
|
||
if (offset == -1)
|
||
{
|
||
if (searching_for_menu_items)
|
||
continue;
|
||
else
|
||
{
|
||
int temp;
|
||
|
||
temp = skip_line (refdef);
|
||
offset = string_in_line (":", refdef + temp);
|
||
if (offset == -1)
|
||
continue; /* Give up? */
|
||
else
|
||
offset += temp;
|
||
}
|
||
}
|
||
|
||
entry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
|
||
entry->filename = (char *)NULL;
|
||
entry->nodename = (char *)NULL;
|
||
entry->label = (char *)xmalloc (offset);
|
||
strncpy (entry->label, refdef, offset - 1);
|
||
entry->label[offset - 1] = '\0';
|
||
canonicalize_whitespace (entry->label);
|
||
|
||
refdef += offset;
|
||
entry->start = start;
|
||
entry->end = refdef - binding->buffer;
|
||
|
||
/* If this reference entry continues with another ':' then the
|
||
nodename is the same as the label. */
|
||
if (*refdef == ':')
|
||
{
|
||
entry->nodename = xstrdup (entry->label);
|
||
}
|
||
else
|
||
{
|
||
/* This entry continues with a specific nodename. Parse the
|
||
nodename from the specification. */
|
||
|
||
refdef += skip_whitespace_and_newlines (refdef);
|
||
|
||
if (searching_for_menu_items)
|
||
info_parse_node (refdef, DONT_SKIP_NEWLINES);
|
||
else
|
||
info_parse_node (refdef, SKIP_NEWLINES);
|
||
|
||
if (info_parsed_filename)
|
||
entry->filename = xstrdup (info_parsed_filename);
|
||
|
||
if (info_parsed_nodename)
|
||
entry->nodename = xstrdup (info_parsed_nodename);
|
||
}
|
||
|
||
add_pointer_to_array
|
||
(entry, refs_index, refs, refs_slots, 50, REFERENCE *);
|
||
}
|
||
return (refs);
|
||
}
|
||
|
||
/* Get the entry associated with LABEL in REFERENCES. Return a pointer
|
||
to the ENTRY if found, or NULL. */
|
||
REFERENCE *
|
||
info_get_labeled_reference (label, references)
|
||
char *label;
|
||
REFERENCE **references;
|
||
{
|
||
register int i;
|
||
REFERENCE *entry;
|
||
|
||
for (i = 0; references && (entry = references[i]); i++)
|
||
{
|
||
if (strcmp (label, entry->label) == 0)
|
||
return (entry);
|
||
}
|
||
return ((REFERENCE *)NULL);
|
||
}
|
||
|
||
/* A utility function for concatenating REFERENCE **. Returns a new
|
||
REFERENCE ** which is the concatenation of REF1 and REF2. The REF1
|
||
and REF2 arrays are freed, but their contents are not. */
|
||
REFERENCE **
|
||
info_concatenate_references (ref1, ref2)
|
||
REFERENCE **ref1, **ref2;
|
||
{
|
||
register int i, j;
|
||
REFERENCE **result;
|
||
int size;
|
||
|
||
/* With one argument passed as NULL, simply return the other arg. */
|
||
if (!ref1)
|
||
return (ref2);
|
||
else if (!ref2)
|
||
return (ref1);
|
||
|
||
/* Get the total size of the slots that we will need. */
|
||
for (i = 0; ref1[i]; i++);
|
||
size = i;
|
||
for (i = 0; ref2[i]; i++);
|
||
size += i;
|
||
|
||
result = (REFERENCE **)xmalloc ((1 + size) * sizeof (REFERENCE *));
|
||
|
||
/* Copy the contents over. */
|
||
for (i = 0; ref1[i]; i++)
|
||
result[i] = ref1[i];
|
||
|
||
j = i;
|
||
for (i = 0; ref2[i]; i++)
|
||
result[j++] = ref2[i];
|
||
|
||
result[j] = (REFERENCE *)NULL;
|
||
free (ref1);
|
||
free (ref2);
|
||
return (result);
|
||
}
|
||
|
||
|
||
|
||
/* Copy a reference structure. Since we tend to free everything at
|
||
every opportunity, we don't share any points, but copy everything into
|
||
new memory. */
|
||
REFERENCE *
|
||
info_copy_reference (src)
|
||
REFERENCE *src;
|
||
{
|
||
REFERENCE *dest = xmalloc (sizeof (REFERENCE));
|
||
dest->label = src->label ? xstrdup (src->label) : NULL;
|
||
dest->filename = src->filename ? xstrdup (src->filename) : NULL;
|
||
dest->nodename = src->nodename ? xstrdup (src->nodename) : NULL;
|
||
dest->start = src->start;
|
||
dest->end = src->end;
|
||
|
||
return dest;
|
||
}
|
||
|
||
|
||
|
||
/* Free the data associated with REFERENCES. */
|
||
void
|
||
info_free_references (references)
|
||
REFERENCE **references;
|
||
{
|
||
register int i;
|
||
REFERENCE *entry;
|
||
|
||
if (references)
|
||
{
|
||
for (i = 0; references && (entry = references[i]); i++)
|
||
{
|
||
maybe_free (entry->label);
|
||
maybe_free (entry->filename);
|
||
maybe_free (entry->nodename);
|
||
|
||
free (entry);
|
||
}
|
||
|
||
free (references);
|
||
}
|
||
}
|
||
|
||
/* Search for sequences of whitespace or newlines in STRING, replacing
|
||
all such sequences with just a single space. Remove whitespace from
|
||
start and end of string. */
|
||
void
|
||
canonicalize_whitespace (string)
|
||
char *string;
|
||
{
|
||
register int i, j;
|
||
int len, whitespace_found, whitespace_loc;
|
||
char *temp;
|
||
|
||
if (!string)
|
||
return;
|
||
|
||
len = strlen (string);
|
||
temp = (char *)xmalloc (1 + len);
|
||
|
||
/* Search for sequences of whitespace or newlines. Replace all such
|
||
sequences in the string with just a single space. */
|
||
|
||
whitespace_found = 0;
|
||
for (i = 0, j = 0; string[i]; i++)
|
||
{
|
||
if (whitespace_or_newline (string[i]))
|
||
{
|
||
whitespace_found++;
|
||
whitespace_loc = i;
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
if (whitespace_found && whitespace_loc)
|
||
{
|
||
whitespace_found = 0;
|
||
|
||
/* Suppress whitespace at start of string. */
|
||
if (j)
|
||
temp[j++] = ' ';
|
||
}
|
||
|
||
temp[j++] = string[i];
|
||
}
|
||
}
|
||
|
||
/* Kill trailing whitespace. */
|
||
if (j && whitespace (temp[j - 1]))
|
||
j--;
|
||
|
||
temp[j] = '\0';
|
||
strcpy (string, temp);
|
||
free (temp);
|
||
}
|
||
|
||
/* String representation of a char returned by printed_representation (). */
|
||
static char the_rep[10];
|
||
|
||
/* Return a pointer to a string which is the printed representation
|
||
of CHARACTER if it were printed at HPOS. */
|
||
char *
|
||
printed_representation (character, hpos)
|
||
unsigned char character;
|
||
int hpos;
|
||
{
|
||
register int i = 0;
|
||
int printable_limit = ISO_Latin_p ? 255 : 127;
|
||
|
||
if (raw_escapes_p && character == '\033')
|
||
the_rep[i++] = character;
|
||
/* Show CTRL-x as ^X. */
|
||
else if (iscntrl (character) && character < 127)
|
||
{
|
||
switch (character)
|
||
{
|
||
case '\r':
|
||
case '\n':
|
||
the_rep[i++] = character;
|
||
break;
|
||
|
||
case '\t':
|
||
{
|
||
int tw;
|
||
|
||
tw = ((hpos + 8) & 0xf8) - hpos;
|
||
while (i < tw)
|
||
the_rep[i++] = ' ';
|
||
}
|
||
break;
|
||
|
||
default:
|
||
the_rep[i++] = '^';
|
||
the_rep[i++] = (character | 0x40);
|
||
}
|
||
}
|
||
/* Show META-x as 0370. */
|
||
else if (character > printable_limit)
|
||
{
|
||
sprintf (the_rep + i, "\\%0o", character);
|
||
i = strlen (the_rep);
|
||
}
|
||
else if (character == DEL)
|
||
{
|
||
the_rep[i++] = '^';
|
||
the_rep[i++] = '?';
|
||
}
|
||
else
|
||
the_rep[i++] = character;
|
||
|
||
the_rep[i] = 0;
|
||
|
||
return the_rep;
|
||
}
|
||
|
||
|
||
/* **************************************************************** */
|
||
/* */
|
||
/* Functions Static To This File */
|
||
/* */
|
||
/* **************************************************************** */
|
||
|
||
/* Amount of space allocated to INFO_PARSED_FILENAME via xmalloc (). */
|
||
static int parsed_filename_size = 0;
|
||
|
||
/* Amount of space allocated to INFO_PARSED_NODENAME via xmalloc (). */
|
||
static int parsed_nodename_size = 0;
|
||
|
||
static void save_string (), saven_string ();
|
||
|
||
/* Remember FILENAME in PARSED_FILENAME. An empty FILENAME is translated
|
||
to a NULL pointer in PARSED_FILENAME. */
|
||
static void
|
||
save_filename (filename)
|
||
char *filename;
|
||
{
|
||
save_string (filename, &info_parsed_filename, &parsed_filename_size);
|
||
}
|
||
|
||
/* Just like save_filename (), but you pass the length of the string. */
|
||
static void
|
||
saven_filename (filename, len)
|
||
char *filename;
|
||
int len;
|
||
{
|
||
saven_string (filename, len,
|
||
&info_parsed_filename, &parsed_filename_size);
|
||
}
|
||
|
||
/* Remember NODENAME in PARSED_NODENAME. An empty NODENAME is translated
|
||
to a NULL pointer in PARSED_NODENAME. */
|
||
static void
|
||
save_nodename (nodename)
|
||
char *nodename;
|
||
{
|
||
save_string (nodename, &info_parsed_nodename, &parsed_nodename_size);
|
||
}
|
||
|
||
/* Just like save_nodename (), but you pass the length of the string. */
|
||
static void
|
||
saven_nodename (nodename, len)
|
||
char *nodename;
|
||
int len;
|
||
{
|
||
saven_string (nodename, len,
|
||
&info_parsed_nodename, &parsed_nodename_size);
|
||
}
|
||
|
||
/* Remember STRING in STRING_P. STRING_P should currently have STRING_SIZE_P
|
||
bytes allocated to it. An empty STRING is translated to a NULL pointer
|
||
in STRING_P. */
|
||
static void
|
||
save_string (string, string_p, string_size_p)
|
||
char *string;
|
||
char **string_p;
|
||
int *string_size_p;
|
||
{
|
||
if (!string || !*string)
|
||
{
|
||
if (*string_p)
|
||
free (*string_p);
|
||
|
||
*string_p = (char *)NULL;
|
||
*string_size_p = 0;
|
||
}
|
||
else
|
||
{
|
||
if (strlen (string) >= *string_size_p)
|
||
*string_p = (char *)xrealloc
|
||
(*string_p, (*string_size_p = 1 + strlen (string)));
|
||
|
||
strcpy (*string_p, string);
|
||
}
|
||
}
|
||
|
||
/* Just like save_string (), but you also pass the length of STRING. */
|
||
static void
|
||
saven_string (string, len, string_p, string_size_p)
|
||
char *string;
|
||
int len;
|
||
char **string_p;
|
||
int *string_size_p;
|
||
{
|
||
if (!string)
|
||
{
|
||
if (*string_p)
|
||
free (*string_p);
|
||
|
||
*string_p = (char *)NULL;
|
||
*string_size_p = 0;
|
||
}
|
||
else
|
||
{
|
||
if (len >= *string_size_p)
|
||
*string_p = (char *)xrealloc (*string_p, (*string_size_p = 1 + len));
|
||
|
||
strncpy (*string_p, string, len);
|
||
(*string_p)[len] = '\0';
|
||
}
|
||
}
|
||
|
||
/* Return a pointer to the part of PATHNAME that simply defines the file. */
|
||
char *
|
||
filename_non_directory (pathname)
|
||
char *pathname;
|
||
{
|
||
register char *filename = pathname + strlen (pathname);
|
||
|
||
if (HAVE_DRIVE (pathname))
|
||
pathname += 2;
|
||
|
||
while (filename > pathname && !IS_SLASH (filename[-1]))
|
||
filename--;
|
||
|
||
return (filename);
|
||
}
|
||
|
||
/* Return non-zero if NODE is one especially created by Info. */
|
||
int
|
||
internal_info_node_p (node)
|
||
NODE *node;
|
||
{
|
||
#if defined (NEVER)
|
||
if (node &&
|
||
(node->filename && !*node->filename) &&
|
||
!node->parent && node->nodename)
|
||
return (1);
|
||
else
|
||
return (0);
|
||
#else
|
||
return ((node != (NODE *)NULL) && ((node->flags & N_IsInternal) != 0));
|
||
#endif /* !NEVER */
|
||
}
|
||
|
||
/* Make NODE appear to be one especially created by Info. */
|
||
void
|
||
name_internal_node (node, name)
|
||
NODE *node;
|
||
char *name;
|
||
{
|
||
if (!node)
|
||
return;
|
||
|
||
node->filename = "";
|
||
node->parent = (char *)NULL;
|
||
node->nodename = name;
|
||
node->flags |= N_IsInternal;
|
||
}
|
||
|
||
/* Return the window displaying NAME, the name of an internally created
|
||
Info window. */
|
||
WINDOW *
|
||
get_internal_info_window (name)
|
||
char *name;
|
||
{
|
||
WINDOW *win;
|
||
|
||
for (win = windows; win; win = win->next)
|
||
if (internal_info_node_p (win->node) &&
|
||
(strcmp (win->node->nodename, name) == 0))
|
||
break;
|
||
|
||
return (win);
|
||
}
|
||
|
||
/* Return a window displaying the node NODE. */
|
||
WINDOW *
|
||
get_window_of_node (node)
|
||
NODE *node;
|
||
{
|
||
WINDOW *win = (WINDOW *)NULL;
|
||
|
||
for (win = windows; win; win = win->next)
|
||
if (win->node == node)
|
||
break;
|
||
|
||
return (win);
|
||
}
|