Back to index

tetex-bin  3.0
Defines | Functions | Variables
man.c File Reference
#include "info.h"
#include <sys/ioctl.h>
#include "signals.h"
#include "tilde.h"
#include "man.h"

Go to the source code of this file.

Defines

#define pid_t   int

Functions

static char * read_from_fd (int fd)
static void clean_manpage (char *manpage)
static NODEmanpage_node_of_file_buffer (FILE_BUFFER *file_buffer, char *pagename)
static char * get_manpage_contents (char *pagename)
NODEmake_manpage_node (char *pagename)
NODEget_manpage_node (FILE_BUFFER *file_buffer, char *pagename)
FILE_BUFFERcreate_manpage_file_buffer (void)
static char * executable_file_in_path (char *filename, char *path)
static char * find_man_formatter (void)
static void get_page_and_section (char *pagename)
static SEARCH_BINDINGfind_reference_section (NODE *node)
REFERENCE ** xrefs_of_manpage (NODE *node)
long locate_manpage_xref (NODE *node, long int start, int dir)
REFERENCE ** manpage_xrefs_in_binding (NODE *node, SEARCH_BINDING *binding)

Variables

static char const *const exec_extensions [] = { "", NULL }
static char * manpage_pagename = (char *)NULL
static char * manpage_section = (char *)NULL
static char * reference_section_starters []
static SEARCH_BINDING frs_binding

Define Documentation

#define pid_t   int

Definition at line 37 of file man.c.


Function Documentation

static void clean_manpage ( char *  manpage) [static]

Definition at line 375 of file man.c.

{
  register int i, j;
  int newline_count = 0;
  char *newpage;

  newpage = (char *)xmalloc (1 + strlen (manpage));

  for (i = 0, j = 0; (newpage[j] = manpage[i]); i++, j++)
    {
      if (manpage[i] == '\n')
        newline_count++;
      else
        newline_count = 0;

      if (newline_count == 3)
        {
          j--;
          newline_count--;
        }

      /* A malformed man page could have a \b as its first character,
         in which case decrementing j by 2 will cause us to write into
         newpage[-1], smashing the hidden info stored there by malloc.  */
      if (manpage[i] == '\b' || (manpage[i] == '\f' && j > 0))
        j -= 2;
      else if (!raw_escapes_p)
       {
         /* Remove the ANSI escape sequences for color, boldface,
            underlining, and italics, generated by some versions of
            Groff.  */
         if (manpage[i] == '\033' && manpage[i + 1] == '['
             && isdigit (manpage[i + 2]))
           {
             if (isdigit (manpage[i + 3]) && manpage[i + 4] == 'm')
              {
                i += 4;
                j--;
              }
             else if (manpage[i + 3] == 'm')
              {
                i += 3;
                j--;
              }
             /* Else do nothing: it's some unknown escape sequence,
               so let's leave it alone.  */
           }
       }
    }

  newpage[j++] = 0;

  strcpy (manpage, newpage);
  free (newpage);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 154 of file man.c.

{
  FILE_BUFFER *file_buffer = make_file_buffer ();
  file_buffer->filename = xstrdup (MANPAGE_FILE_BUFFER_NAME);
  file_buffer->fullpath = xstrdup (MANPAGE_FILE_BUFFER_NAME);
  file_buffer->finfo.st_size = 0;
  file_buffer->filesize = 0;
  file_buffer->contents = (char *)NULL;
  file_buffer->flags = (N_IsInternal | N_CannotGC | N_IsManPage);

  return (file_buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* executable_file_in_path ( char *  filename,
char *  path 
) [static]

Definition at line 171 of file man.c.

{
  struct stat finfo;
  char *temp_dirname;
  int statable, dirname_index;

  dirname_index = 0;

  while ((temp_dirname = extract_colon_unit (path, &dirname_index)))
    {
      char *temp;
      char *temp_end;
      int i;

      /* Expand a leading tilde if one is present. */
      if (*temp_dirname == '~')
        {
          char *expanded_dirname;

          expanded_dirname = tilde_expand_word (temp_dirname);
          free (temp_dirname);
          temp_dirname = expanded_dirname;
        }

      temp = (char *)xmalloc (34 + strlen (temp_dirname) + strlen (filename));
      strcpy (temp, temp_dirname);
      if (!IS_SLASH (temp[(strlen (temp)) - 1]))
        strcat (temp, "/");
      strcat (temp, filename);
      temp_end = temp + strlen (temp);

      free (temp_dirname);

      /* Look for FILENAME, possibly with any of the extensions
        in EXEC_EXTENSIONS[].  */
      for (i = 0; exec_extensions[i]; i++)
       {
         if (exec_extensions[i][0])
           strcpy (temp_end, exec_extensions[i]);
         statable = (stat (temp, &finfo) == 0);

         /* If we have found a regular executable file, then use it. */
         if ((statable) && (S_ISREG (finfo.st_mode)) &&
             (access (temp, X_OK) == 0))
           return (temp);
       }

      free (temp);
    }
  return ((char *)NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* find_man_formatter ( void  ) [static]

Definition at line 225 of file man.c.

{
  return (executable_file_in_path ("man", (char *)getenv ("PATH")));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static SEARCH_BINDING* find_reference_section ( NODE node) [static]

Definition at line 546 of file man.c.

{
  register int i;
  long position = -1;

  frs_binding.buffer = node->contents;
  frs_binding.start = 0;
  frs_binding.end = node->nodelen;
  frs_binding.flags = S_SkipDest;

  for (i = 0; reference_section_starters[i] != (char *)NULL; i++)
    {
      position = search_forward (reference_section_starters[i], &frs_binding);
      if (position != -1)
        break;
    }

  if (position == -1)
    return ((SEARCH_BINDING *)NULL);

  /* We found the start of the reference section, and point is right after
     the string which starts it.  The text from here to the next header
     (or end of buffer) contains the only references in this manpage. */
  frs_binding.start = position;

  for (i = frs_binding.start; i < frs_binding.end - 2; i++)
    {
      if ((frs_binding.buffer[i] == '\n') &&
          (!whitespace (frs_binding.buffer[i + 1])))
        {
          frs_binding.end = i;
          break;
        }
    }

  return (&frs_binding);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char * get_manpage_contents ( char *  pagename) [static]

Definition at line 276 of file man.c.

{
  static char *formatter_args[4] = { (char *)NULL };
  int pipes[2];
  pid_t child;
  RETSIGTYPE (*sigsave) (int signum);
  char *formatted_page = NULL;
  int arg_index = 1;

  if (formatter_args[0] == (char *)NULL)
    formatter_args[0] = find_man_formatter ();

  if (formatter_args[0] == (char *)NULL)
    return ((char *)NULL);

  get_page_and_section (pagename);

  if (manpage_section != (char *)NULL)
    formatter_args[arg_index++] = manpage_section;

  formatter_args[arg_index++] = manpage_pagename;
  formatter_args[arg_index] = (char *)NULL;

  /* Open a pipe to this program, read the output, and save it away
     in FORMATTED_PAGE.  The reader end of the pipe is pipes[0]; the
     writer end is pipes[1]. */
#if PIPE_USE_FORK
  pipe (pipes);

  sigsave = signal (SIGCHLD, reap_children);

  child = fork ();
  if (child == -1)
    return ((char *)NULL);

  if (child != 0)
    {
      /* In the parent, close the writing end of the pipe, and read from
         the exec'd child. */
      close (pipes[1]);
      formatted_page = read_from_fd (pipes[0]);
      close (pipes[0]);
      signal (SIGCHLD, sigsave);
    }
  else
    { /* In the child, close the read end of the pipe, make the write end
         of the pipe be stdout, and execute the man page formatter. */
      close (pipes[0]);
      freopen (NULL_DEVICE, "w", stderr);
      freopen (NULL_DEVICE, "r", stdin);
      dup2 (pipes[1], fileno (stdout));

      execv (formatter_args[0], formatter_args);

      /* If we get here, we couldn't exec, so close out the pipe and
         exit. */
      close (pipes[1]);
      xexit (0);
    }
#else  /* !PIPE_USE_FORK */
  /* Cannot fork/exec, but can popen/pclose.  */
  {
    FILE *fpipe;
    char *cmdline = xmalloc (strlen (formatter_args[0])
                          + strlen (manpage_pagename)
                          + (arg_index > 2 ? strlen (manpage_section) : 0)
                          + 3);
    int save_stderr = dup (fileno (stderr));
    int fd_err = open (NULL_DEVICE, O_WRONLY, 0666);

    if (fd_err > 2)
      dup2 (fd_err, fileno (stderr)); /* Don't print errors. */
    sprintf (cmdline, "%s %s %s", formatter_args[0], manpage_pagename,
                              arg_index > 2 ? manpage_section : "");
    fpipe = popen (cmdline, "r");
    free (cmdline);
    if (fd_err > 2)
      close (fd_err);
    dup2 (save_stderr, fileno (stderr));
    if (fpipe == 0)
      return ((char *)NULL);
    formatted_page = read_from_fd (fileno (fpipe));
    if (pclose (fpipe) == -1)
      {
       if (formatted_page)
         free (formatted_page);
       return ((char *)NULL);
      }
  }
#endif /* !PIPE_USE_FORK */

  /* If we have the page, then clean it up. */
  if (formatted_page)
    clean_manpage (formatted_page);

  return (formatted_page);
}

Here is the call graph for this function:

Here is the caller graph for this function:

NODE* get_manpage_node ( FILE_BUFFER file_buffer,
char *  pagename 
)

Definition at line 69 of file man.c.

{
  NODE *node;

  node = manpage_node_of_file_buffer (file_buffer, pagename);

  if (!node)
    {
      char *page;

      page = get_manpage_contents (pagename);

      if (page)
        {
          char header[1024];
          long oldsize, newsize;
          int hlen, plen;
         char *old_contents = file_buffer->contents;

          sprintf (header, "\n\n%c\n%s %s,  %s %s,  %s (dir)\n\n",
                   INFO_COOKIE,
                   INFO_FILE_LABEL, file_buffer->filename,
                   INFO_NODE_LABEL, pagename,
                   INFO_UP_LABEL);
          oldsize = file_buffer->filesize;
          hlen = strlen (header);
          plen = strlen (page);
          newsize = (oldsize + hlen + plen);
          file_buffer->contents =
            (char *)xrealloc (file_buffer->contents, 1 + newsize);
          memcpy (file_buffer->contents + oldsize, header, hlen);
          memcpy (file_buffer->contents + oldsize + hlen, page, plen);
          file_buffer->contents[newsize] = '\0';
          file_buffer->filesize = newsize;
          file_buffer->finfo.st_size = newsize;
          build_tags_and_nodes (file_buffer);
          free (page);
         /* We have just relocated file_buffer->contents from under
            the feet of info_windows[] array.  Therefore, all the
            nodes on that list which are showing man pages have their
            contents member pointing into the blue.  Undo that harm.  */
         if (old_contents && oldsize && old_contents != file_buffer->contents)
           {
             int iw;
             INFO_WINDOW *info_win;
             char *old_contents_end = old_contents + oldsize;

             for (iw = 0; (info_win = info_windows[iw]); iw++)
              {
                int in;

                for (in = 0; in < info_win->nodes_index; in++)
                  {
                    NODE *tmp_node = info_win->nodes[in];

                    /* It really only suffices to see that node->filename
                      is "*manpages*".  But after several hours of
                      debugging this, would you blame me for being a bit
                      paranoid?  */
                    if (tmp_node && tmp_node->filename
                          && tmp_node->contents
                          && strcmp (tmp_node->filename,
                              MANPAGE_FILE_BUFFER_NAME) == 0
                          && tmp_node->contents >= old_contents
                          && tmp_node->contents + tmp_node->nodelen
                                <= old_contents_end)
                     {
                       info_win->nodes[in] =
                         manpage_node_of_file_buffer (file_buffer,
                                tmp_node->nodename);
                       free (tmp_node->nodename);
                       free (tmp_node);
                     }
                  }
              }
           }
        }

      node = manpage_node_of_file_buffer (file_buffer, pagename);
    }

  return (node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void get_page_and_section ( char *  pagename) [static]

Definition at line 234 of file man.c.

{
  register int i;

  if (manpage_pagename)
    free (manpage_pagename);

  if (manpage_section)
    free (manpage_section);

  manpage_pagename = (char *)NULL;
  manpage_section  = (char *)NULL;

  for (i = 0; pagename[i] != '\0' && pagename[i] != '('; i++);

  manpage_pagename = (char *)xmalloc (1 + i);
  strncpy (manpage_pagename, pagename, i);
  manpage_pagename[i] = '\0';

  if (pagename[i] == '(')
    {
      int start;

      start = i + 1;

      for (i = start; pagename[i] != '\0' && pagename[i] != ')'; i++);

      manpage_section = (char *)xmalloc (1 + (i - start));
      strncpy (manpage_section, pagename + start, (i - start));
      manpage_section[i - start] = '\0';
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

long locate_manpage_xref ( NODE node,
long int  start,
int  dir 
)

Definition at line 653 of file man.c.

{
  REFERENCE **refs;
  long position = -1;

  refs = xrefs_of_manpage (node);

  if (refs)
    {
      register int i, count;
      REFERENCE *entry;

      for (i = 0; refs[i]; i++);
      count = i;

      if (dir > 0)
        {
          for (i = 0; (entry = refs[i]); i++)
            if (entry->start > start)
              {
                position = entry->start;
                break;
              }
        }
      else
        {
          for (i = count - 1; i > -1; i--)
            {
              entry = refs[i];

              if (entry->start < start)
                {
                  position = entry->start;
                  break;
                }
            }
        }

      info_free_references (refs);
    }
  return (position);
}

Here is the call graph for this function:

Here is the caller graph for this function:

NODE* make_manpage_node ( char *  pagename)

Definition at line 63 of file man.c.

{
  return (info_get_node (MANPAGE_FILE_BUFFER_NAME, pagename));
}

Here is the call graph for this function:

static NODE * manpage_node_of_file_buffer ( FILE_BUFFER file_buffer,
char *  pagename 
) [static]

Definition at line 432 of file man.c.

{
  NODE *node = (NODE *)NULL;
  TAG *tag = (TAG *)NULL;

  if (file_buffer->contents)
    {
      register int i;

      for (i = 0; (tag = file_buffer->tags[i]); i++)
        {
          if (strcasecmp (pagename, tag->nodename) == 0)
            break;
        }
    }

  if (tag)
    {
      node = (NODE *)xmalloc (sizeof (NODE));
      node->filename = file_buffer->filename;
      node->nodename = xstrdup (tag->nodename);
      node->contents = file_buffer->contents + tag->nodestart;
      node->nodelen = tag->nodelen;
      node->flags    = 0;
      node->display_pos = 0;
      node->parent   = (char *)NULL;
      node->flags = (N_HasTagsTable | N_IsManPage);
      node->contents += skip_node_separator (node->contents);
    }

  return (node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

REFERENCE** manpage_xrefs_in_binding ( NODE node,
SEARCH_BINDING binding 
)

Definition at line 700 of file man.c.

{
  register int i;
  REFERENCE **all_refs = xrefs_of_manpage (node);
  REFERENCE **brefs = (REFERENCE **)NULL;
  REFERENCE *entry;
  int brefs_index = 0;
  int brefs_slots = 0;
  int start, end;

  if (!all_refs)
    return ((REFERENCE **)NULL);

  start = binding->start + (binding->buffer - node->contents);
  end = binding->end + (binding->buffer - node->contents);

  for (i = 0; (entry = all_refs[i]); i++)
    {
      if ((entry->start > start) && (entry->end < end))
        {
          add_pointer_to_array
            (entry, brefs_index, brefs, brefs_slots, 10, REFERENCE *);
        }
      else
        {
          maybe_free (entry->label);
          maybe_free (entry->filename);
          maybe_free (entry->nodename);
          free (entry);
        }
    }

  free (all_refs);
  return (brefs);
}

Here is the call graph for this function:

static char * read_from_fd ( int  fd) [static]

Definition at line 466 of file man.c.

{
  struct timeval timeout;
  char *buffer = (char *)NULL;
  int bsize = 0;
  int bindex = 0;
  int select_result;
#if defined (FD_SET)
  fd_set read_fds;

  timeout.tv_sec = 15;
  timeout.tv_usec = 0;

  FD_ZERO (&read_fds);
  FD_SET (fd, &read_fds);

  select_result = select (fd + 1, fd_set_cast (&read_fds), 0, 0, &timeout);
#else /* !FD_SET */
  select_result = 1;
#endif /* !FD_SET */

  switch (select_result)
    {
    case 0:
    case -1:
      break;

    default:
      {
        int amount_read;
        int done = 0;

        while (!done)
          {
            while ((bindex + 1024) > (bsize))
              buffer = (char *)xrealloc (buffer, (bsize += 1024));
            buffer[bindex] = '\0';

            amount_read = read (fd, buffer + bindex, 1023);

            if (amount_read < 0)
              {
                done = 1;
              }
            else
              {
                bindex += amount_read;
                buffer[bindex] = '\0';
                if (amount_read == 0)
                  done = 1;
              }
          }
      }
    }

  if ((buffer != (char *)NULL) && (*buffer == '\0'))
    {
      free (buffer);
      buffer = (char *)NULL;
    }

  return (buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 585 of file man.c.

{
  SEARCH_BINDING *reference_section;
  REFERENCE **refs = (REFERENCE **)NULL;
  int refs_index = 0;
  int refs_slots = 0;
  long position;

  reference_section = find_reference_section (node);

  if (reference_section == (SEARCH_BINDING *)NULL)
    return ((REFERENCE **)NULL);

  /* Grovel the reference section building a list of references found there.
     A reference is alphabetic characters followed by non-whitespace text
     within parenthesis. */
  reference_section->flags = 0;

  while ((position = search_forward ("(", reference_section)) != -1)
    {
      register int start, end;

      for (start = position; start > reference_section->start; start--)
        if (whitespace (reference_section->buffer[start]))
          break;

      start++;

      for (end = position; end < reference_section->end; end++)
        {
          if (whitespace (reference_section->buffer[end]))
            {
              end = start;
              break;
            }

          if (reference_section->buffer[end] == ')')
            {
              end++;
              break;
            }
        }

      if (end != start)
        {
          REFERENCE *entry;
          int len = end - start;

          entry = (REFERENCE *)xmalloc (sizeof (REFERENCE));
          entry->label = (char *)xmalloc (1 + len);
          strncpy (entry->label, (reference_section->buffer) + start, len);
          entry->label[len] = '\0';
          entry->filename = xstrdup (node->filename);
          entry->nodename = xstrdup (entry->label);
          entry->start = start;
          entry->end = end;

          add_pointer_to_array
            (entry, refs_index, refs, refs_slots, 10, REFERENCE *);
        }

      reference_section->start = position + 1;
    }

  return (refs);
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

char const* const exec_extensions[] = { "", NULL } [static]

Definition at line 53 of file man.c.

Definition at line 543 of file man.c.

char* manpage_pagename = (char *)NULL [static]

Definition at line 230 of file man.c.

char* manpage_section = (char *)NULL [static]

Definition at line 231 of file man.c.

char* reference_section_starters[] [static]
Initial value:
{
  "\nRELATED INFORMATION",
  "\nRELATED\tINFORMATION",
  "RELATED INFORMATION\n",
  "RELATED\tINFORMATION\n",
  "\nSEE ALSO",
  "\nSEE\tALSO",
  "SEE ALSO\n",
  "SEE\tALSO\n",
  (char *)NULL
}

Definition at line 530 of file man.c.