/* info-utils.c -- miscellanous. $Id: info-utils.c 5191 2013-02-23 00:11:18Z karl $ Copyright (C) 1993, 1998, 2003, 2004, 2007, 2008, 2009, 2011, 2012, 2013 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 3 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, see . Originally written by Brian Fox. */ #include "info.h" #include "info-utils.h" #if defined (HANDLE_MAN_PAGES) # include "man.h" #endif /* HANDLE_MAN_PAGES */ #ifdef __hpux #define va_copy(ap1,ap2) memcpy((&ap1),(&ap2),sizeof(va_list)) #endif /* 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 = NULL; /* Variable which holds the most recent nodename parsed as a result of calling info_parse_xxx (). */ char *info_parsed_nodename = NULL; /* Variable which holds the most recent line number parsed as a result of calling info_parse_xxx (). */ int info_parsed_line_number = 0; static void save_string (char *string, char **string_p, int *string_size_p); static void saven_string (char *string, int len, char **string_p, int *string_size_p); /* Functions to remember a filename or nodename for later return. */ static void save_filename (char *filename); static void saven_filename (char *filename, int len); static void save_nodename (char *nodename); static void saven_nodename (char *nodename, int len); /* How to get a reference (either menu or cross). */ static REFERENCE **info_references_internal (char *label, SEARCH_BINDING *binding); /* 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. The second argument is one of the PARSE_NODE_* constants. It specifies how to parse the node name: PARSE_NODE_DFLT Node name stops at LF, `,', `.', or `TAB' PARSE_NODE_SKIP_NEWLINES Node name stops at `,', `.', or `TAB' PARSE_NODE_VERBATIM Don't parse nodename */ void info_parse_node (char *string, int flag) { register int i = 0; /* Default the answer. */ save_filename (NULL); save_nodename (NULL); /* Special case of nothing passed. Return nothing. */ if (!string || !*string) return; string += skip_whitespace (string); /* Check for (FILENAME)NODENAME. */ if (*string == '(') { int bcnt; int bfirst; i = 0; /* Advance past the opening paren. */ string++; /* Find the closing paren. Handle nested parens correctly. */ for (bcnt = 0, bfirst = -1; string[i]; i++) { if (string[i] == ')') { if (bcnt == 0) { bfirst = -1; break; } else if (!bfirst) bfirst = i; bcnt--; } else if (string[i] == '(') bcnt++; } if (bfirst >= 0) i = bfirst; /* 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, flag); saven_nodename (string, i); canonicalize_whitespace (info_parsed_nodename); if (info_parsed_nodename && !*info_parsed_nodename) { free (info_parsed_nodename); info_parsed_nodename = NULL; } /* Parse ``(line ...)'' part of menus, if any. */ { char *rest = string + i; /* Advance only if it's not already at end of string. */ if (*rest) rest++; /* Skip any whitespace first, and then a newline in case the item was so long to contain the ``(line ...)'' string in the same physical line. */ while (whitespace(*rest)) rest++; if (*rest == '\n') { rest++; while (whitespace(*rest)) rest++; } /* Are we looking at an opening parenthesis? That can only mean we have a winner. :) */ if (strncmp (rest, "(line ", strlen ("(line ")) == 0) { rest += strlen ("(line "); info_parsed_line_number = strtol (rest, NULL, 0); } else info_parsed_line_number = 0; } } /* 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 (char *label, NODE *node) { register int i; char *nodeline; /* Default answer to failure. */ save_nodename (NULL); save_filename (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, PARSE_NODE_DFLT); } /* **************************************************************** */ /* */ /* 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) { long position; SEARCH_BINDING tmp_search; REFERENCE **menu = NULL; tmp_search.buffer = node->contents; tmp_search.start = 0; tmp_search.end = node->nodelen; tmp_search.flags = S_FoldCase; /* Find the start of the menu. */ if (search_forward (INFO_MENU_LABEL, &tmp_search, &position) != search_success) return NULL; /* We have the start of the menu now. Glean menu items from the rest of the node. */ tmp_search.start = position + strlen (INFO_MENU_LABEL); tmp_search.start += skip_line (tmp_search.buffer + tmp_search.start); tmp_search.start--; menu = info_menu_items (&tmp_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) { SEARCH_BINDING tmp_search; #if defined (HANDLE_MAN_PAGES) if (node->flags & N_IsManPage) return xrefs_of_manpage (node); #endif tmp_search.buffer = node->contents; tmp_search.start = 0; tmp_search.end = node->nodelen; tmp_search.flags = S_FoldCase; return info_xrefs (&tmp_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 (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 (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 (char *label, SEARCH_BINDING *binding) { SEARCH_BINDING tmp_search; REFERENCE **refs = NULL; int refs_index = 0, refs_slots = 0; int searching_for_menu_items = 0; long position; tmp_search.buffer = binding->buffer; tmp_search.start = binding->start; tmp_search.end = binding->end; tmp_search.flags = S_FoldCase | S_SkipDest; searching_for_menu_items = (mbscasecmp (label, INFO_MENU_ENTRY_LABEL) == 0); while (search_forward (label, &tmp_search, &position) == search_success) { int offset, start; char *refdef; REFERENCE *entry; tmp_search.start = position; tmp_search.start += skip_whitespace (tmp_search.buffer + tmp_search.start); start = tmp_search.start - binding->start; refdef = tmp_search.buffer + tmp_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 = xmalloc (sizeof (REFERENCE)); entry->filename = NULL; entry->nodename = NULL; entry->label = xmalloc (offset); strncpy (entry->label, refdef, offset - 1); entry->label[offset - 1] = '\0'; canonicalize_whitespace (entry->label); entry->line_number = 0; 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, PARSE_NODE_DFLT); else info_parse_node (refdef, PARSE_NODE_SKIP_NEWLINES); if (info_parsed_filename) entry->filename = xstrdup (info_parsed_filename); if (info_parsed_nodename) entry->nodename = xstrdup (info_parsed_nodename); entry->line_number = info_parsed_line_number; } 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 (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 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 (REFERENCE **ref1, REFERENCE **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 = 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] = 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 (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; dest->line_number = 0; return dest; } /* Free the data associated with REFERENCES. */ void info_free_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 (char *string) { register int i, j; int len, whitespace_found, whitespace_loc = 0; char *temp; if (!string) return; len = strlen (string); temp = 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; static size_t the_rep_size; /* Return a pointer to a string which is the printed representation of CHARACTER if it were printed at HPOS. */ char * printed_representation (const char *character, size_t len, size_t hpos, /* Return: */ size_t *plen) { const unsigned char *cp = (const unsigned char *) character; register int i = 0; int printable_limit = ISO_Latin_p ? 255 : 127; #define REPSPACE(s) \ do \ { \ while (the_rep_size < s) \ { \ if (the_rep_size == 0) \ the_rep_size = 8; /* Initial allocation */ \ the_rep = x2realloc (the_rep, &the_rep_size); \ } \ } \ while (0) #define SC(c) \ do \ { \ REPSPACE(i + 1); \ the_rep[i++] = c; \ } \ while (0) for (; len > 0; cp++, len--) { if (raw_escapes_p && *cp == '\033') SC(*cp); /* Show CTRL-x as ^X. */ else if (iscntrl (*cp) && *cp < 127) { switch (*cp) { case '\r': case '\n': SC(*cp); break; case '\t': { int tw; tw = ((hpos + 8) & 0xf8) - hpos; while (i < tw) SC(' '); break; } default: SC('^'); SC(*cp | 0x40); } } /* Show META-x as 0370. */ else if (*cp > printable_limit) { REPSPACE (i + 5); sprintf (the_rep + i, "\\%0o", *cp); i = strlen (the_rep); } else if (*cp == DEL) { SC('^'); SC('?'); } else SC(*cp); } SC(0); *plen = i - 1; 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; /* Remember FILENAME in PARSED_FILENAME. An empty FILENAME is translated to a NULL pointer in PARSED_FILENAME. */ static void save_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 (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 (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 (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 (char *string, char **string_p, int *string_size_p) { if (!string || !*string) { if (*string_p) free (*string_p); *string_p = NULL; *string_size_p = 0; } else if (string_size_p) { if (strlen (string) >= (unsigned int) *string_size_p) *string_p = xrealloc (*string_p, (*string_size_p = 1 + strlen (string))); strcpy (*string_p, string); } else { free (*string_p); *string_p = xstrdup (string); } } /* Just like save_string (), but you also pass the length of STRING. */ static void saven_string (char *string, int len, char **string_p, int *string_size_p) { if (!string) { if (*string_p) free (*string_p); *string_p = NULL; *string_size_p = 0; } else { if (string_size_p) { if (len >= *string_size_p) *string_p = xrealloc (*string_p, (*string_size_p = 1 + len)); } else { free (*string_p); *string_p = xmalloc (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 (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) { #if defined (NEVER) if (node && (node->filename && !*node->filename) && !node->parent && node->nodename) return 1; else return 0; #else return (node != NULL) && ((node->flags & N_IsInternal) != 0); #endif /* !NEVER */ } /* Make NODE appear to be one especially created by Info. */ void name_internal_node (NODE *node, char *name) { if (!node) return; node->filename = ""; node->parent = 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 (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) { WINDOW *win = NULL; for (win = windows; win; win = win->next) if (win->node == node) break; return win; } /* Flexible Text Buffer */ void text_buffer_init (struct text_buffer *buf) { memset (buf, 0, sizeof *buf); } void text_buffer_free (struct text_buffer *buf) { free (buf->base); } size_t text_buffer_vprintf (struct text_buffer *buf, const char *format, va_list ap) { ssize_t n; va_list ap_copy; if (!buf->base) { if (buf->size == 0) buf->size = MIN_TEXT_BUF_ALLOC; /* Initial allocation */ buf->base = xmalloc (buf->size); } for (;;) { va_copy (ap_copy, ap); n = vsnprintf (buf->base + buf->off, buf->size - buf->off, format, ap_copy); va_end (ap_copy); if (n < 0 || buf->off + n >= buf->size || !memchr (buf->base + buf->off, '\0', buf->size - buf->off + 1)) { size_t newlen = buf->size * 2; if (newlen < buf->size) xalloc_die (); buf->size = newlen; buf->base = xrealloc (buf->base, buf->size); } else { buf->off += n; break; } } return n; } void text_buffer_alloc (struct text_buffer *buf, size_t len) { if (buf->off + len > buf->size) { buf->size = buf->off + len; if (buf->size < MIN_TEXT_BUF_ALLOC) buf->size = MIN_TEXT_BUF_ALLOC; buf->base = xrealloc (buf->base, buf->size); } } size_t text_buffer_add_string (struct text_buffer *buf, const char *str, size_t len) { text_buffer_alloc (buf, len); memcpy (buf->base + buf->off, str, len); buf->off += len; return len; } size_t text_buffer_fill (struct text_buffer *buf, int c, size_t len) { char *p; int i; text_buffer_alloc (buf, len); for (i = 0, p = buf->base + buf->off; i < len; i++) *p++ = c; buf->off += len; return len; } void text_buffer_add_char (struct text_buffer *buf, int c) { char ch = c; text_buffer_add_string (buf, &ch, 1); } size_t text_buffer_printf (struct text_buffer *buf, const char *format, ...) { va_list ap; size_t n; va_start (ap, format); n = text_buffer_vprintf (buf, format, ap); va_end (ap); return n; }