builtins/common.c

   1 /* common.c - utility functions for all builtins */
   2
   3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   7    Bash is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    Bash is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <config.h>
  22
  23 #if defined (HAVE_UNISTD_H)
  24 #  ifdef _MINIX
  25 #    include <sys/types.h>
  26 #  endif
  27 #  include <unistd.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <chartypes.h>
  32 #include "../bashtypes.h"
  33 #include "posixstat.h"
  34 #include <signal.h>
  35
  36 #include <errno.h>
  37
  38 #if defined (PREFER_STDARG)
  39 #  include <stdarg.h>
  40 #else
  41 #  include <varargs.h>
  42 #endif
  43
  44 #include "../bashansi.h"
  45 #include "../bashintl.h"
  46
  47 #define NEED_FPURGE_DECL
  48
  49 #include "../shell.h"
  50 #include "maxpath.h"
  51 #include "../flags.h"
  52 #include "../jobs.h"
  53 #include "../builtins.h"
  54 #include "../input.h"
  55 #include "../execute_cmd.h"
  56 #include "../trap.h"
  57 #include "bashgetopt.h"
  58 #include "common.h"
  59 #include "builtext.h"
  60 #include <tilde/tilde.h>
  61
  62 #if defined (HISTORY)
  63 #  include "../bashhist.h"
  64 #endif
  65
  66 #if !defined (errno)
  67 extern int errno;
  68 #endif /* !errno */
  69
  70 extern int indirection_level, subshell_environment;
  71 extern int line_number;
  72 extern int last_command_exit_value;
  73 extern int running_trap;
  74 extern int posixly_correct;
  75 extern char *this_command_name, *shell_name;
  76 extern const char * const bash_getcwd_errstr;
  77
  78 /* Used by some builtins and the mainline code. */
  79 sh_builtin_func_t *last_shell_builtin = (sh_builtin_func_t *)NULL;
  80 sh_builtin_func_t *this_shell_builtin = (sh_builtin_func_t *)NULL;
  81
  82 /* **************************************************************** */
  83 /*                                                                  */
  84 /*           Error reporting, usage, and option processing          */
  85 /*                                                                  */
  86 /* **************************************************************** */
  87
  88 /* This is a lot like report_error (), but it is for shell builtins
  89    instead of shell control structures, and it won't ever exit the
  90    shell. */
  91
  92 static void
  93 builtin_error_prolog ()
  94 {
  95   char *name;
  96
  97   name = get_name_for_error ();
  98   fprintf (stderr, "%s: ", name);
  99
 100   if (interactive_shell == 0)
 101     fprintf (stderr, _("line %d: "), executing_line_number ());
 102
 103   if (this_command_name && *this_command_name)
 104     fprintf (stderr, "%s: ", this_command_name);
 105 }
 106
 107 void
 108 #if defined (PREFER_STDARG)
 109 builtin_error (const char *format, ...)
 110 #else
 111 builtin_error (format, va_alist)
 112      const char *format;
 113      va_dcl
 114 #endif
 115 {
 116   va_list args;
 117
 118   builtin_error_prolog ();
 119
 120   SH_VA_START (args, format);
 121
 122   vfprintf (stderr, format, args);
 123   va_end (args);
 124   fprintf (stderr, "\n");
 125 }
 126
 127 void
 128 #if defined (PREFER_STDARG)
 129 builtin_warning (const char *format, ...)
 130 #else
 131 builtin_warning (format, va_alist)
 132      const char *format;
 133      va_dcl
 134 #endif
 135 {
 136   va_list args;
 137
 138   builtin_error_prolog ();
 139   fprintf (stderr, _("warning: "));
 140
 141   SH_VA_START (args, format);
 142
 143   vfprintf (stderr, format, args);
 144   va_end (args);
 145   fprintf (stderr, "\n");
 146 }
 147
 148 /* Print a usage summary for the currently-executing builtin command. */
 149 void
 150 builtin_usage ()
 151 {
 152   if (this_command_name && *this_command_name)
 153     fprintf (stderr, _("%s: usage: "), this_command_name);
 154   fprintf (stderr, "%s\n", current_builtin->short_doc);
 155   fflush (stderr);
 156 }
 157
 158 /* Return if LIST is NULL else barf and jump to top_level.  Used by some
 159    builtins that do not accept arguments. */
 160 void
 161 no_args (list)
 162      WORD_LIST *list;
 163 {
 164   if (list)
 165     {
 166       builtin_error (_("too many arguments"));
 167       top_level_cleanup ();
 168       jump_to_top_level (DISCARD);
 169     }
 170 }
 171
 172 /* Check that no options were given to the currently-executing builtin,
 173    and return 0 if there were options. */
 174 int
 175 no_options (list)
 176      WORD_LIST *list;
 177 {
 178   reset_internal_getopt ();
 179   if (internal_getopt (list, "") != -1)
 180     {
 181       builtin_usage ();
 182       return (1);
 183     }
 184   return (0);
 185 }
 186
 187 void
 188 sh_needarg (s)
 189      char *s;
 190 {
 191   builtin_error (_("%s: option requires an argument"), s);
 192 }
 193
 194 void
 195 sh_neednumarg (s)
 196      char *s;
 197 {
 198   builtin_error (_("%s: numeric argument required"), s);
 199 }
 200
 201 void
 202 sh_notfound (s)
 203      char *s;
 204 {
 205   builtin_error (_("%s: not found"), s);
 206 }
 207
 208 /* Function called when one of the builtin commands detects an invalid
 209    option. */
 210 void
 211 sh_invalidopt (s)
 212      char *s;
 213 {
 214   builtin_error (_("%s: invalid option"), s);
 215 }
 216
 217 void
 218 sh_invalidoptname (s)
 219      char *s;
 220 {
 221   builtin_error (_("%s: invalid option name"), s);
 222 }
 223
 224 void
 225 sh_invalidid (s)
 226      char *s;
 227 {
 228   builtin_error (_("`%s': not a valid identifier"), s);
 229 }
 230
 231 void
 232 sh_invalidnum (s)
 233      char *s;
 234 {
 235   char *msg;
 236
 237   if (*s == '0' && isdigit (s[1]))
 238     msg = _("invalid octal number");
 239   else if (*s == '0' && s[1] == 'x')
 240     msg = _("invalid hex number");
 241   else
 242     msg = _("invalid number");
 243   builtin_error ("%s: %s", s, msg);
 244 }
 245
 246 void
 247 sh_invalidsig (s)
 248      char *s;
 249 {
 250   builtin_error (_("%s: invalid signal specification"), s);
 251 }
 252
 253 void
 254 sh_badpid (s)
 255      char *s;
 256 {
 257   builtin_error (_("`%s': not a pid or valid job spec"), s);
 258 }
 259
 260 void
 261 sh_readonly (s)
 262      const char *s;
 263 {
 264   builtin_error (_("%s: readonly variable"), s);
 265 }
 266
 267 void
 268 sh_erange (s, desc)
 269      char *s, *desc;
 270 {
 271   if (s)
 272     builtin_error (_("%s: %s out of range"), s, desc ? desc : _("argument"));
 273   else
 274     builtin_error (_("%s out of range"), desc ? desc : _("argument"));
 275 }
 276
 277 #if defined (JOB_CONTROL)
 278 void
 279 sh_badjob (s)
 280      char *s;
 281 {
 282   builtin_error (_("%s: no such job"), s);
 283 }
 284
 285 void
 286 sh_nojobs (s)
 287      char *s;
 288 {
 289   if (s)
 290     builtin_error (_("%s: no job control"), s);
 291   else
 292     builtin_error (_("no job control"));
 293 }
 294 #endif
 295
 296 #if defined (RESTRICTED_SHELL)
 297 void
 298 sh_restricted (s)
 299      char *s;
 300 {
 301   if (s)
 302     builtin_error (_("%s: restricted"), s);
 303   else
 304     builtin_error (_("restricted"));
 305 }
 306 #endif
 307
 308 void
 309 sh_notbuiltin (s)
 310      char *s;
 311 {
 312   builtin_error (_("%s: not a shell builtin"), s);
 313 }
 314
 315 void
 316 sh_wrerror ()
 317 {
 318 #if defined (DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS) && defined (EPIPE)
 319   if (errno != EPIPE)
 320 #endif /* DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS && EPIPE */
 321   builtin_error (_("write error: %s"), strerror (errno));
 322 }
 323
 324 int
 325 sh_chkwrite (s)
 326      int s;
 327 {
 328   fflush (stdout);
 329   if (ferror (stdout))
 330     {
 331       sh_wrerror ();
 332       fpurge (stdout);
 333       clearerr (stdout);
 334       return (EXECUTION_FAILURE);
 335     }
 336   return (s);
 337 }
 338
 339 /* **************************************************************** */
 340 /*                                                                  */
 341 /*           Shell positional parameter manipulation                */
 342 /*                                                                  */
 343 /* **************************************************************** */
 344
 345 /* Convert a WORD_LIST into a C-style argv.  Return the number of elements
 346    in the list in *IP, if IP is non-null.  A convenience function for
 347    loadable builtins; also used by `test'. */
 348 char **
 349 make_builtin_argv (list, ip)
 350      WORD_LIST *list;
 351      int *ip;
 352 {
 353   char **argv;
 354
 355   argv = strvec_from_word_list (list, 0, 1, ip);
 356   argv[0] = this_command_name;
 357   return argv;
 358 }
 359
 360 /* Remember LIST in $0 ... $9, and REST_OF_ARGS.  If DESTRUCTIVE is
 361    non-zero, then discard whatever the existing arguments are, else
 362    only discard the ones that are to be replaced. */
 363 void
 364 remember_args (list, destructive)
 365      WORD_LIST *list;
 366      int destructive;
 367 {
 368   register int i;
 369
 370   for (i = 1; i < 10; i++)
 371     {
 372       if ((destructive || list) && dollar_vars[i])
 373         {
 374           free (dollar_vars[i]);
 375           dollar_vars[i] = (char *)NULL;
 376         }
 377
 378       if (list)
 379         {
 380           dollar_vars[i] = savestring (list->word->word);
 381           list = list->next;
 382         }
 383     }
 384
 385   /* If arguments remain, assign them to REST_OF_ARGS.
 386      Note that copy_word_list (NULL) returns NULL, and
 387      that dispose_words (NULL) does nothing. */
 388   if (destructive || list)
 389     {
 390       dispose_words (rest_of_args);
 391       rest_of_args = copy_word_list (list);
 392     }
 393
 394   if (destructive)
 395     set_dollar_vars_changed ();
 396 }
 397
 398 static int changed_dollar_vars;
 399
 400 /* Have the dollar variables been reset to new values since we last
 401    checked? */
 402 int
 403 dollar_vars_changed ()
 404 {
 405   return (changed_dollar_vars);
 406 }
 407
 408 void
 409 set_dollar_vars_unchanged ()
 410 {
 411   changed_dollar_vars = 0;
 412 }
 413
 414 void
 415 set_dollar_vars_changed ()
 416 {
 417   if (variable_context)
 418     changed_dollar_vars |= ARGS_FUNC;
 419   else if (this_shell_builtin == set_builtin)
 420     changed_dollar_vars |= ARGS_SETBLTIN;
 421   else
 422     changed_dollar_vars |= ARGS_INVOC;
 423 }
 424
 425 /* **************************************************************** */
 426 /*                                                                  */
 427 /*              Validating numeric input and arguments              */
 428 /*                                                                  */
 429 /* **************************************************************** */
 430
 431 /* Read a numeric arg for this_command_name, the name of the shell builtin
 432    that wants it.  LIST is the word list that the arg is to come from.
 433    Accept only the numeric argument; report an error if other arguments
 434    follow.  If FATAL is 1, call throw_to_top_level, which exits the
 435    shell; if it's 2, call jump_to_top_level (DISCARD), which aborts the
 436    current command; if FATAL is 0, return an indication of an invalid
 437    number by setting *NUMOK == 0 and return -1. */
 438 int
 439 get_numeric_arg (list, fatal, count)
 440      WORD_LIST *list;
 441      int fatal;
 442      intmax_t *count;
 443 {
 444   char *arg;
 445
 446   if (count)
 447     *count = 1;
 448
 449   if (list && list->word && ISOPTION (list->word->word, '-'))
 450     list = list->next;
 451
 452   if (list)
 453     {
 454       arg = list->word->word;
 455       if (arg == 0 || (legal_number (arg, count) == 0))
 456         {
 457           sh_neednumarg (list->word->word ? list->word->word : "`'");
 458           if (fatal == 0)
 459             return 0;
 460           else if (fatal == 1)          /* fatal == 1; abort */
 461             throw_to_top_level ();
 462           else                          /* fatal == 2; discard current command */
 463             {
 464               top_level_cleanup ();
 465               jump_to_top_level (DISCARD);
 466             }
 467         }
 468       no_args (list->next);
 469     }
 470
 471   return (1);
 472 }
 473
 474 /* Get an eight-bit status value from LIST */
 475 int
 476 get_exitstat (list)
 477      WORD_LIST *list;
 478 {
 479   int status;
 480   intmax_t sval;
 481   char *arg;
 482
 483   if (list && list->word && ISOPTION (list->word->word, '-'))
 484     list = list->next;
 485
 486   if (list == 0)
 487     return (last_command_exit_value);
 488
 489   arg = list->word->word;
 490   if (arg == 0 || legal_number (arg, &sval) == 0)
 491     {
 492       sh_neednumarg (list->word->word ? list->word->word : "`'");
 493       return 255;
 494     }
 495   no_args (list->next);
 496
 497   status = sval & 255;
 498   return status;
 499 }
 500
 501 /* Return the octal number parsed from STRING, or -1 to indicate
 502    that the string contained a bad number. */
 503 int
 504 read_octal (string)
 505      char *string;
 506 {
 507   int result, digits;
 508
 509   result = digits = 0;
 510   while (*string && ISOCTAL (*string))
 511     {
 512       digits++;
 513       result = (result * 8) + (*string++ - '0');
 514       if (result > 0777)
 515         return -1;
 516     }
 517
 518   if (digits == 0 || *string)
 519     result = -1;
 520
 521   return (result);
 522 }
 523
 524 /* **************************************************************** */
 525 /*                                                                  */
 526 /*           Manipulating the current working directory             */
 527 /*                                                                  */
 528 /* **************************************************************** */
 529
 530 /* Return a consed string which is the current working directory.
 531    FOR_WHOM is the name of the caller for error printing.  */
 532 char *the_current_working_directory = (char *)NULL;
 533
 534 char *
 535 get_working_directory (for_whom)
 536      char *for_whom;
 537 {
 538   if (no_symbolic_links)
 539     {
 540       FREE (the_current_working_directory);
 541       the_current_working_directory = (char *)NULL;
 542     }
 543
 544   if (the_current_working_directory == 0)
 545     {
 546 #if defined (GETCWD_BROKEN)
 547       the_current_working_directory = getcwd (0, PATH_MAX);
 548 #else
 549       the_current_working_directory = getcwd (0, 0);
 550 #endif
 551       if (the_current_working_directory == 0)
 552         {
 553           fprintf (stderr, _("%s: error retrieving current directory: %s: %s\n"),
 554                    (for_whom && *for_whom) ? for_whom : get_name_for_error (),
 555                    _(bash_getcwd_errstr), strerror (errno));
 556           return (char *)NULL;
 557         }
 558     }
 559
 560   return (savestring (the_current_working_directory));
 561 }
 562
 563 /* Make NAME our internal idea of the current working directory. */
 564 void
 565 set_working_directory (name)
 566      char *name;
 567 {
 568   FREE (the_current_working_directory);
 569   the_current_working_directory = savestring (name);
 570 }
 571
 572 /* **************************************************************** */
 573 /*                                                                  */
 574 /*              Job control support functions                       */
 575 /*                                                                  */
 576 /* **************************************************************** */
 577
 578 #if defined (JOB_CONTROL)
 579 int
 580 get_job_by_name (name, flags)
 581      const char *name;
 582      int flags;
 583 {
 584   register int i, wl, cl, match, job;
 585   register PROCESS *p;
 586   register JOB *j;
 587
 588   job = NO_JOB;
 589   wl = strlen (name);
 590   for (i = js.j_jobslots - 1; i >= 0; i--)
 591     {
 592       j = get_job_by_jid (i);
 593       if (j == 0 || ((flags & JM_STOPPED) && J_JOBSTATE(j) != JSTOPPED))
 594         continue;
 595
 596       p = j->pipe;
 597       do
 598         {
 599           if (flags & JM_EXACT)
 600             {
 601               cl = strlen (p->command);
 602               match = STREQN (p->command, name, cl);
 603             }
 604           else if (flags & JM_SUBSTRING)
 605             match = strindex (p->command, name) != (char *)0;
 606           else
 607             match = STREQN (p->command, name, wl);
 608
 609           if (match == 0)
 610             {
 611               p = p->next;
 612               continue;
 613             }
 614           else if (flags & JM_FIRSTMATCH)
 615             return i;           /* return first match */
 616           else if (job != NO_JOB)
 617             {
 618               if (this_shell_builtin)
 619                 builtin_error (_("%s: ambiguous job spec"), name);
 620               else
 621                 report_error (_("%s: ambiguous job spec"), name);
 622               return (DUP_JOB);
 623             }
 624           else
 625             job = i;
 626         }
 627       while (p != j->pipe);
 628     }
 629
 630   return (job);
 631 }
 632
 633 /* Return the job spec found in LIST. */
 634 int
 635 get_job_spec (list)
 636      WORD_LIST *list;
 637 {
 638   register char *word;
 639   int job, jflags;
 640
 641   if (list == 0)
 642     return (js.j_current);
 643
 644   word = list->word->word;
 645
 646   if (*word == '\0')
 647     return (NO_JOB);
 648
 649   if (*word == '%')
 650     word++;
 651
 652   if (DIGIT (*word) && all_digits (word))
 653     {
 654       job = atoi (word);
 655       return (job > js.j_jobslots ? NO_JOB : job - 1);
 656     }
 657
 658   jflags = 0;
 659   switch (*word)
 660     {
 661     case 0:
 662     case '%':
 663     case '+':
 664       return (js.j_current);
 665
 666     case '-':
 667       return (js.j_previous);
 668
 669     case '?':                   /* Substring search requested. */
 670       jflags |= JM_SUBSTRING;
 671       word++;
 672       /* FALLTHROUGH */
 673
 674     default:
 675       return get_job_by_name (word, jflags);
 676     }
 677 }
 678 #endif /* JOB_CONTROL */
 679
 680 /*
 681  * NOTE:  `kill' calls this function with forcecols == 0
 682  */
 683 int
 684 display_signal_list (list, forcecols)
 685      WORD_LIST *list;
 686      int forcecols;
 687 {
 688   register int i, column;
 689   char *name;
 690   int result, signum, dflags;
 691   intmax_t lsignum;
 692
 693   result = EXECUTION_SUCCESS;
 694   if (!list)
 695     {
 696       for (i = 1, column = 0; i < NSIG; i++)
 697         {
 698           name = signal_name (i);
 699           if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
 700             continue;
 701
 702           if (posixly_correct && !forcecols)
 703             {
 704               /* This is for the kill builtin.  POSIX.2 says the signal names
 705                  are displayed without the `SIG' prefix. */
 706               if (STREQN (name, "SIG", 3))
 707                 name += 3;
 708               printf ("%s%s", name, (i == NSIG - 1) ? "" : " ");
 709             }
 710           else
 711             {
 712               printf ("%2d) %s", i, name);
 713
 714               if (++column < 5)
 715                 printf ("\t");
 716               else
 717                 {
 718                   printf ("\n");
 719                   column = 0;
 720                 }
 721             }
 722         }
 723
 724       if ((posixly_correct && !forcecols) || column != 0)
 725         printf ("\n");
 726       return result;
 727     }
 728
 729   /* List individual signal names or numbers. */
 730   while (list)
 731     {
 732       if (legal_number (list->word->word, &lsignum))
 733         {
 734           /* This is specified by Posix.2 so that exit statuses can be
 735              mapped into signal numbers. */
 736           if (lsignum > 128)
 737             lsignum -= 128;
 738           if (lsignum < 0 || lsignum >= NSIG)
 739             {
 740               sh_invalidsig (list->word->word);
 741               result = EXECUTION_FAILURE;
 742               list = list->next;
 743               continue;
 744             }
 745
 746           signum = lsignum;
 747           name = signal_name (signum);
 748           if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
 749             {
 750               list = list->next;
 751               continue;
 752             }
 753 #if defined (JOB_CONTROL)
 754           /* POSIX.2 says that `kill -l signum' prints the signal name without
 755              the `SIG' prefix. */
 756           printf ("%s\n", (this_shell_builtin == kill_builtin) ? name + 3 : name);
 757 #else
 758           printf ("%s\n", name);
 759 #endif
 760         }
 761       else
 762         {
 763           dflags = DSIG_NOCASE;
 764           if (posixly_correct == 0 || this_shell_builtin != kill_builtin)
 765             dflags |= DSIG_SIGPREFIX;
 766           signum = decode_signal (list->word->word, dflags);
 767           if (signum == NO_SIG)
 768             {
 769               sh_invalidsig (list->word->word);
 770               result = EXECUTION_FAILURE;
 771               list = list->next;
 772               continue;
 773             }
 774           printf ("%d\n", signum);
 775         }
 776       list = list->next;
 777     }
 778   return (result);
 779 }
 780
 781 /* **************************************************************** */
 782 /*                                                                  */
 783 /*          Finding builtin commands and their functions            */
 784 /*                                                                  */
 785 /* **************************************************************** */
 786
 787 /* Perform a binary search and return the address of the builtin function
 788    whose name is NAME.  If the function couldn't be found, or the builtin
 789    is disabled or has no function associated with it, return NULL.
 790    Return the address of the builtin.
 791    DISABLED_OKAY means find it even if the builtin is disabled. */
 792 struct builtin *
 793 builtin_address_internal (name, disabled_okay)
 794      char *name;
 795      int disabled_okay;
 796 {
 797   int hi, lo, mid, j;
 798
 799   hi = num_shell_builtins - 1;
 800   lo = 0;
 801
 802   while (lo <= hi)
 803     {
 804       mid = (lo + hi) / 2;
 805
 806       j = shell_builtins[mid].name[0] - name[0];
 807
 808       if (j == 0)
 809         j = strcmp (shell_builtins[mid].name, name);
 810
 811       if (j == 0)
 812         {
 813           /* It must have a function pointer.  It must be enabled, or we
 814              must have explicitly allowed disabled functions to be found,
 815              and it must not have been deleted. */
 816           if (shell_builtins[mid].function &&
 817               ((shell_builtins[mid].flags & BUILTIN_DELETED) == 0) &&
 818               ((shell_builtins[mid].flags & BUILTIN_ENABLED) || disabled_okay))
 819             return (&shell_builtins[mid]);
 820           else
 821             return ((struct builtin *)NULL);
 822         }
 823       if (j > 0)
 824         hi = mid - 1;
 825       else
 826         lo = mid + 1;
 827     }
 828   return ((struct builtin *)NULL);
 829 }
 830
 831 /* Return the pointer to the function implementing builtin command NAME. */
 832 sh_builtin_func_t *
 833 find_shell_builtin (name)
 834      char *name;
 835 {
 836   current_builtin = builtin_address_internal (name, 0);
 837   return (current_builtin ? current_builtin->function : (sh_builtin_func_t *)NULL);
 838 }
 839
 840 /* Return the address of builtin with NAME, whether it is enabled or not. */
 841 sh_builtin_func_t *
 842 builtin_address (name)
 843      char *name;
 844 {
 845   current_builtin = builtin_address_internal (name, 1);
 846   return (current_builtin ? current_builtin->function : (sh_builtin_func_t *)NULL);
 847 }
 848
 849 /* Return the function implementing the builtin NAME, but only if it is a
 850    POSIX.2 special builtin. */
 851 sh_builtin_func_t *
 852 find_special_builtin (name)
 853      char *name;
 854 {
 855   current_builtin = builtin_address_internal (name, 0);
 856   return ((current_builtin && (current_builtin->flags & SPECIAL_BUILTIN)) ?
 857                         current_builtin->function :
 858                         (sh_builtin_func_t *)NULL);
 859 }
 860
 861 static int
 862 shell_builtin_compare (sbp1, sbp2)
 863      struct builtin *sbp1, *sbp2;
 864 {
 865   int result;
 866
 867   if ((result = sbp1->name[0] - sbp2->name[0]) == 0)
 868     result = strcmp (sbp1->name, sbp2->name);
 869
 870   return (result);
 871 }
 872
 873 /* Sort the table of shell builtins so that the binary search will work
 874    in find_shell_builtin. */
 875 void
 876 initialize_shell_builtins ()
 877 {
 878   qsort (shell_builtins, num_shell_builtins, sizeof (struct builtin),
 879     (QSFUNC *)shell_builtin_compare);
 880 }