sys/src/ape/cmd/pdksh/eval.c

   1 /*
   2  * Expansion - quoting, separation, substitution, globbing
   3  */
   4
   5 #include "sh.h"
   6 #include <pwd.h>
   7 #include "ksh_dir.h"
   8 #include "ksh_stat.h"
   9
  10 /*
  11  * string expansion
  12  *
  13  * first pass: quoting, IFS separation, ~, ${}, $() and $(()) substitution.
  14  * second pass: alternation ({,}), filename expansion (*?[]).
  15  */
  16
  17 /* expansion generator state */
  18 typedef struct Expand {
  19         /* int  type; */        /* see expand() */
  20         const char *str;        /* string */
  21         union {
  22                 const char **strv;/* string[] */
  23                 struct shf *shf;/* file */
  24         } u;                    /* source */
  25         struct tbl *var;        /* variable in ${var..} */
  26         short   split;          /* split "$@" / call waitlast $() */
  27 } Expand;
  28
  29 #define XBASE           0       /* scanning original */
  30 #define XSUB            1       /* expanding ${} string */
  31 #define XARGSEP         2       /* ifs0 between "$*" */
  32 #define XARG            3       /* expanding $*, $@ */
  33 #define XCOM            4       /* expanding $() */
  34 #define XNULLSUB        5       /* "$@" when $# is 0 (don't generate word) */
  35
  36 /* States used for field splitting */
  37 #define IFS_WORD        0       /* word has chars (or quotes) */
  38 #define IFS_WS          1       /* have seen IFS white-space */
  39 #define IFS_NWS         2       /* have seen IFS non-white-space */
  40
  41 static  int     varsub ARGS((Expand *xp, char *sp, char *word, int *stypep, int *slenp));
  42 static  int     comsub ARGS((Expand *xp, char *cp));
  43 static  char   *trimsub ARGS((char *str, char *pat, int how));
  44 static  void    glob ARGS((char *cp, XPtrV *wp, int markdirs));
  45 static  void    globit ARGS((XString *xs, char **xpp, char *sp, XPtrV *wp,
  46                              int check));
  47 static char     *maybe_expand_tilde ARGS((char *p, XString *dsp, char **dpp,
  48                                           int isassign));
  49 static  char   *tilde ARGS((char *acp));
  50 static  char   *homedir ARGS((char *name));
  51 #ifdef BRACE_EXPAND
  52 static void     alt_expand ARGS((XPtrV *wp, char *start, char *exp_start,
  53                                  char *end, int fdo));
  54 #endif
  55
  56 /* compile and expand word */
  57 char *
  58 substitute(cp, f)
  59         const char *cp;
  60         int f;
  61 {
  62         struct source *s, *sold;
  63
  64         sold = source;
  65         s = pushs(SWSTR, ATEMP);
  66         s->start = s->str = cp;
  67         source = s;
  68         if (yylex(ONEWORD) != LWORD)
  69                 internal_errorf(1, "substitute");
  70         source = sold;
  71         afree(s, ATEMP);
  72         return evalstr(yylval.cp, f);
  73 }
  74
  75 /*
  76  * expand arg-list
  77  */
  78 char **
  79 eval(ap, f)
  80         register char **ap;
  81         int f;
  82 {
  83         XPtrV w;
  84
  85         if (*ap == NULL)
  86                 return ap;
  87         XPinit(w, 32);
  88         XPput(w, NULL);         /* space for shell name */
  89 #ifdef  SHARPBANG
  90         XPput(w, NULL);         /* and space for one arg */
  91 #endif
  92         while (*ap != NULL)
  93                 expand(*ap++, &w, f);
  94         XPput(w, NULL);
  95 #ifdef  SHARPBANG
  96         return (char **) XPclose(w) + 2;
  97 #else
  98         return (char **) XPclose(w) + 1;
  99 #endif
 100 }
 101
 102 /*
 103  * expand string
 104  */
 105 char *
 106 evalstr(cp, f)
 107         char *cp;
 108         int f;
 109 {
 110         XPtrV w;
 111
 112         XPinit(w, 1);
 113         expand(cp, &w, f);
 114         cp = (XPsize(w) == 0) ? null : (char*) *XPptrv(w);
 115         XPfree(w);
 116         return cp;
 117 }
 118
 119 /*
 120  * expand string - return only one component
 121  * used from iosetup to expand redirection files
 122  */
 123 char *
 124 evalonestr(cp, f)
 125         register char *cp;
 126         int f;
 127 {
 128         XPtrV w;
 129
 130         XPinit(w, 1);
 131         expand(cp, &w, f);
 132         switch (XPsize(w)) {
 133         case 0:
 134                 cp = null;
 135                 break;
 136         case 1:
 137                 cp = (char*) *XPptrv(w);
 138                 break;
 139         default:
 140                 cp = evalstr(cp, f&~DOGLOB);
 141                 break;
 142         }
 143         XPfree(w);
 144         return cp;
 145 }
 146
 147 /* for nested substitution: ${var:=$var2} */
 148 typedef struct SubType {
 149         short   stype;          /* [=+-?%#] action after expanded word */
 150         short   base;           /* begin position of expanded word */
 151         short   f;              /* saved value of f (DOPAT, etc) */
 152         struct tbl *var;        /* variable for ${var..} */
 153         short   quote;          /* saved value of quote (for ${..[%#]..}) */
 154         struct SubType *prev;   /* old type */
 155         struct SubType *next;   /* poped type (to avoid re-allocating) */
 156 } SubType;
 157
 158 void
 159 expand(cp, wp, f)
 160         char *cp;               /* input word */
 161         register XPtrV *wp;     /* output words */
 162         int f;                  /* DO* flags */
 163 {
 164         register int UNINITIALIZED(c);
 165         register int type;      /* expansion type */
 166         register int quote = 0; /* quoted */
 167         XString ds;             /* destination string */
 168         register char *dp, *sp; /* dest., source */
 169         int fdo, word;          /* second pass flags; have word */
 170         int doblank;            /* field spliting of parameter/command subst */
 171         Expand x;               /* expansion variables */
 172         SubType st_head, *st;
 173         int UNINITIALIZED(newlines); /* For trailing newlines in COMSUB */
 174         int saw_eq, tilde_ok;
 175         int make_magic;
 176
 177         if (cp == NULL)
 178                 internal_errorf(1, "expand(NULL)");
 179         /* for alias, readonly, set, typeset commands */
 180         if ((f & DOVACHECK) && is_wdvarassign(cp)) {
 181                 f &= ~(DOVACHECK|DOBLANK|DOGLOB|DOTILDE);
 182                 f |= DOASNTILDE;
 183         }
 184         if (Flag(FNOGLOB))
 185                 f &= ~DOGLOB;
 186         if (Flag(FMARKDIRS))
 187                 f |= DOMARKDIRS;
 188 #ifdef BRACE_EXPAND
 189         if (Flag(FBRACEEXPAND) && (f & DOGLOB))
 190                 f |= DOBRACE_;
 191 #endif /* BRACE_EXPAND */
 192
 193         Xinit(ds, dp, 128, ATEMP);      /* init dest. string */
 194         type = XBASE;
 195         sp = cp;
 196         fdo = 0;
 197         saw_eq = 0;
 198         tilde_ok = (f & (DOTILDE|DOASNTILDE)) ? 1 : 0; /* must be 1/0 */
 199         doblank = 0;
 200         make_magic = 0;
 201         word = (f&DOBLANK) ? IFS_WS : IFS_WORD;
 202         st_head.next = (SubType *) 0;
 203         st = &st_head;
 204
 205         while (1) {
 206                 Xcheck(ds, dp);
 207
 208                 switch (type) {
 209                   case XBASE:   /* original prefixed string */
 210                         c = *sp++;
 211                         switch (c) {
 212                           case EOS:
 213                                 c = 0;
 214                                 break;
 215                           case CHAR:
 216                                 c = *sp++;
 217                                 break;
 218                           case QCHAR:
 219                                 quote |= 2; /* temporary quote */
 220                                 c = *sp++;
 221                                 break;
 222                           case OQUOTE:
 223                                 word = IFS_WORD;
 224                                 tilde_ok = 0;
 225                                 quote = 1;
 226                                 continue;
 227                           case CQUOTE:
 228                                 quote = 0;
 229                                 continue;
 230                           case COMSUB:
 231                                 tilde_ok = 0;
 232                                 if (f & DONTRUNCOMMAND) {
 233                                         word = IFS_WORD;
 234                                         *dp++ = '$'; *dp++ = '(';
 235                                         while (*sp != '\0') {
 236                                                 Xcheck(ds, dp);
 237                                                 *dp++ = *sp++;
 238                                         }
 239                                         *dp++ = ')';
 240                                 } else {
 241                                         type = comsub(&x, sp);
 242                                         if (type == XCOM && (f&DOBLANK))
 243                                                 doblank++;
 244                                         sp = strchr(sp, 0) + 1;
 245                                         newlines = 0;
 246                                 }
 247                                 continue;
 248                           case EXPRSUB:
 249                                 word = IFS_WORD;
 250                                 tilde_ok = 0;
 251                                 if (f & DONTRUNCOMMAND) {
 252                                         *dp++ = '$'; *dp++ = '('; *dp++ = '(';
 253                                         while (*sp != '\0') {
 254                                                 Xcheck(ds, dp);
 255                                                 *dp++ = *sp++;
 256                                         }
 257                                         *dp++ = ')'; *dp++ = ')';
 258                                 } else {
 259                                         struct tbl v;
 260                                         char *p;
 261
 262                                         v.flag = DEFINED|ISSET|INTEGER;
 263                                         v.type = 10; /* not default */
 264                                         v.name[0] = '\0';
 265                                         v_evaluate(&v, substitute(sp, 0),
 266                                                 KSH_UNWIND_ERROR);
 267                                         sp = strchr(sp, 0) + 1;
 268                                         for (p = str_val(&v); *p; ) {
 269                                                 Xcheck(ds, dp);
 270                                                 *dp++ = *p++;
 271                                         }
 272                                 }
 273                                 continue;
 274                           case OSUBST: /* ${{#}var{:}[=+-?#%]word} */
 275                           /* format is:
 276                            *   OSUBST [{x] plain-variable-part \0
 277                            *     compiled-word-part CSUBST [}x]
 278                            * This is were all syntax checking gets done...
 279                            */
 280                           {
 281                                 char *varname = ++sp; /* skip the { or x (}) */
 282                                 int stype;
 283                                 int slen;
 284
 285                                 sp = strchr(sp, '\0') + 1; /* skip variable */
 286                                 type = varsub(&x, varname, sp, &stype, &slen);
 287                                 if (type < 0) {
 288                                         char endc;
 289                                         char *str, *end;
 290
 291                                         end = (char *) wdscan(sp, CSUBST);
 292                                         /* ({) the } or x is already skipped */
 293                                         endc = *end;
 294                                         *end = EOS;
 295                                         str = snptreef((char *) 0, 64, "%S",
 296                                                         varname - 1);
 297                                         *end = endc;
 298                                         errorf("%s: bad substitution", str);
 299                                 }
 300                                 if (f&DOBLANK)
 301                                         doblank++;
 302                                 tilde_ok = 0;
 303                                 if (type == XBASE) {    /* expand? */
 304                                         if (!st->next) {
 305                                                 SubType *newst;
 306
 307                                                 newst = (SubType *) alloc(
 308                                                         sizeof(SubType), ATEMP);
 309                                                 newst->next = (SubType *) 0;
 310                                                 newst->prev = st;
 311                                                 st->next = newst;
 312                                         }
 313                                         st = st->next;
 314                                         st->stype = stype;
 315                                         st->base = Xsavepos(ds, dp);
 316                                         st->f = f;
 317                                         st->var = x.var;
 318                                         st->quote = quote;
 319                                         /* skip qualifier(s) */
 320                                         if (stype)
 321                                                 sp += slen;
 322                                         switch (stype & 0x7f) {
 323                                           case '#':
 324                                           case '%':
 325                                                 /* ! DOBLANK,DOBRACE_,DOTILDE */
 326                                                 f = DOPAT | (f&DONTRUNCOMMAND)
 327                                                     | DOTEMP_;
 328                                                 quote = 0;
 329                                                 /* Prepend open pattern (so |
 330                                                  * in a trim will work as
 331                                                  * expected)
 332                                                  */
 333                                                 *dp++ = MAGIC;
 334                                                 *dp++ = '@' + 0x80;
 335                                                 break;
 336                                           case '=':
 337                                                 /* Enabling tilde expansion
 338                                                  * after :'s here is
 339                                                  * non-standard ksh, but is
 340                                                  * consistent with rules for
 341                                                  * other assignments.  Not
 342                                                  * sure what POSIX thinks of
 343                                                  * this.
 344                                                  * Not doing tilde expansion
 345                                                  * for integer variables is a
 346                                                  * non-POSIX thing - makes
 347                                                  * sense though, since ~ is
 348                                                  * a arithmetic operator.
 349                                                  */
 350                                                 if (!(x.var->flag & INTEGER))
 351                                                         f |= DOASNTILDE|DOTILDE;
 352                                                 f |= DOTEMP_;
 353                                                 /* These will be done after the
 354                                                  * value has been assigned.
 355                                                  */
 356                                                 f &= ~(DOBLANK|DOGLOB|DOBRACE_);
 357                                                 tilde_ok = 1;
 358                                                 break;
 359                                           case '?':
 360                                                 f &= ~DOBLANK;
 361                                                 f |= DOTEMP_;
 362                                                 /* fall through */
 363                                           default:
 364                                                 /* Enable tilde expansion */
 365                                                 tilde_ok = 1;
 366                                                 f |= DOTILDE;
 367                                         }
 368                                 } else
 369                                         /* skip word */
 370                                         sp = (char *) wdscan(sp, CSUBST);
 371                                 continue;
 372                           }
 373                           case CSUBST: /* only get here if expanding word */
 374                                 sp++; /* ({) skip the } or x */
 375                                 tilde_ok = 0;   /* in case of ${unset:-} */
 376                                 *dp = '\0';
 377                                 quote = st->quote;
 378                                 f = st->f;
 379                                 if (f&DOBLANK)
 380                                         doblank--;
 381                                 switch (st->stype&0x7f) {
 382                                   case '#':
 383                                   case '%':
 384                                         /* Append end-pattern */
 385                                         *dp++ = MAGIC; *dp++ = ')'; *dp = '\0';
 386                                         dp = Xrestpos(ds, dp, st->base);
 387                                         /* Must use st->var since calling
 388                                          * global would break things
 389                                          * like x[i+=1].
 390                                          */
 391                                         x.str = trimsub(str_val(st->var),
 392                                                 dp, st->stype);
 393                                         type = XSUB;
 394                                         if (f&DOBLANK)
 395                                                 doblank++;
 396                                         st = st->prev;
 397                                         continue;
 398                                   case '=':
 399                                         /* Restore our position and substitute
 400                                          * the value of st->var (may not be
 401                                          * the assigned value in the presence
 402                                          * of integer/right-adj/etc attributes).
 403                                          */
 404                                         dp = Xrestpos(ds, dp, st->base);
 405                                         /* Must use st->var since calling
 406                                          * global would cause with things
 407                                          * like x[i+=1] to be evaluated twice.
 408                                          */
 409                                         /* Note: not exported by FEXPORT
 410                                          * in at&t ksh.
 411                                          */
 412                                         /* XXX POSIX says readonly is only
 413                                          * fatal for special builtins (setstr
 414                                          * does readonly check).
 415                                          */
 416                                         setstr(st->var, debunk(
 417                                                 (char *) alloc(strlen(dp) + 1,
 418                                                         ATEMP), dp),
 419                                                 KSH_UNWIND_ERROR);
 420                                         x.str = str_val(st->var);
 421                                         type = XSUB;
 422                                         if (f&DOBLANK)
 423                                                 doblank++;
 424                                         st = st->prev;
 425                                         continue;
 426                                   case '?':
 427                                     {
 428                                         char *s = Xrestpos(ds, dp, st->base);
 429
 430                                         errorf("%s: %s", st->var->name,
 431                                             dp == s ?
 432                                               "parameter null or not set"
 433                                             : (debunk(s, s), s));
 434                                     }
 435                                 }
 436                                 st = st->prev;
 437                                 type = XBASE;
 438                                 continue;
 439
 440                           case OPAT: /* open pattern: *(foo|bar) */
 441                                 /* Next char is the type of pattern */
 442                                 make_magic = 1;
 443                                 c = *sp++ + 0x80;
 444                                 break;
 445
 446                           case SPAT: /* pattern seperator (|) */
 447                                 make_magic = 1;
 448                                 c = '|';
 449                                 break;
 450
 451                           case CPAT: /* close pattern */
 452                                 make_magic = 1;
 453                                 c = /*(*/ ')';
 454                                 break;
 455                         }
 456                         break;
 457
 458                   case XNULLSUB:
 459                         /* Special case for "$@" (and "${foo[@]}") - no
 460                          * word is generated if $# is 0 (unless there is
 461                          * other stuff inside the quotes).
 462                          */
 463                         type = XBASE;
 464                         if (f&DOBLANK) {
 465                                 doblank--;
 466                                 /* not really correct: x=; "$x$@" should
 467                                  * generate a null argument and
 468                                  * set A; "${@:+}" shouldn't.
 469                                  */
 470                                 if (dp == Xstring(ds, dp))
 471                                         word = IFS_WS;
 472                         }
 473                         continue;
 474
 475                   case XSUB:
 476                         if ((c = *x.str++) == 0) {
 477                                 type = XBASE;
 478                                 if (f&DOBLANK)
 479                                         doblank--;
 480                                 continue;
 481                         }
 482                         break;
 483
 484                   case XARGSEP:
 485                         type = XARG;
 486                         quote = 1;
 487                   case XARG:
 488                         if ((c = *x.str++) == '\0') {
 489                                 /* force null words to be created so
 490                                  * set -- '' 2 ''; foo "$@" will do
 491                                  * the right thing
 492                                  */
 493                                 if (quote && x.split)
 494                                         word = IFS_WORD;
 495                                 if ((x.str = *x.u.strv++) == NULL) {
 496                                         type = XBASE;
 497                                         if (f&DOBLANK)
 498                                                 doblank--;
 499                                         continue;
 500                                 }
 501                                 c = ifs0;
 502                                 if (c == 0) {
 503                                         if (quote && !x.split)
 504                                                 continue;
 505                                         c = ' ';
 506                                 }
 507                                 if (quote && x.split) {
 508                                         /* terminate word for "$@" */
 509                                         type = XARGSEP;
 510                                         quote = 0;
 511                                 }
 512                         }
 513                         break;
 514
 515                   case XCOM:
 516                         if (newlines) {         /* Spit out saved nl's */
 517                                 c = '\n';
 518                                 --newlines;
 519                         } else {
 520                                 while ((c = shf_getc(x.u.shf)) == 0 || c == '\n')
 521                                     if (c == '\n')
 522                                             newlines++; /* Save newlines */
 523                                 if (newlines && c != EOF) {
 524                                         shf_ungetc(c, x.u.shf);
 525                                         c = '\n';
 526                                         --newlines;
 527                                 }
 528                         }
 529                         if (c == EOF) {
 530                                 newlines = 0;
 531                                 shf_close(x.u.shf);
 532                                 if (x.split)
 533                                         subst_exstat = waitlast();
 534                                 type = XBASE;
 535                                 if (f&DOBLANK)
 536                                         doblank--;
 537                                 continue;
 538                         }
 539                         break;
 540                 }
 541
 542                 /* check for end of word or IFS separation */
 543                 if (c == 0 || (!quote && (f & DOBLANK) && doblank && !make_magic
 544                                && ctype(c, C_IFS)))
 545                 {
 546                         /* How words are broken up:
 547                          *                 |       value of c
 548                          *        word     |    ws      nws     0
 549                          *      -----------------------------------
 550                          *      IFS_WORD        w/WS    w/NWS   w
 551                          *      IFS_WS          -/WS    w/NWS   -
 552                          *      IFS_NWS         -/NWS   w/NWS   w
 553                          *   (w means generate a word)
 554                          * Note that IFS_NWS/0 generates a word (at&t ksh
 555                          * doesn't do this, but POSIX does).
 556                          */
 557                         if (word == IFS_WORD
 558                             || (!ctype(c, C_IFSWS) && (c || word == IFS_NWS)))
 559                         {
 560                                 char *p;
 561
 562                                 *dp++ = '\0';
 563                                 p = Xclose(ds, dp);
 564 #ifdef BRACE_EXPAND
 565                                 if (fdo & DOBRACE_)
 566                                         /* also does globbing */
 567                                         alt_expand(wp, p, p,
 568                                                    p + Xlength(ds, (dp - 1)),
 569                                                    fdo | (f & DOMARKDIRS));
 570                                 else
 571 #endif /* BRACE_EXPAND */
 572                                 if (fdo & DOGLOB)
 573                                         glob(p, wp, f & DOMARKDIRS);
 574                                 else if ((f & DOPAT) || !(fdo & DOMAGIC_))
 575                                         XPput(*wp, p);
 576                                 else
 577                                         XPput(*wp, debunk(p, p));
 578                                 fdo = 0;
 579                                 saw_eq = 0;
 580                                 tilde_ok = (f & (DOTILDE|DOASNTILDE)) ? 1 : 0;
 581                                 if (c != 0)
 582                                         Xinit(ds, dp, 128, ATEMP);
 583                         }
 584                         if (c == 0)
 585                                 return;
 586                         if (word != IFS_NWS)
 587                                 word = ctype(c, C_IFSWS) ? IFS_WS : IFS_NWS;
 588                 } else {
 589                         /* age tilde_ok info - ~ code tests second bit */
 590                         tilde_ok <<= 1;
 591                         /* mark any special second pass chars */
 592                         if (!quote)
 593                                 switch (c) {
 594                                   case '[':
 595                                   case NOT:
 596                                   case '-':
 597                                   case ']':
 598                                         /* For character classes - doesn't hurt
 599                                          * to have magic !,-,]'s outside of
 600                                          * [...] expressions.
 601                                          */
 602                                         if (f & (DOPAT | DOGLOB)) {
 603                                                 fdo |= DOMAGIC_;
 604                                                 if (c == '[')
 605                                                         fdo |= f & DOGLOB;
 606                                                 *dp++ = MAGIC;
 607                                         }
 608                                         break;
 609                                   case '*':
 610                                   case '?':
 611                                         if (f & (DOPAT | DOGLOB)) {
 612                                                 fdo |= DOMAGIC_ | (f & DOGLOB);
 613                                                 *dp++ = MAGIC;
 614                                         }
 615                                         break;
 616 #ifdef BRACE_EXPAND
 617                                   case OBRACE:
 618                                   case ',':
 619                                   case CBRACE:
 620                                         if ((f & DOBRACE_) && (c == OBRACE
 621                                                 || (fdo & DOBRACE_)))
 622                                         {
 623                                                 fdo |= DOBRACE_|DOMAGIC_;
 624                                                 *dp++ = MAGIC;
 625                                         }
 626                                         break;
 627 #endif /* BRACE_EXPAND */
 628                                   case '=':
 629                                         /* Note first unquoted = for ~ */
 630                                         if (!(f & DOTEMP_) && !saw_eq) {
 631                                                 saw_eq = 1;
 632                                                 tilde_ok = 1;
 633                                         }
 634                                         break;
 635                                   case PATHSEP: /* : */
 636                                         /* Note unquoted : for ~ */
 637                                         if (!(f & DOTEMP_) && (f & DOASNTILDE))
 638                                                 tilde_ok = 1;
 639                                         break;
 640                                   case '~':
 641                                         /* tilde_ok is reset whenever
 642                                          * any of ' " $( $(( ${ } are seen.
 643                                          * Note that tilde_ok must be preserved
 644                                          * through the sequence ${A=a=}~
 645                                          */
 646                                         if (type == XBASE
 647                                             && (f & (DOTILDE|DOASNTILDE))
 648                                             && (tilde_ok & 2))
 649                                         {
 650                                                 char *p, *dp_x;
 651
 652                                                 dp_x = dp;
 653                                                 p = maybe_expand_tilde(sp,
 654                                                         &ds, &dp_x,
 655                                                         f & DOASNTILDE);
 656                                                 if (p) {
 657                                                         if (dp != dp_x)
 658                                                                 word = IFS_WORD;
 659                                                         dp = dp_x;
 660                                                         sp = p;
 661                                                         continue;
 662                                                 }
 663                                         }
 664                                         break;
 665                                 }
 666                         else
 667                                 quote &= ~2; /* undo temporary */
 668
 669                         if (make_magic) {
 670                                 make_magic = 0;
 671                                 fdo |= DOMAGIC_ | (f & DOGLOB);
 672                                 *dp++ = MAGIC;
 673                         } else if (ISMAGIC(c)) {
 674                                 fdo |= DOMAGIC_;
 675                                 *dp++ = MAGIC;
 676                         }
 677                         *dp++ = c; /* save output char */
 678                         word = IFS_WORD;
 679                 }
 680         }
 681 }
 682
 683 /*
 684  * Prepare to generate the string returned by ${} substitution.
 685  */
 686 static int
 687 varsub(xp, sp, word, stypep, slenp)
 688         Expand *xp;
 689         char *sp;
 690         char *word;
 691         int *stypep;    /* becomes qualifier type */
 692         int *slenp;     /* " " len (=, :=, etc.) valid iff *stypep != 0 */
 693 {
 694         int c;
 695         int state;      /* next state: XBASE, XARG, XSUB, XNULLSUB */
 696         int stype;      /* substitution type */
 697         int slen;
 698         char *p;
 699         struct tbl *vp;
 700
 701         if (sp[0] == '\0')      /* Bad variable name */
 702                 return -1;
 703
 704         xp->var = (struct tbl *) 0;
 705
 706         /* ${#var}, string length or array size */
 707         if (sp[0] == '#' && (c = sp[1]) != '\0') {
 708                 int zero_ok = 0;
 709
 710                 /* Can't have any modifiers for ${#...} */
 711                 if (*word != CSUBST)
 712                         return -1;
 713                 sp++;
 714                 /* Check for size of array */
 715                 if ((p=strchr(sp,'[')) && (p[1]=='*'||p[1]=='@') && p[2]==']') {
 716                         int n = 0;
 717                         int max = 0;
 718                         vp = global(arrayname(sp));
 719                         if (vp->flag & (ISSET|ARRAY))
 720                                 zero_ok = 1;
 721                         for (; vp; vp = vp->u.array)
 722                                 if (vp->flag & ISSET) {
 723                                         max = vp->index + 1;
 724                                         n++;
 725                                 }
 726                         c = n; /* ksh88/ksh93 go for number, not max index */
 727                 } else if (c == '*' || c == '@')
 728                         c = e->loc->argc;
 729                 else {
 730                         p = str_val(global(sp));
 731                         zero_ok = p != null;
 732                         c = strlen(p);
 733                 }
 734                 if (Flag(FNOUNSET) && c == 0 && !zero_ok)
 735                         errorf("%s: parameter not set", sp);
 736                 *stypep = 0; /* unqualified variable/string substitution */
 737                 xp->str = str_save(ulton((unsigned long)c, 10), ATEMP);
 738                 return XSUB;
 739         }
 740
 741         /* Check for qualifiers in word part */
 742         stype = 0;
 743         c = word[slen = 0] == CHAR ? word[1] : 0;
 744         if (c == ':') {
 745                 slen += 2;
 746                 stype = 0x80;
 747                 c = word[slen + 0] == CHAR ? word[slen + 1] : 0;
 748         }
 749         if (ctype(c, C_SUBOP1)) {
 750                 slen += 2;
 751                 stype |= c;
 752         } else if (ctype(c, C_SUBOP2)) { /* Note: ksh88 allows :%, :%%, etc */
 753                 slen += 2;
 754                 stype = c;
 755                 if (word[slen + 0] == CHAR && c == word[slen + 1]) {
 756                         stype |= 0x80;
 757                         slen += 2;
 758                 }
 759         } else if (stype)       /* : is not ok */
 760                 return -1;
 761         if (!stype && *word != CSUBST)
 762                 return -1;
 763         *stypep = stype;
 764         *slenp = slen;
 765
 766         c = sp[0];
 767         if (c == '*' || c == '@') {
 768                 switch (stype & 0x7f) {
 769                   case '=':     /* can't assign to a vector */
 770                   case '%':     /* can't trim a vector (yet) */
 771                   case '#':
 772                         return -1;
 773                 }
 774                 if (e->loc->argc == 0) {
 775                         xp->str = null;
 776                         state = c == '@' ? XNULLSUB : XSUB;
 777                 } else {
 778                         xp->u.strv = (const char **) e->loc->argv + 1;
 779                         xp->str = *xp->u.strv++;
 780                         xp->split = c == '@'; /* $@ */
 781                         state = XARG;
 782                 }
 783         } else {
 784                 if ((p=strchr(sp,'[')) && (p[1]=='*'||p[1]=='@') && p[2]==']') {
 785                         XPtrV wv;
 786
 787                         switch (stype & 0x7f) {
 788                           case '=':     /* can't assign to a vector */
 789                           case '%':     /* can't trim a vector (yet) */
 790                           case '#':
 791                                 return -1;
 792                         }
 793                         XPinit(wv, 32);
 794                         vp = global(arrayname(sp));
 795                         for (; vp; vp = vp->u.array) {
 796                                 if (!(vp->flag&ISSET))
 797                                         continue;
 798                                 XPput(wv, str_val(vp));
 799                         }
 800                         if (XPsize(wv) == 0) {
 801                                 xp->str = null;
 802                                 state = p[1] == '@' ? XNULLSUB : XSUB;
 803                                 XPfree(wv);
 804                         } else {
 805                                 XPput(wv, 0);
 806                                 xp->u.strv = (const char **) XPptrv(wv);
 807                                 xp->str = *xp->u.strv++;
 808                                 xp->split = p[1] == '@'; /* ${foo[@]} */
 809                                 state = XARG;
 810                         }
 811                 } else {
 812                         /* Can't assign things like $! or $1 */
 813                         if ((stype & 0x7f) == '='
 814                             && (ctype(*sp, C_VAR1) || digit(*sp)))
 815                                 return -1;
 816                         xp->var = global(sp);
 817                         xp->str = str_val(xp->var);
 818                         state = XSUB;
 819                 }
 820         }
 821
 822         c = stype&0x7f;
 823         /* test the compiler's code generator */
 824         if (ctype(c, C_SUBOP2) ||
 825             (((stype&0x80) ? *xp->str=='\0' : xp->str==null) ? /* undef? */
 826              c == '=' || c == '-' || c == '?' : c == '+'))
 827                 state = XBASE;  /* expand word instead of variable value */
 828         if (Flag(FNOUNSET) && xp->str == null
 829             && (ctype(c, C_SUBOP2) || (state != XBASE && c != '+')))
 830                 errorf("%s: parameter not set", sp);
 831         return state;
 832 }
 833
 834 /*
 835  * Run the command in $(...) and read its output.
 836  */
 837 static int
 838 comsub(xp, cp)
 839         register Expand *xp;
 840         char *cp;
 841 {
 842         Source *s, *sold;
 843         register struct op *t;
 844         struct shf *shf;
 845
 846         s = pushs(SSTRING, ATEMP);
 847         s->start = s->str = cp;
 848         sold = source;
 849         t = compile(s);
 850         source = sold;
 851
 852         if (t == NULL)
 853                 return XBASE;
 854
 855         if (t != NULL && t->type == TCOM && /* $(<file) */
 856             *t->args == NULL && *t->vars == NULL && t->ioact != NULL) {
 857                 register struct ioword *io = *t->ioact;
 858                 char *name;
 859
 860                 if ((io->flag&IOTYPE) != IOREAD)
 861                         errorf("funny $() command: %s",
 862                                 snptreef((char *) 0, 32, "%R", io));
 863                 shf = shf_open(name = evalstr(io->name, DOTILDE), O_RDONLY, 0,
 864                         SHF_MAPHI|SHF_CLEXEC);
 865                 if (shf == NULL)
 866                         errorf("%s: cannot open $() input", name);
 867                 xp->split = 0;  /* no waitlast() */
 868         } else {
 869                 int ofd1, pv[2];
 870                 openpipe(pv);
 871                 shf = shf_fdopen(pv[0], SHF_RD, (struct shf *) 0);
 872                 ofd1 = savefd(1, 0);    /* fd 1 may be closed... */
 873                 ksh_dup2(pv[1], 1, FALSE);
 874                 close(pv[1]);
 875                 execute(t, XFORK|XXCOM|XPIPEO);
 876                 restfd(1, ofd1);
 877                 startlast();
 878                 xp->split = 1;  /* waitlast() */
 879         }
 880
 881         xp->u.shf = shf;
 882         return XCOM;
 883 }
 884
 885 /*
 886  * perform #pattern and %pattern substitution in ${}
 887  */
 888
 889 static char *
 890 trimsub(str, pat, how)
 891         register char *str;
 892         char *pat;
 893         int how;
 894 {
 895         register char *end = strchr(str, 0);
 896         register char *p, c;
 897
 898         switch (how&0xff) {     /* UCHAR_MAX maybe? */
 899           case '#':             /* shortest at begining */
 900                 for (p = str; p <= end; p++) {
 901                         c = *p; *p = '\0';
 902                         if (gmatch(str, pat, FALSE)) {
 903                                 *p = c;
 904                                 return p;
 905                         }
 906                         *p = c;
 907                 }
 908                 break;
 909           case '#'|0x80:        /* longest match at begining */
 910                 for (p = end; p >= str; p--) {
 911                         c = *p; *p = '\0';
 912                         if (gmatch(str, pat, FALSE)) {
 913                                 *p = c;
 914                                 return p;
 915                         }
 916                         *p = c;
 917                 }
 918                 break;
 919           case '%':             /* shortest match at end */
 920                 for (p = end; p >= str; p--) {
 921                         if (gmatch(p, pat, FALSE))
 922                                 return str_nsave(str, p - str, ATEMP);
 923                 }
 924                 break;
 925           case '%'|0x80:        /* longest match at end */
 926                 for (p = str; p <= end; p++) {
 927                         if (gmatch(p, pat, FALSE))
 928                                 return str_nsave(str, p - str, ATEMP);
 929                 }
 930                 break;
 931         }
 932
 933         return str;             /* no match, return string */
 934 }
 935
 936 /*
 937  * glob
 938  * Name derived from V6's /etc/glob, the program that expanded filenames.
 939  */
 940
 941 /* XXX cp not const 'cause slashes are temporarily replaced with nulls... */
 942 static void
 943 glob(cp, wp, markdirs)
 944         char *cp;
 945         register XPtrV *wp;
 946         int markdirs;
 947 {
 948         int oldsize = XPsize(*wp);
 949
 950         if (glob_str(cp, wp, markdirs) == 0)
 951                 XPput(*wp, debunk(cp, cp));
 952         else
 953                 qsortp(XPptrv(*wp) + oldsize, (size_t)(XPsize(*wp) - oldsize),
 954                         xstrcmp);
 955 }
 956
 957 #define GF_NONE         0
 958 #define GF_EXCHECK      BIT(0)          /* do existance check on file */
 959 #define GF_GLOBBED      BIT(1)          /* some globbing has been done */
 960 #define GF_MARKDIR      BIT(2)          /* add trailing / to directories */
 961
 962 /* Apply file globbing to cp and store the matching files in wp.  Returns
 963  * the number of matches found.
 964  */
 965 int
 966 glob_str(cp, wp, markdirs)
 967         char *cp;
 968         XPtrV *wp;
 969         int markdirs;
 970 {
 971         int oldsize = XPsize(*wp);
 972         XString xs;
 973         char *xp;
 974
 975         Xinit(xs, xp, 256, ATEMP);
 976         globit(&xs, &xp, cp, wp, markdirs ? GF_MARKDIR : GF_NONE);
 977         Xfree(xs, xp);
 978
 979         return XPsize(*wp) - oldsize;
 980 }
 981
 982 static void
 983 globit(xs, xpp, sp, wp, check)
 984         XString *xs;            /* dest string */
 985         char **xpp;             /* ptr to dest end */
 986         char *sp;               /* source path */
 987         register XPtrV *wp;     /* output list */
 988         int check;              /* GF_* flags */
 989 {
 990         register char *np;      /* next source component */
 991         char *xp = *xpp;
 992         char *se;
 993         char odirsep;
 994
 995         /* This to allow long expansions to be interrupted */
 996         intrcheck();
 997
 998         if (sp == NULL) {       /* end of source path */
 999                 /* We only need to check if the file exists if a pattern
1000                  * is followed by a non-pattern (eg, foo*x/bar; no check
1001                  * is needed for foo* since the match must exist) or if
1002                  * any patterns were expanded and the markdirs option is set.
1003                  * Symlinks make things a bit tricky...
1004                  */
1005                 if ((check & GF_EXCHECK)
1006                     || ((check & GF_MARKDIR) && (check & GF_GLOBBED)))
1007                 {
1008 #define stat_check()    (stat_done ? stat_done : \
1009                             (stat_done = stat(Xstring(*xs, xp), &statb) < 0 \
1010                                 ? -1 : 1))
1011                         struct stat lstatb, statb;
1012                         int stat_done = 0;       /* -1: failed, 1 ok */
1013
1014                         if (lstat(Xstring(*xs, xp), &lstatb) < 0)
1015                                 return;
1016                         /* special case for systems which strip trailing
1017                          * slashes from regular files (eg, /etc/passwd/).
1018                          * SunOS 4.1.3 does this...
1019                          */
1020                         if ((check & GF_EXCHECK) && xp > Xstring(*xs, xp)
1021                             && ISDIRSEP(xp[-1]) && !S_ISDIR(lstatb.st_mode)
1022 #ifdef S_ISLNK
1023                             && (!S_ISLNK(lstatb.st_mode)
1024                                 || stat_check() < 0
1025                                 || !S_ISDIR(statb.st_mode))
1026 #endif /* S_ISLNK */
1027                                 )
1028                                 return;
1029                         /* Possibly tack on a trailing / if there isn't already
1030                          * one and if the file is a directory or a symlink to a
1031                          * directory
1032                          */
1033                         if (((check & GF_MARKDIR) && (check & GF_GLOBBED))
1034                             && xp > Xstring(*xs, xp) && !ISDIRSEP(xp[-1])
1035                             && (S_ISDIR(lstatb.st_mode)
1036 #ifdef S_ISLNK
1037                                 || (S_ISLNK(lstatb.st_mode)
1038                                     && stat_check() > 0
1039                                     && S_ISDIR(statb.st_mode))
1040 #endif /* S_ISLNK */
1041                                     ))
1042                         {
1043                                 *xp++ = DIRSEP;
1044                                 *xp = '\0';
1045                         }
1046                 }
1047 #ifdef OS2 /* Done this way to avoid bug in gcc 2.7.2... */
1048     /* Ugly kludge required for command
1049      * completion - see how search_access()
1050      * is implemented for OS/2...
1051      */
1052 # define KLUDGE_VAL     4
1053 #else /* OS2 */
1054 # define KLUDGE_VAL     0
1055 #endif /* OS2 */
1056                 XPput(*wp, str_nsave(Xstring(*xs, xp), Xlength(*xs, xp)
1057                         + KLUDGE_VAL, ATEMP));
1058                 return;
1059         }
1060
1061         if (xp > Xstring(*xs, xp))
1062                 *xp++ = DIRSEP;
1063         while (ISDIRSEP(*sp)) {
1064                 Xcheck(*xs, xp);
1065                 *xp++ = *sp++;
1066         }
1067         np = ksh_strchr_dirsep(sp);
1068         if (np != NULL) {
1069                 se = np;
1070                 odirsep = *np;  /* don't assume DIRSEP, can be multiple kinds */
1071                 *np++ = '\0';
1072         } else {
1073                 odirsep = '\0'; /* keep gcc quiet */
1074                 se = sp + strlen(sp);
1075         }
1076
1077
1078         /* Check if sp needs globbing - done to avoid pattern checks for strings
1079          * containing MAGIC characters, open ['s without the matching close ],
1080          * etc. (otherwise opendir() will be called which may fail because the
1081          * directory isn't readable - if no globbing is needed, only execute
1082          * permission should be required (as per POSIX)).
1083          */
1084         if (!has_globbing(sp, se)) {
1085                 XcheckN(*xs, xp, se - sp + 1);
1086                 debunk(xp, sp);
1087                 xp += strlen(xp);
1088                 *xpp = xp;
1089                 globit(xs, xpp, np, wp, check);
1090         } else {
1091                 DIR *dirp;
1092                 struct dirent *d;
1093                 char *name;
1094                 int len;
1095                 int prefix_len;
1096
1097                 /* xp = *xpp;      copy_non_glob() may have re-alloc'd xs */
1098                 *xp = '\0';
1099                 prefix_len = Xlength(*xs, xp);
1100                 dirp = ksh_opendir(prefix_len ? Xstring(*xs, xp) : ".");
1101                 if (dirp == NULL)
1102                         goto Nodir;
1103                 while ((d = readdir(dirp)) != NULL) {
1104                         name = d->d_name;
1105                         if (name[0] == '.' &&
1106                             (name[1] == 0 || (name[1] == '.' && name[2] == 0)))
1107                                 continue; /* always ignore . and .. */
1108                         if ((*name == '.' && *sp != '.')
1109                             || !gmatch(name, sp, TRUE))
1110                                 continue;
1111
1112                         len = NLENGTH(d) + 1;
1113                         XcheckN(*xs, xp, len);
1114                         memcpy(xp, name, len);
1115                         *xpp = xp + len - 1;
1116                         globit(xs, xpp, np, wp,
1117                                 (check & GF_MARKDIR) | GF_GLOBBED
1118                                 | (np ? GF_EXCHECK : GF_NONE));
1119                         xp = Xstring(*xs, xp) + prefix_len;
1120                 }
1121                 closedir(dirp);
1122           Nodir:;
1123         }
1124
1125         if (np != NULL)
1126                 *--np = odirsep;
1127 }
1128
1129 #if 0
1130 /* Check if p contains something that needs globbing; if it does, 0 is
1131  * returned; if not, p is copied into xs/xp after stripping any MAGICs
1132  */
1133 static int      copy_non_glob ARGS((XString *xs, char **xpp, char *p));
1134 static int
1135 copy_non_glob(xs, xpp, p)
1136         XString *xs;
1137         char **xpp;
1138         char *p;
1139 {
1140         char *xp;
1141         int len = strlen(p);
1142
1143         XcheckN(*xs, *xpp, len);
1144         xp = *xpp;
1145         for (; *p; p++) {
1146                 if (ISMAGIC(*p)) {
1147                         int c = *++p;
1148
1149                         if (c == '*' || c == '?')
1150                                 return 0;
1151                         if (*p == '[') {
1152                                 char *q = p + 1;
1153
1154                                 if (ISMAGIC(*q) && q[1] == NOT)
1155                                         q += 2;
1156                                 if (ISMAGIC(*q) && q[1] == ']')
1157                                         q += 2;
1158                                 for (; *q; q++)
1159                                         if (ISMAGIC(*q) && *++q == ']')
1160                                                 return 0;
1161                                 /* pass a literal [ through */
1162                         }
1163                         /* must be a MAGIC-MAGIC, or MAGIC-!, MAGIC--, etc. */
1164                 }
1165                 *xp++ = *p;
1166         }
1167         *xp = '\0';
1168         *xpp = xp;
1169         return 1;
1170 }
1171 #endif /* 0 */
1172
1173 /* remove MAGIC from string */
1174 char *
1175 debunk(dp, sp)
1176         char *dp;
1177         const char *sp;
1178 {
1179         char *d, *s;
1180
1181         if ((s = strchr(sp, MAGIC))) {
1182                 memcpy(dp, sp, s - sp);
1183                 for (d = dp + (s - sp); *s; s++)
1184                         if (!ISMAGIC(*s) || !(*++s & 0x80)
1185                             || !strchr("*+?@! ", *s & 0x7f))
1186                                 *d++ = *s;
1187                         else {
1188                                 /* extended pattern operators: *+?@! */
1189                                 if ((*s & 0x7f) != ' ')
1190                                         *d++ = *s & 0x7f;
1191                                 *d++ = '(';
1192                         }
1193                 *d = '\0';
1194         } else if (dp != sp)
1195                 strcpy(dp, sp);
1196         return dp;
1197 }
1198
1199 /* Check if p is an unquoted name, possibly followed by a / or :.  If so
1200  * puts the expanded version in *dcp,dp and returns a pointer in p just
1201  * past the name, otherwise returns 0.
1202  */
1203 static char *
1204 maybe_expand_tilde(p, dsp, dpp, isassign)
1205         char *p;
1206         XString *dsp;
1207         char **dpp;
1208         int isassign;
1209 {
1210         XString ts;
1211         char *dp = *dpp;
1212         char *tp, *r;
1213
1214         Xinit(ts, tp, 16, ATEMP);
1215         /* : only for DOASNTILDE form */
1216         while (p[0] == CHAR && !ISDIRSEP(p[1])
1217                && (!isassign || p[1] != PATHSEP))
1218         {
1219                 Xcheck(ts, tp);
1220                 *tp++ = p[1];
1221                 p += 2;
1222         }
1223         *tp = '\0';
1224         r = (p[0] == EOS || p[0] == CHAR || p[0] == CSUBST) ? tilde(Xstring(ts, tp)) : (char *) 0;
1225         Xfree(ts, tp);
1226         if (r) {
1227                 while (*r) {
1228                         Xcheck(*dsp, dp);
1229                         if (ISMAGIC(*r))
1230                                 *dp++ = MAGIC;
1231                         *dp++ = *r++;
1232                 }
1233                 *dpp = dp;
1234                 r = p;
1235         }
1236         return r;
1237 }
1238
1239 /*
1240  * tilde expansion
1241  *
1242  * based on a version by Arnold Robbins
1243  */
1244
1245 static char *
1246 tilde(cp)
1247         char *cp;
1248 {
1249         char *dp;
1250
1251         if (cp[0] == '\0')
1252                 dp = str_val(global("HOME"));
1253         else if (cp[0] == '+' && cp[1] == '\0')
1254                 dp = str_val(global("PWD"));
1255         else if (cp[0] == '-' && cp[1] == '\0')
1256                 dp = str_val(global("OLDPWD"));
1257         else
1258                 dp = homedir(cp);
1259         /* If HOME, PWD or OLDPWD are not set, don't expand ~ */
1260         if (dp == null)
1261                 dp = (char *) 0;
1262         return dp;
1263 }
1264
1265 /*
1266  * map userid to user's home directory.
1267  * note that 4.3's getpw adds more than 6K to the shell,
1268  * and the YP version probably adds much more.
1269  * we might consider our own version of getpwnam() to keep the size down.
1270  */
1271
1272 static char *
1273 homedir(name)
1274         char *name;
1275 {
1276         register struct tbl *ap;
1277
1278         ap = tenter(&homedirs, name, hash(name));
1279         if (!(ap->flag & ISSET)) {
1280 #ifdef OS2
1281                 /* No usernames in OS2 - punt */
1282                 return NULL;
1283 #else /* OS2 */
1284                 struct passwd *pw;
1285
1286                 pw = getpwnam(name);
1287                 if (pw == NULL)
1288                         return NULL;
1289                 ap->val.s = str_save(pw->pw_dir, APERM);
1290                 ap->flag |= DEFINED|ISSET|ALLOC;
1291 #endif /* OS2 */
1292         }
1293         return ap->val.s;
1294 }
1295
1296 #ifdef BRACE_EXPAND
1297 static void
1298 alt_expand(wp, start, exp_start, end, fdo)
1299         XPtrV *wp;
1300         char *start, *exp_start;
1301         char *end;
1302         int fdo;
1303 {
1304         int UNINITIALIZED(count);
1305         char *brace_start, *brace_end, *UNINITIALIZED(comma);
1306         char *field_start;
1307         char *p;
1308
1309         /* search for open brace */
1310         for (p = exp_start; (p = strchr(p, MAGIC)) && p[1] != OBRACE; p += 2)
1311                 ;
1312         brace_start = p;
1313
1314         /* find matching close brace, if any */
1315         if (p) {
1316                 comma = (char *) 0;
1317                 count = 1;
1318                 for (p += 2; *p && count; p++) {
1319                         if (ISMAGIC(*p)) {
1320                                 if (*++p == OBRACE)
1321                                         count++;
1322                                 else if (*p == CBRACE)
1323                                         --count;
1324                                 else if (*p == ',' && count == 1)
1325                                         comma = p;
1326                         }
1327                 }
1328         }
1329         /* no valid expansions... */
1330         if (!p || count != 0) {
1331                 /* Note that given a{{b,c} we do not expand anything (this is
1332                  * what at&t ksh does.  This may be changed to do the {b,c}
1333                  * expansion. }
1334                  */
1335                 if (fdo & DOGLOB)
1336                         glob(start, wp, fdo & DOMARKDIRS);
1337                 else
1338                         XPput(*wp, debunk(start, start));
1339                 return;
1340         }
1341         brace_end = p;
1342         if (!comma) {
1343                 alt_expand(wp, start, brace_end, end, fdo);
1344                 return;
1345         }
1346
1347         /* expand expression */
1348         field_start = brace_start + 2;
1349         count = 1;
1350         for (p = brace_start + 2; p != brace_end; p++) {
1351                 if (ISMAGIC(*p)) {
1352                         if (*++p == OBRACE)
1353                                 count++;
1354                         else if ((*p == CBRACE && --count == 0)
1355                                  || (*p == ',' && count == 1))
1356                         {
1357                                 char *new;
1358                                 int l1, l2, l3;
1359
1360                                 l1 = brace_start - start;
1361                                 l2 = (p - 1) - field_start;
1362                                 l3 = end - brace_end;
1363                                 new = (char *) alloc(l1 + l2 + l3 + 1, ATEMP);
1364                                 memcpy(new, start, l1);
1365                                 memcpy(new + l1, field_start, l2);
1366                                 memcpy(new + l1 + l2, brace_end, l3);
1367                                 new[l1 + l2 + l3] = '\0';
1368                                 alt_expand(wp, new, new + l1,
1369                                            new + l1 + l2 + l3, fdo);
1370                                 field_start = p + 1;
1371                         }
1372                 }
1373         }
1374         return;
1375 }
1376 #endif /* BRACE_EXPAND */