builtins/mapfile.def

   1 This file is mapfile.def, from which is created mapfile.c.
   2 It implements the builtin "mapfile" in Bash.
   3
   4 Copyright (C) 2005-2006 Rocky Bernstein for Free Software Foundation, Inc.
   5 Copyright (C) 2008-2010 Free Software Foundation, Inc.
   6
   7 This file is part of GNU Bash, the Bourne Again SHell.
   8
   9 Bash is free software: you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation, either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 Bash is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 $PRODUCES mapfile.c
  23
  24 $BUILTIN mapfile
  25 $FUNCTION mapfile_builtin
  26 $SHORT_DOC mapfile [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]
  27 Read lines from the standard input into an indexed array variable.
  28
  29 Read lines from the standard input into the indexed array variable ARRAY, or
  30 from file descriptor FD if the -u option is supplied.  The variable MAPFILE
  31 is the default ARRAY.
  32
  33 Options:
  34   -n count      Copy at most COUNT lines.  If COUNT is 0, all lines are copied.
  35   -O origin     Begin assigning to ARRAY at index ORIGIN.  The default index is 0.
  36   -s count      Discard the first COUNT lines read.
  37   -t            Remove a trailing newline from each line read.
  38   -u fd         Read lines from file descriptor FD instead of the standard input.
  39   -C callback   Evaluate CALLBACK each time QUANTUM lines are read.
  40   -c quantum    Specify the number of lines read between each call to CALLBACK.
  41
  42 Arguments:
  43   ARRAY         Array variable name to use for file data.
  44
  45 If -C is supplied without -c, the default quantum is 5000.  When
  46 CALLBACK is evaluated, it is supplied the index of the next array
  47 element to be assigned and the line to be assigned to that element
  48 as additional arguments.
  49
  50 If not supplied with an explicit origin, mapfile will clear ARRAY before
  51 assigning to it.
  52
  53 Exit Status:
  54 Returns success unless an invalid option is given or ARRAY is readonly or
  55 not an indexed array.
  56 $END
  57
  58 $BUILTIN readarray
  59 $FUNCTION mapfile_builtin
  60 $SHORT_DOC readarray [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]
  61 Read lines from a file into an array variable.
  62
  63 A synonym for `mapfile'.
  64 $END
  65
  66 #include <config.h>
  67
  68 #include "builtins.h"
  69 #include "posixstat.h"
  70
  71 #if defined (HAVE_UNISTD_H)
  72 #  include <unistd.h>
  73 #endif
  74
  75 #include "bashansi.h"
  76 #include "bashintl.h"
  77
  78 #include <stdio.h>
  79 #include <errno.h>
  80
  81 #include "../bashintl.h"
  82 #include "../shell.h"
  83 #include "common.h"
  84 #include "bashgetopt.h"
  85
  86 #if !defined (errno)
  87 extern int errno;
  88 #endif
  89
  90 #if defined (ARRAY_VARS)
  91
  92 static int run_callback __P((const char *, unsigned int, const char *));
  93
  94 #define DEFAULT_ARRAY_NAME      "MAPFILE"
  95 #define DEFAULT_VARIABLE_NAME   "MAPLINE"       /* not used right now */
  96
  97 /* The value specifying how frequently `mapfile'  calls the callback. */
  98 #define DEFAULT_QUANTUM 5000
  99
 100 /* Values for FLAGS */
 101 #define MAPF_CLEARARRAY 0x01
 102 #define MAPF_CHOP       0x02
 103
 104 static int
 105 run_callback (callback, curindex, curline)
 106      const char *callback;
 107      unsigned int curindex;
 108      const char *curline;
 109 {
 110   unsigned int execlen;
 111   char  *execstr, *qline;
 112   int flags;
 113
 114   qline = sh_single_quote (curline);
 115   execlen = strlen (callback) + strlen (qline) + 10;
 116   /* 1 for each space between %s and %d,
 117      another 1 for the last nul char for C string. */
 118   execlen += 3;
 119   execstr = xmalloc (execlen);
 120
 121   flags = SEVAL_NOHIST;
 122 #if 0
 123   if (interactive)
 124     flags |= SEVAL_INTERACT;
 125 #endif
 126   snprintf (execstr, execlen, "%s %d %s", callback, curindex, qline);
 127   free (qline);
 128   return parse_and_execute (execstr, NULL, flags);
 129 }
 130
 131 static void
 132 do_chop(line)
 133      char * line;
 134 {
 135   int length;
 136
 137   length = strlen (line);
 138   if (length && line[length-1] == '\n')
 139     line[length-1] = '\0';
 140 }
 141
 142 static int
 143 mapfile (fd, line_count_goal, origin, nskip, callback_quantum, callback, array_name, flags)
 144      int fd;
 145      long line_count_goal, origin, nskip, callback_quantum;
 146      char *callback, *array_name;
 147      int flags;
 148 {
 149   char *line;
 150   size_t line_length;
 151   unsigned int array_index, line_count;
 152   SHELL_VAR *entry;
 153   int unbuffered_read;
 154
 155   line = NULL;
 156   line_length = 0;
 157   unbuffered_read = 0;
 158
 159   /* The following check should be done before reading any lines.  Doing it
 160      here allows us to call bind_array_element instead of bind_array_variable
 161      and skip the variable lookup on every call. */
 162   entry = find_or_make_array_variable (array_name, 1);
 163   if (entry == 0 || readonly_p (entry) || noassign_p (entry))
 164     {
 165       if (entry && readonly_p (entry))
 166         err_readonly (array_name);
 167
 168       return (EXECUTION_FAILURE);
 169     }
 170   else if (array_p (entry) == 0)
 171     {
 172       builtin_error (_("%s: not an indexed array"), array_name);
 173       return (EXECUTION_FAILURE);
 174     }
 175
 176   if (flags & MAPF_CLEARARRAY)
 177     array_flush (array_cell (entry));
 178
 179 #ifndef __CYGWIN__
 180   unbuffered_read = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
 181 #else
 182   unbuffered_read = 1;
 183 #endif
 184
 185   zreset ();
 186
 187   /* Skip any lines at beginning of file? */
 188   for (line_count = 0; line_count < nskip; line_count++)
 189     if (zgetline (fd, &line, &line_length, unbuffered_read) < 0)
 190       break;
 191
 192   line = 0;
 193   line_length = 0;
 194
 195   /* Reset the buffer for bash own stream */
 196   interrupt_immediately++;
 197   for (array_index = origin, line_count = 1;
 198        zgetline (fd, &line, &line_length, unbuffered_read) != -1;
 199        array_index++, line_count++)
 200     {
 201       /* Have we exceeded # of lines to store? */
 202       if (line_count_goal != 0 && line_count > line_count_goal)
 203         break;
 204
 205       /* Remove trailing newlines? */
 206       if (flags & MAPF_CHOP)
 207         do_chop (line);
 208
 209       /* Has a callback been registered and if so is it time to call it? */
 210       if (callback && line_count && (line_count % callback_quantum) == 0)
 211         {
 212           run_callback (callback, array_index, line);
 213
 214           /* Reset the buffer for bash own stream. */
 215           if (unbuffered_read == 0)
 216             zsyncfd (fd);
 217         }
 218
 219       bind_array_element (entry, array_index, line, 0);
 220     }
 221
 222   xfree (line);
 223
 224   if (unbuffered_read == 0)
 225     zsyncfd (fd);
 226
 227   interrupt_immediately--;
 228   return EXECUTION_SUCCESS;
 229 }
 230
 231 int
 232 mapfile_builtin (list)
 233      WORD_LIST *list;
 234 {
 235   int opt, code, fd, clear_array, flags;
 236   intmax_t intval;
 237   long lines, origin, nskip, callback_quantum;
 238   char *array_name, *callback;
 239
 240   clear_array = 1;
 241   fd = 0;
 242   lines = origin = nskip = 0;
 243   flags = MAPF_CLEARARRAY;
 244   callback_quantum = DEFAULT_QUANTUM;
 245   callback = 0;
 246
 247   reset_internal_getopt ();
 248   while ((opt = internal_getopt (list, "u:n:O:tC:c:s:")) != -1)
 249     {
 250       switch (opt)
 251         {
 252         case 'u':
 253           code = legal_number (list_optarg, &intval);
 254           if (code == 0 || intval < 0 || intval != (int)intval)
 255             {
 256               builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
 257               return (EXECUTION_FAILURE);
 258             }
 259           else
 260             fd = intval;
 261
 262           if (sh_validfd (fd) == 0)
 263             {
 264               builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
 265               return (EXECUTION_FAILURE);
 266             }
 267           break;
 268
 269         case 'n':
 270           code = legal_number (list_optarg, &intval);
 271           if (code == 0 || intval < 0 || intval != (unsigned)intval)
 272             {
 273               builtin_error (_("%s: invalid line count"), list_optarg);
 274               return (EXECUTION_FAILURE);
 275             }
 276           else
 277             lines = intval;
 278           break;
 279
 280         case 'O':
 281           code = legal_number (list_optarg, &intval);
 282           if (code == 0 || intval < 0 || intval != (unsigned)intval)
 283             {
 284               builtin_error (_("%s: invalid array origin"), list_optarg);
 285               return (EXECUTION_FAILURE);
 286             }
 287           else
 288             origin = intval;
 289           flags &= ~MAPF_CLEARARRAY;
 290           break;
 291         case 't':
 292           flags |= MAPF_CHOP;
 293           break;
 294         case 'C':
 295           callback = list_optarg;
 296           break;
 297         case 'c':
 298           code = legal_number (list_optarg, &intval);
 299           if (code == 0 || intval <= 0 || intval != (unsigned)intval)
 300             {
 301               builtin_error (_("%s: invalid callback quantum"), list_optarg);
 302               return (EXECUTION_FAILURE);
 303             }
 304           else
 305             callback_quantum = intval;
 306           break;
 307         case 's':
 308           code = legal_number (list_optarg, &intval);
 309           if (code == 0 || intval < 0 || intval != (unsigned)intval)
 310             {
 311               builtin_error (_("%s: invalid line count"), list_optarg);
 312               return (EXECUTION_FAILURE);
 313             }
 314           else
 315             nskip = intval;
 316           break;
 317         default:
 318           builtin_usage ();
 319           return (EX_USAGE);
 320         }
 321     }
 322   list = loptend;
 323
 324   if (list == 0)
 325     array_name = DEFAULT_ARRAY_NAME;
 326   else if (list->word == 0 || list->word->word == 0)
 327     {
 328       builtin_error ("internal error: getting variable name");
 329       return (EXECUTION_FAILURE);
 330     }
 331   else if (list->word->word[0] == '\0')
 332     {
 333       builtin_error (_("empty array variable name"));
 334       return (EX_USAGE);
 335     }
 336   else
 337     array_name = list->word->word;
 338
 339   if (legal_identifier (array_name) == 0 && valid_array_reference (array_name) == 0)
 340     {
 341       sh_invalidid (array_name);
 342       return (EXECUTION_FAILURE);
 343     }
 344
 345   return mapfile (fd, lines, origin, nskip, callback_quantum, callback, array_name, flags);
 346 }
 347
 348 #else
 349
 350 int
 351 mapfile_builtin (list)
 352      WORD_LIST *list;
 353 {
 354   builtin_error (_("array variable support required"));
 355   return (EXECUTION_FAILURE);
 356 }
 357
 358 #endif  /* ARRAY_VARS */