lib/readtokens.c

   1 /* readtokens.c  -- Functions for reading tokens from an input stream.
   2
   3    Copyright (C) 1990-1991, 1999-2004, 2006, 2009 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18    Written by Jim Meyering. */
  19
  20 /* This almost supercedes xreadline stuff -- using delim="\n"
  21    gives the same functionality, except that these functions
  22    would never return empty lines. */
  23
  24 #include <config.h>
  25
  26 #include "readtokens.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdbool.h>
  32
  33 #include "xalloc.h"
  34
  35 #if USE_UNLOCKED_IO
  36 # include "unlocked-io.h"
  37 #endif
  38
  39 /* Initialize a tokenbuffer. */
  40
  41 void
  42 init_tokenbuffer (token_buffer *tokenbuffer)
  43 {
  44   tokenbuffer->size = 0;
  45   tokenbuffer->buffer = NULL;
  46 }
  47
  48 /* Read a token from STREAM into TOKENBUFFER.
  49    A token is delimited by any of the N_DELIM bytes in DELIM.
  50    Upon return, the token is in tokenbuffer->buffer and
  51    has a trailing '\0' instead of any original delimiter.
  52    The function value is the length of the token not including
  53    the final '\0'.  Upon EOF (i.e. on the call after the last
  54    token is read) or error, return -1 without modifying tokenbuffer.
  55    The EOF and error conditions may be distinguished in the caller
  56    by testing ferror (STREAM).
  57
  58    This function works properly on lines containing NUL bytes
  59    and on files do not end with a delimiter.  */
  60
  61 size_t
  62 readtoken (FILE *stream,
  63            const char *delim,
  64            size_t n_delim,
  65            token_buffer *tokenbuffer)
  66 {
  67   char *p;
  68   int c;
  69   size_t i, n;
  70   static const char *saved_delim = NULL;
  71   static char isdelim[256];
  72   bool same_delimiters;
  73
  74   if (delim == NULL && saved_delim == NULL)
  75     abort ();
  76
  77   same_delimiters = false;
  78   if (delim != saved_delim && saved_delim != NULL)
  79     {
  80       same_delimiters = true;
  81       for (i = 0; i < n_delim; i++)
  82         {
  83           if (delim[i] != saved_delim[i])
  84             {
  85               same_delimiters = false;
  86               break;
  87             }
  88         }
  89     }
  90
  91   if (!same_delimiters)
  92     {
  93       size_t j;
  94       saved_delim = delim;
  95       memset (isdelim, 0, sizeof isdelim);
  96       for (j = 0; j < n_delim; j++)
  97         {
  98           unsigned char ch = delim[j];
  99           isdelim[ch] = 1;
 100         }
 101     }
 102
 103   /* FIXME: don't fool with this caching.  Use strchr instead.  */
 104   /* skip over any leading delimiters */
 105   for (c = getc (stream); c >= 0 && isdelim[c]; c = getc (stream))
 106     {
 107       /* empty */
 108     }
 109
 110   p = tokenbuffer->buffer;
 111   n = tokenbuffer->size;
 112   i = 0;
 113   for (;;)
 114     {
 115       if (c < 0 && i == 0)
 116         return -1;
 117
 118       if (i == n)
 119         p = x2nrealloc (p, &n, sizeof *p);
 120
 121       if (c < 0)
 122         {
 123           p[i] = 0;
 124           break;
 125         }
 126       if (isdelim[c])
 127         {
 128           p[i] = 0;
 129           break;
 130         }
 131       p[i++] = c;
 132       c = getc (stream);
 133     }
 134
 135   tokenbuffer->buffer = p;
 136   tokenbuffer->size = n;
 137   return i;
 138 }
 139
 140 /* Build a NULL-terminated array of pointers to tokens
 141    read from STREAM.  Return the number of tokens read.
 142    All storage is obtained through calls to xmalloc-like functions.
 143
 144    %%% Question: is it worth it to do a single
 145    %%% realloc() of `tokens' just before returning? */
 146
 147 size_t
 148 readtokens (FILE *stream,
 149             size_t projected_n_tokens,
 150             const char *delim,
 151             size_t n_delim,
 152             char ***tokens_out,
 153             size_t **token_lengths)
 154 {
 155   token_buffer tb, *token = &tb;
 156   char **tokens;
 157   size_t *lengths;
 158   size_t sz;
 159   size_t n_tokens;
 160
 161   if (projected_n_tokens == 0)
 162     projected_n_tokens = 64;
 163   else
 164     projected_n_tokens++;       /* add one for trailing NULL pointer */
 165
 166   sz = projected_n_tokens;
 167   tokens = xnmalloc (sz, sizeof *tokens);
 168   lengths = xnmalloc (sz, sizeof *lengths);
 169
 170   n_tokens = 0;
 171   init_tokenbuffer (token);
 172   for (;;)
 173     {
 174       char *tmp;
 175       size_t token_length = readtoken (stream, delim, n_delim, token);
 176       if (n_tokens >= sz)
 177         {
 178           tokens = x2nrealloc (tokens, &sz, sizeof *tokens);
 179           lengths = xnrealloc (lengths, sz, sizeof *lengths);
 180         }
 181
 182       if (token_length == (size_t) -1)
 183         {
 184           /* don't increment n_tokens for NULL entry */
 185           tokens[n_tokens] = NULL;
 186           lengths[n_tokens] = 0;
 187           break;
 188         }
 189       tmp = xnmalloc (token_length + 1, sizeof *tmp);
 190       lengths[n_tokens] = token_length;
 191       tokens[n_tokens] = memcpy (tmp, token->buffer, token_length + 1);
 192       n_tokens++;
 193     }
 194
 195   free (token->buffer);
 196   *tokens_out = tokens;
 197   if (token_lengths != NULL)
 198     *token_lengths = lengths;
 199   return n_tokens;
 200 }