contrib/tcsh/sh.exp.c

   1 /* $Header: /src/pub/tcsh/sh.exp.c,v 3.45 2005/01/18 20:24:50 christos Exp $ */
   2 /*
   3  * sh.exp.c: Expression evaluations
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$Id: sh.exp.c,v 3.45 2005/01/18 20:24:50 christos Exp $")
  36
  37 #include "tw.h"
  38
  39 /*
  40  * C shell
  41  */
  42
  43 #define TEXP_IGNORE 1   /* in ignore, it means to ignore value, just parse */
  44 #define TEXP_NOGLOB 2   /* in ignore, it means not to globone */
  45
  46 #define ADDOP   1
  47 #define MULOP   2
  48 #define EQOP    4
  49 #define RELOP   8
  50 #define RESTOP  16
  51 #define ANYOP   31
  52
  53 #define EQEQ    1
  54 #define GTR     2
  55 #define LSS     4
  56 #define NOTEQ   6
  57 #define EQMATCH 7
  58 #define NOTEQMATCH 8
  59
  60 static  int      sh_access      __P((Char *, int));
  61 static  int      exp1           __P((Char ***, int));
  62 static  int      exp2x          __P((Char ***, int));
  63 static  int      exp2a          __P((Char ***, int));
  64 static  int      exp2b          __P((Char ***, int));
  65 static  int      exp2c          __P((Char ***, int));
  66 static  Char    *exp3           __P((Char ***, int));
  67 static  Char    *exp3a          __P((Char ***, int));
  68 static  Char    *exp4           __P((Char ***, int));
  69 static  Char    *exp5           __P((Char ***, int));
  70 static  Char    *exp6           __P((Char ***, int));
  71 static  void     evalav         __P((Char **));
  72 static  int      isa            __P((Char *, int));
  73 static  int      egetn          __P((Char *));
  74
  75
  76 #ifdef EDEBUG
  77 static  void     etracc         __P((char *, Char *, Char ***));
  78 static  void     etraci         __P((char *, int, Char ***));
  79 #endif /* EDEBUG */
  80
  81
  82 /*
  83  * shell access function according to POSIX and non POSIX
  84  * From Beto Appleton (beto@aixwiz.aix.ibm.com)
  85  */
  86 static int
  87 sh_access(fname, mode)
  88     Char *fname;
  89     int mode;
  90 {
  91 #if defined(POSIX) && !defined(USE_ACCESS)
  92     struct stat     statb;
  93 #endif /* POSIX */
  94     char *name = short2str(fname);
  95
  96     if (*name == '\0')
  97         return 1;
  98
  99 #if !defined(POSIX) || defined(USE_ACCESS)
 100     return access(name, mode);
 101 #else /* POSIX */
 102
 103     /*
 104      * POSIX 1003.2-d11.2
 105      *  -r file         True if file exists and is readable.
 106      *  -w file         True if file exists and is writable.
 107      *                  True shall indicate only that the write flag is on.
 108      *                  The file shall not be writable on a read-only file
 109      *                  system even if this test indicates true.
 110      *  -x file         True if file exists and is executable.
 111      *                  True shall indicate only that the execute flag is on.
 112      *                  If file is a directory, true indicates that the file
 113      *                  can be searched.
 114      */
 115     if (mode != W_OK && mode != X_OK)
 116         return access(name, mode);
 117
 118     if (stat(name, &statb) == -1)
 119         return 1;
 120
 121     if (access(name, mode) == 0) {
 122 #ifdef S_ISDIR
 123         if (S_ISDIR(statb.st_mode) && mode == X_OK)
 124             return 0;
 125 #endif /* S_ISDIR */
 126
 127         /* root needs permission for someone */
 128         switch (mode) {
 129         case W_OK:
 130             mode = S_IWUSR | S_IWGRP | S_IWOTH;
 131             break;
 132         case X_OK:
 133             mode = S_IXUSR | S_IXGRP | S_IXOTH;
 134             break;
 135         default:
 136             abort();
 137             break;
 138         }
 139
 140     }
 141
 142     else if (euid == statb.st_uid)
 143         mode <<= 6;
 144
 145     else if (egid == statb.st_gid)
 146         mode <<= 3;
 147
 148 # ifdef NGROUPS_MAX
 149     else {
 150         /* you can be in several groups */
 151         long    n;
 152         GETGROUPS_T *groups;
 153
 154         /*
 155          * Try these things to find a positive maximum groups value:
 156          *   1) sysconf(_SC_NGROUPS_MAX)
 157          *   2) NGROUPS_MAX
 158          *   3) getgroups(0, unused)
 159          * Then allocate and scan the groups array if one of these worked.
 160          */
 161 #  if defined (HAVE_SYSCONF) && defined (_SC_NGROUPS_MAX)
 162         if ((n = sysconf(_SC_NGROUPS_MAX)) == -1)
 163 #  endif /* _SC_NGROUPS_MAX */
 164             n = NGROUPS_MAX;
 165         if (n <= 0)
 166             n = getgroups(0, (GETGROUPS_T *) NULL);
 167
 168         if (n > 0) {
 169             groups = xmalloc((size_t) (n * sizeof(*groups)));
 170             n = getgroups((int) n, groups);
 171             while (--n >= 0)
 172                 if (groups[n] == statb.st_gid) {
 173                     mode <<= 3;
 174                     break;
 175                 }
 176         }
 177     }
 178 # endif /* NGROUPS_MAX */
 179
 180     if (statb.st_mode & mode)
 181         return 0;
 182     else
 183         return 1;
 184 #endif /* !POSIX */
 185 }
 186
 187 int
 188 expr(vp)
 189     Char ***vp;
 190 {
 191     return (exp0(vp, 0));
 192 }
 193
 194 int
 195 exp0(vp, ignore)
 196     Char ***vp;
 197     int    ignore;
 198 {
 199     int p1 = exp1(vp, ignore);
 200
 201 #ifdef EDEBUG
 202     etraci("exp0 p1", p1, vp);
 203 #endif /* EDEBUG */
 204     if (**vp && eq(**vp, STRor2)) {
 205         int p2;
 206
 207         (*vp)++;
 208         p2 = exp0(vp, (ignore & TEXP_IGNORE) || p1);
 209 #ifdef EDEBUG
 210         etraci("exp0 p2", p2, vp);
 211 #endif /* EDEBUG */
 212         return (p1 || p2);
 213     }
 214     return (p1);
 215 }
 216
 217 static int
 218 exp1(vp, ignore)
 219     Char ***vp;
 220     int    ignore;
 221 {
 222     int p1 = exp2x(vp, ignore);
 223
 224 #ifdef EDEBUG
 225     etraci("exp1 p1", p1, vp);
 226 #endif /* EDEBUG */
 227     if (**vp && eq(**vp, STRand2)) {
 228         int p2;
 229
 230         (*vp)++;
 231         p2 = exp1(vp, (ignore & TEXP_IGNORE) || !p1);
 232 #ifdef EDEBUG
 233         etraci("exp1 p2", p2, vp);
 234 #endif /* EDEBUG */
 235         return (p1 && p2);
 236     }
 237     return (p1);
 238 }
 239
 240 static int
 241 exp2x(vp, ignore)
 242     Char ***vp;
 243     int    ignore;
 244 {
 245     int p1 = exp2a(vp, ignore);
 246
 247 #ifdef EDEBUG
 248     etraci("exp3 p1", p1, vp);
 249 #endif /* EDEBUG */
 250     if (**vp && eq(**vp, STRor)) {
 251         int p2;
 252
 253         (*vp)++;
 254         p2 = exp2x(vp, ignore);
 255 #ifdef EDEBUG
 256         etraci("exp3 p2", p2, vp);
 257 #endif /* EDEBUG */
 258         return (p1 | p2);
 259     }
 260     return (p1);
 261 }
 262
 263 static int
 264 exp2a(vp, ignore)
 265     Char ***vp;
 266     int    ignore;
 267 {
 268     int p1 = exp2b(vp, ignore);
 269
 270 #ifdef EDEBUG
 271     etraci("exp2a p1", p1, vp);
 272 #endif /* EDEBUG */
 273     if (**vp && eq(**vp, STRcaret)) {
 274         int p2;
 275
 276         (*vp)++;
 277         p2 = exp2a(vp, ignore);
 278 #ifdef EDEBUG
 279         etraci("exp2a p2", p2, vp);
 280 #endif /* EDEBUG */
 281         return (p1 ^ p2);
 282     }
 283     return (p1);
 284 }
 285
 286 static int
 287 exp2b(vp, ignore)
 288     Char ***vp;
 289     int    ignore;
 290 {
 291     int p1 = exp2c(vp, ignore);
 292
 293 #ifdef EDEBUG
 294     etraci("exp2b p1", p1, vp);
 295 #endif /* EDEBUG */
 296     if (**vp && eq(**vp, STRand)) {
 297         int p2;
 298
 299         (*vp)++;
 300         p2 = exp2b(vp, ignore);
 301 #ifdef EDEBUG
 302         etraci("exp2b p2", p2, vp);
 303 #endif /* EDEBUG */
 304         return (p1 & p2);
 305     }
 306     return (p1);
 307 }
 308
 309 static int
 310 exp2c(vp, ignore)
 311     Char ***vp;
 312     int    ignore;
 313 {
 314     Char *p1 = exp3(vp, ignore);
 315     Char *p2;
 316     int i;
 317
 318 #ifdef EDEBUG
 319     etracc("exp2c p1", p1, vp);
 320 #endif /* EDEBUG */
 321     if ((i = isa(**vp, EQOP)) != 0) {
 322         (*vp)++;
 323         if (i == EQMATCH || i == NOTEQMATCH)
 324             ignore |= TEXP_NOGLOB;
 325         p2 = exp3(vp, ignore);
 326 #ifdef EDEBUG
 327         etracc("exp2c p2", p2, vp);
 328 #endif /* EDEBUG */
 329         if (!(ignore & TEXP_IGNORE))
 330             switch (i) {
 331
 332             case EQEQ:
 333                 i = eq(p1, p2);
 334                 break;
 335
 336             case NOTEQ:
 337                 i = !eq(p1, p2);
 338                 break;
 339
 340             case EQMATCH:
 341                 i = Gmatch(p1, p2);
 342                 break;
 343
 344             case NOTEQMATCH:
 345                 i = !Gmatch(p1, p2);
 346                 break;
 347             }
 348         xfree((ptr_t) p1);
 349         xfree((ptr_t) p2);
 350         return (i);
 351     }
 352     i = egetn(p1);
 353     xfree((ptr_t) p1);
 354     return (i);
 355 }
 356
 357 static Char *
 358 exp3(vp, ignore)
 359     Char ***vp;
 360     int    ignore;
 361 {
 362     Char *p1, *p2;
 363     int i;
 364
 365     p1 = exp3a(vp, ignore);
 366 #ifdef EDEBUG
 367     etracc("exp3 p1", p1, vp);
 368 #endif /* EDEBUG */
 369     if ((i = isa(**vp, RELOP)) != 0) {
 370         (*vp)++;
 371         if (**vp && eq(**vp, STRequal))
 372             i |= 1, (*vp)++;
 373         p2 = exp3(vp, ignore);
 374 #ifdef EDEBUG
 375         etracc("exp3 p2", p2, vp);
 376 #endif /* EDEBUG */
 377         if (!(ignore & TEXP_IGNORE))
 378             switch (i) {
 379
 380             case GTR:
 381                 i = egetn(p1) > egetn(p2);
 382                 break;
 383
 384             case GTR | 1:
 385                 i = egetn(p1) >= egetn(p2);
 386                 break;
 387
 388             case LSS:
 389                 i = egetn(p1) < egetn(p2);
 390                 break;
 391
 392             case LSS | 1:
 393                 i = egetn(p1) <= egetn(p2);
 394                 break;
 395             }
 396         xfree((ptr_t) p1);
 397         xfree((ptr_t) p2);
 398         return (putn(i));
 399     }
 400     return (p1);
 401 }
 402
 403 static Char *
 404 exp3a(vp, ignore)
 405     Char ***vp;
 406     int    ignore;
 407 {
 408     Char *p1, *p2, *op;
 409     int i;
 410
 411     p1 = exp4(vp, ignore);
 412 #ifdef EDEBUG
 413     etracc("exp3a p1", p1, vp);
 414 #endif /* EDEBUG */
 415     op = **vp;
 416     if (op && any("<>", op[0]) && op[0] == op[1]) {
 417         (*vp)++;
 418         p2 = exp3a(vp, ignore);
 419 #ifdef EDEBUG
 420         etracc("exp3a p2", p2, vp);
 421 #endif /* EDEBUG */
 422         if (op[0] == '<')
 423             i = egetn(p1) << egetn(p2);
 424         else
 425             i = egetn(p1) >> egetn(p2);
 426         xfree((ptr_t) p1);
 427         xfree((ptr_t) p2);
 428         return (putn(i));
 429     }
 430     return (p1);
 431 }
 432
 433 static Char *
 434 exp4(vp, ignore)
 435     Char ***vp;
 436     int    ignore;
 437 {
 438     Char *p1, *p2;
 439     int i = 0;
 440
 441     p1 = exp5(vp, ignore);
 442 #ifdef EDEBUG
 443     etracc("exp4 p1", p1, vp);
 444 #endif /* EDEBUG */
 445     if (isa(**vp, ADDOP)) {
 446         Char *op = *(*vp)++;
 447
 448         p2 = exp4(vp, ignore);
 449 #ifdef EDEBUG
 450         etracc("exp4 p2", p2, vp);
 451 #endif /* EDEBUG */
 452         if (!(ignore & TEXP_IGNORE))
 453             switch (op[0]) {
 454
 455             case '+':
 456                 i = egetn(p1) + egetn(p2);
 457                 break;
 458
 459             case '-':
 460                 i = egetn(p1) - egetn(p2);
 461                 break;
 462             }
 463         xfree((ptr_t) p1);
 464         xfree((ptr_t) p2);
 465         return (putn(i));
 466     }
 467     return (p1);
 468 }
 469
 470 static Char *
 471 exp5(vp, ignore)
 472     Char ***vp;
 473     int    ignore;
 474 {
 475     Char *p1, *p2;
 476     int i = 0;
 477
 478     p1 = exp6(vp, ignore);
 479 #ifdef EDEBUG
 480     etracc("exp5 p1", p1, vp);
 481 #endif /* EDEBUG */
 482
 483     if (isa(**vp, MULOP)) {
 484         Char *op = *(*vp)++;
 485         if ((ignore & TEXP_NOGLOB) != 0)
 486             /*
 487              * We are just trying to get the right side of
 488              * a =~ or !~ operator
 489              */
 490             return Strsave(op);
 491
 492         p2 = exp5(vp, ignore);
 493 #ifdef EDEBUG
 494         etracc("exp5 p2", p2, vp);
 495 #endif /* EDEBUG */
 496         if (!(ignore & TEXP_IGNORE))
 497             switch (op[0]) {
 498
 499             case '*':
 500                 i = egetn(p1) * egetn(p2);
 501                 break;
 502
 503             case '/':
 504                 i = egetn(p2);
 505                 if (i == 0)
 506                     stderror(ERR_DIV0);
 507                 i = egetn(p1) / i;
 508                 break;
 509
 510             case '%':
 511                 i = egetn(p2);
 512                 if (i == 0)
 513                     stderror(ERR_MOD0);
 514                 i = egetn(p1) % i;
 515                 break;
 516             }
 517         xfree((ptr_t) p1);
 518         xfree((ptr_t) p2);
 519         return (putn(i));
 520     }
 521     return (p1);
 522 }
 523
 524 static Char *
 525 exp6(vp, ignore)
 526     Char ***vp;
 527     int    ignore;
 528 {
 529     int     ccode, i = 0;
 530     Char *cp;
 531
 532     if (**vp == 0)
 533         stderror(ERR_NAME | ERR_EXPRESSION);
 534     if (eq(**vp, STRbang)) {
 535         (*vp)++;
 536         cp = exp6(vp, ignore);
 537 #ifdef EDEBUG
 538         etracc("exp6 ! cp", cp, vp);
 539 #endif /* EDEBUG */
 540         i = egetn(cp);
 541         xfree((ptr_t) cp);
 542         return (putn(!i));
 543     }
 544     if (eq(**vp, STRtilde)) {
 545         (*vp)++;
 546         cp = exp6(vp, ignore);
 547 #ifdef EDEBUG
 548         etracc("exp6 ~ cp", cp, vp);
 549 #endif /* EDEBUG */
 550         i = egetn(cp);
 551         xfree((ptr_t) cp);
 552         return (putn(~i));
 553     }
 554     if (eq(**vp, STRLparen)) {
 555         (*vp)++;
 556         ccode = exp0(vp, ignore);
 557 #ifdef EDEBUG
 558         etraci("exp6 () ccode", ccode, vp);
 559 #endif /* EDEBUG */
 560         if (*vp == 0 || **vp == 0 || ***vp != ')')
 561             stderror(ERR_NAME | ERR_EXPRESSION);
 562         (*vp)++;
 563         return (putn(ccode));
 564     }
 565     if (eq(**vp, STRLbrace)) {
 566         Char **v;
 567         struct command faket;
 568         Char   *fakecom[2];
 569
 570         faket.t_dtyp = NODE_COMMAND;
 571         faket.t_dflg = F_BACKQ;
 572         faket.t_dcar = faket.t_dcdr = faket.t_dspr = NULL;
 573         faket.t_dcom = fakecom;
 574         fakecom[0] = STRfakecom;
 575         fakecom[1] = NULL;
 576         (*vp)++;
 577         v = *vp;
 578         for (;;) {
 579             if (!**vp)
 580                 stderror(ERR_NAME | ERR_MISSING, '}');
 581             if (eq(*(*vp)++, STRRbrace))
 582                 break;
 583         }
 584         if (ignore & TEXP_IGNORE)
 585             return (Strsave(STRNULL));
 586         psavejob();
 587         if (pfork(&faket, -1) == 0) {
 588             *--(*vp) = 0;
 589             evalav(v);
 590             exitstat();
 591         }
 592         pwait();
 593         prestjob();
 594 #ifdef EDEBUG
 595         etraci("exp6 {} status", egetn(varval(STRstatus)), vp);
 596 #endif /* EDEBUG */
 597         return (putn(egetn(varval(STRstatus)) == 0));
 598     }
 599     if (isa(**vp, ANYOP))
 600         return (Strsave(STRNULL));
 601     cp = *(*vp)++;
 602 #ifdef convex
 603 # define FILETESTS "erwxfdzoplstSXLbcugkmKR"
 604 #else
 605 # define FILETESTS "erwxfdzoplstSXLbcugkmK"
 606 #endif /* convex */
 607 #define FILEVALS  "ZAMCDIUGNFPL"
 608     if (*cp == '-' && (any(FILETESTS, cp[1]) || any(FILEVALS, cp[1])))
 609         return(filetest(cp, vp, ignore));
 610 #ifdef EDEBUG
 611     etracc("exp6 default", cp, vp);
 612 #endif /* EDEBUG */
 613     return (ignore & TEXP_NOGLOB ? Strsave(cp) : globone(cp, G_APPEND));
 614 }
 615
 616
 617 /*
 618  * Extended file tests
 619  * From: John Rowe <rowe@excc.exeter.ac.uk>
 620  */
 621 Char *
 622 filetest(cp, vp, ignore)
 623     Char *cp, ***vp;
 624     int ignore;
 625 {
 626 #ifdef convex
 627     struct cvxstat stb, *st = NULL;
 628 # define TCSH_STAT      stat64
 629 #else
 630 # define TCSH_STAT      stat
 631     struct stat stb, *st = NULL;
 632 #endif /* convex */
 633
 634 #ifdef S_IFLNK
 635 # ifdef convex
 636     struct cvxstat lstb, *lst = NULL;
 637 #  define TCSH_LSTAT lstat64
 638 # else
 639 #  define TCSH_LSTAT lstat
 640     struct stat lstb, *lst = NULL;
 641 # endif /* convex */
 642     char *filnam;
 643 #endif /* S_IFLNK */
 644
 645     int i = 0;
 646     unsigned pmask = 0xffff;
 647     int altout = 0;
 648     Char *ft = cp, *dp, *ep, *strdev, *strino, *strF, *str, valtest = '\0',
 649     *errval = STR0;
 650     char *string, string0[8];
 651     time_t footime;
 652     struct passwd *pw;
 653     struct group *gr;
 654
 655     while(any(FILETESTS, *++ft))
 656         continue;
 657
 658     if (!*ft && *(ft - 1) == 'L')
 659         --ft;
 660
 661     if (any(FILEVALS, *ft)) {
 662         valtest = *ft++;
 663         /*
 664          * Value tests return '-1' on failure as 0 is
 665          * a legitimate value for many of them.
 666          * 'F' returns ':' for compatibility.
 667          */
 668         errval = valtest == 'F' ? STRcolon : STRminus1;
 669
 670         if (valtest == 'P' && *ft >= '0' && *ft <= '7') {
 671             pmask = (char) *ft - '0';
 672             while ( *++ft >= '0' && *ft <= '7' )
 673                 pmask = 8 * pmask + ((char) *ft - '0');
 674         }
 675         if (Strcmp(ft, STRcolon) == 0 && any("AMCUGP", valtest)) {
 676             altout = 1;
 677             ++ft;
 678         }
 679     }
 680
 681     if (*ft || ft == cp + 1)
 682         stderror(ERR_NAME | ERR_FILEINQ);
 683
 684     /*
 685      * Detect missing file names by checking for operator in the file name
 686      * position.  However, if an operator name appears there, we must make
 687      * sure that there's no file by that name (e.g., "/") before announcing
 688      * an error.  Even this check isn't quite right, since it doesn't take
 689      * globbing into account.
 690      */
 691
 692     if (isa(**vp, ANYOP) && TCSH_STAT(short2str(**vp), &stb))
 693         stderror(ERR_NAME | ERR_FILENAME);
 694
 695     dp = *(*vp)++;
 696     if (ignore & TEXP_IGNORE)
 697         return (Strsave(STRNULL));
 698     ep = globone(dp, G_APPEND);
 699     ft = &cp[1];
 700     do
 701         switch (*ft) {
 702
 703         case 'r':
 704             i = !sh_access(ep, R_OK);
 705             break;
 706
 707         case 'w':
 708             i = !sh_access(ep, W_OK);
 709             break;
 710
 711         case 'x':
 712             i = !sh_access(ep, X_OK);
 713             break;
 714
 715         case 'X':       /* tcsh extension, name is an executable in the path
 716                          * or a tcsh builtin command
 717                          */
 718             i = find_cmd(ep, 0);
 719             break;
 720
 721         case 't':       /* SGI extension, true when file is a tty */
 722             i = isatty(atoi(short2str(ep)));
 723             break;
 724
 725         default:
 726
 727 #ifdef S_IFLNK
 728             if (tolower(*ft) == 'l') {
 729                 /*
 730                  * avoid convex compiler bug.
 731                  */
 732                 if (!lst) {
 733                     lst = &lstb;
 734                     if (TCSH_LSTAT(short2str(ep), lst) == -1) {
 735                         xfree((ptr_t) ep);
 736                         return (Strsave(errval));
 737                     }
 738                 }
 739                 if (*ft == 'L')
 740                     st = lst;
 741             }
 742             else
 743 #endif /* S_IFLNK */
 744                 /*
 745                  * avoid convex compiler bug.
 746                  */
 747                 if (!st) {
 748                     st = &stb;
 749                     if (TCSH_STAT(short2str(ep), st) == -1) {
 750                         xfree((ptr_t) ep);
 751                         return (Strsave(errval));
 752                     }
 753                 }
 754
 755             switch (*ft) {
 756
 757             case 'f':
 758 #ifdef S_ISREG
 759                 i = S_ISREG(st->st_mode);
 760 #else /* !S_ISREG */
 761                 i = 0;
 762 #endif /* S_ISREG */
 763                 break;
 764
 765             case 'd':
 766 #ifdef S_ISDIR
 767                 i = S_ISDIR(st->st_mode);
 768 #else /* !S_ISDIR */
 769                 i = 0;
 770 #endif /* S_ISDIR */
 771                 break;
 772
 773             case 'p':
 774 #ifdef S_ISFIFO
 775                 i = S_ISFIFO(st->st_mode);
 776 #else /* !S_ISFIFO */
 777                 i = 0;
 778 #endif /* S_ISFIFO */
 779                 break;
 780
 781             case 'm' :
 782 #ifdef S_ISOFL
 783               i = S_ISOFL(st->st_dm_mode);
 784 #else /* !S_ISOFL */
 785               i = 0;
 786 #endif /* S_ISOFL */
 787               break ;
 788
 789             case 'K' :
 790 #ifdef S_ISOFL
 791               i = stb.st_dm_key;
 792 #else /* !S_ISOFL */
 793               i = 0;
 794 #endif /* S_ISOFL */
 795               break ;
 796
 797
 798             case 'l':
 799 #ifdef S_ISLNK
 800                 i = S_ISLNK(lst->st_mode);
 801 #else /* !S_ISLNK */
 802                 i = 0;
 803 #endif /* S_ISLNK */
 804                 break;
 805
 806             case 'S':
 807 # ifdef S_ISSOCK
 808                 i = S_ISSOCK(st->st_mode);
 809 # else /* !S_ISSOCK */
 810                 i = 0;
 811 # endif /* S_ISSOCK */
 812                 break;
 813
 814             case 'b':
 815 #ifdef S_ISBLK
 816                 i = S_ISBLK(st->st_mode);
 817 #else /* !S_ISBLK */
 818                 i = 0;
 819 #endif /* S_ISBLK */
 820                 break;
 821
 822             case 'c':
 823 #ifdef S_ISCHR
 824                 i = S_ISCHR(st->st_mode);
 825 #else /* !S_ISCHR */
 826                 i = 0;
 827 #endif /* S_ISCHR */
 828                 break;
 829
 830             case 'u':
 831                 i = (S_ISUID & st->st_mode) != 0;
 832                 break;
 833
 834             case 'g':
 835                 i = (S_ISGID & st->st_mode) != 0;
 836                 break;
 837
 838             case 'k':
 839                 i = (S_ISVTX & st->st_mode) != 0;
 840                 break;
 841
 842             case 'z':
 843                 i = st->st_size == 0;
 844                 break;
 845
 846 #ifdef convex
 847             case 'R':
 848                 i = (stb.st_dmonflags & IMIGRATED) == IMIGRATED;
 849                 break;
 850 #endif /* convex */
 851
 852             case 's':
 853                 i = stb.st_size != 0;
 854                 break;
 855
 856             case 'e':
 857                 i = 1;
 858                 break;
 859
 860             case 'o':
 861                 i = st->st_uid == uid;
 862                 break;
 863
 864                 /*
 865                  * Value operators are a tcsh extension.
 866                  */
 867
 868             case 'D':
 869                 i = (int) st->st_dev;
 870                 break;
 871
 872             case 'I':
 873                 i = (int) st->st_ino;
 874                 break;
 875
 876             case 'F':
 877                 strdev = putn( (int) st->st_dev);
 878                 strino = putn( (int) st->st_ino);
 879                 strF = (Char *) xmalloc((size_t) (2 + Strlen(strdev) +
 880                                          Strlen(strino)) * sizeof(Char));
 881                 (void) Strcat(Strcat(Strcpy(strF, strdev), STRcolon), strino);
 882                 xfree((ptr_t) strdev);
 883                 xfree((ptr_t) strino);
 884                 xfree((ptr_t) ep);
 885                 return(strF);
 886
 887             case 'L':
 888                 if ( *(ft + 1) ) {
 889                     i = 1;
 890                     break;
 891                 }
 892 #ifdef S_ISLNK
 893                 filnam = short2str(ep);
 894 #ifdef PATH_MAX
 895 # define MY_PATH_MAX PATH_MAX
 896 #else /* !PATH_MAX */
 897 /*
 898  * I can't think of any more sensible alterative; readlink doesn't give
 899  * us an errno if the buffer isn't large enough :-(
 900  */
 901 # define MY_PATH_MAX  2048
 902 #endif /* PATH_MAX */
 903                 i = readlink(filnam, string = (char *)
 904                       xmalloc((size_t) (1 + MY_PATH_MAX) * sizeof(char)),
 905                         MY_PATH_MAX);
 906                 if (i >= 0 && i <= MY_PATH_MAX)
 907                     string[i] = '\0'; /* readlink does not null terminate */
 908                 strF = (i < 0) ? errval : str2short(string);
 909                 xfree((ptr_t) string);
 910                 xfree((ptr_t) ep);
 911                 return(Strsave(strF));
 912
 913 #else /* !S_ISLNK */
 914                 i = 0;
 915                 break;
 916 #endif /* S_ISLNK */
 917
 918
 919             case 'N':
 920                 i = (int) st->st_nlink;
 921                 break;
 922
 923             case 'P':
 924                 string = string0 + 1;
 925                 (void) xsnprintf(string, sizeof(string0) - 1, "%o",
 926                     pmask & (unsigned int)
 927                     ((S_IRWXU|S_IRWXG|S_IRWXO|S_ISUID|S_ISGID) & st->st_mode));
 928                 if (altout && *string != '0')
 929                     *--string = '0';
 930                 xfree((ptr_t) ep);
 931                 return(Strsave(str2short(string)));
 932
 933             case 'U':
 934                 if (altout && (pw = getpwuid(st->st_uid))) {
 935                     xfree((ptr_t) ep);
 936                     return(Strsave(str2short(pw->pw_name)));
 937                 }
 938                 i = (int) st->st_uid;
 939                 break;
 940
 941             case 'G':
 942                 if ( altout && (gr = getgrgid(st->st_gid))) {
 943                     xfree((ptr_t) ep);
 944                     return(Strsave(str2short(gr->gr_name)));
 945                 }
 946                 i = (int) st->st_gid;
 947                 break;
 948
 949             case 'Z':
 950                 i = (int) st->st_size;
 951                 break;
 952
 953             case 'A': case 'M': case 'C':
 954                 footime = *ft == 'A' ? st->st_atime :
 955                     *ft == 'M' ? st->st_mtime : st->st_ctime;
 956                 if (altout) {
 957                     strF = str2short(ctime(&footime));
 958                     if ((str = Strchr(strF, '\n')) != NULL)
 959                         *str = (Char) '\0';
 960                     xfree((ptr_t) ep);
 961                     return(Strsave(strF));
 962                 }
 963                 i = (int) footime;
 964                 break;
 965
 966             }
 967         }
 968     while (*++ft && i);
 969 #ifdef EDEBUG
 970     etraci("exp6 -? i", i, vp);
 971 #endif /* EDEBUG */
 972     xfree((ptr_t) ep);
 973     return (putn(i));
 974 }
 975
 976
 977 static void
 978 evalav(v)
 979     Char **v;
 980 {
 981     struct wordent paraml1;
 982     struct wordent *hp = &paraml1;
 983     struct command *t;
 984     struct wordent *wdp = hp;
 985
 986     set(STRstatus, Strsave(STR0), VAR_READWRITE);
 987     hp->prev = hp->next = hp;
 988     hp->word = STRNULL;
 989     while (*v) {
 990         struct wordent *new =
 991         (struct wordent *) xcalloc(1, sizeof *wdp);
 992
 993         new->prev = wdp;
 994         new->next = hp;
 995         wdp->next = new;
 996         wdp = new;
 997         wdp->word = Strsave(*v++);
 998     }
 999     hp->prev = wdp;
1000     alias(&paraml1);
1001     t = syntax(paraml1.next, &paraml1, 0);
1002     if (seterr)
1003         stderror(ERR_OLD);
1004     execute(t, -1, NULL, NULL, TRUE);
1005     freelex(&paraml1), freesyn(t);
1006 }
1007
1008 static int
1009 isa(cp, what)
1010     Char *cp;
1011     int what;
1012 {
1013     if (cp == 0)
1014         return ((what & RESTOP) != 0);
1015     if (*cp == '\0')
1016         return 0;
1017     if (cp[1] == 0) {
1018         if (what & ADDOP && (*cp == '+' || *cp == '-'))
1019             return (1);
1020         if (what & MULOP && (*cp == '*' || *cp == '/' || *cp == '%'))
1021             return (1);
1022         if (what & RESTOP && (*cp == '(' || *cp == ')' || *cp == '!' ||
1023                               *cp == '~' || *cp == '^' || *cp == '"'))
1024             return (1);
1025     }
1026     else if (cp[2] == 0) {
1027         if (what & RESTOP) {
1028             if (cp[0] == '|' && cp[1] == '&')
1029                 return (1);
1030             if (cp[0] == '<' && cp[1] == '<')
1031                 return (1);
1032             if (cp[0] == '>' && cp[1] == '>')
1033                 return (1);
1034         }
1035         if (what & EQOP) {
1036             if (cp[0] == '=') {
1037                 if (cp[1] == '=')
1038                     return (EQEQ);
1039                 if (cp[1] == '~')
1040                     return (EQMATCH);
1041             }
1042             else if (cp[0] == '!') {
1043                 if (cp[1] == '=')
1044                     return (NOTEQ);
1045                 if (cp[1] == '~')
1046                     return (NOTEQMATCH);
1047             }
1048         }
1049     }
1050     if (what & RELOP) {
1051         if (*cp == '<')
1052             return (LSS);
1053         if (*cp == '>')
1054             return (GTR);
1055     }
1056     return (0);
1057 }
1058
1059 static int
1060 egetn(cp)
1061     Char *cp;
1062 {
1063     if (*cp && *cp != '-' && !Isdigit(*cp))
1064         stderror(ERR_NAME | ERR_EXPRESSION);
1065     return (getn(cp));
1066 }
1067
1068 /* Phew! */
1069
1070 #ifdef EDEBUG
1071 static void
1072 etraci(str, i, vp)
1073     char   *str;
1074     int     i;
1075     Char ***vp;
1076 {
1077     xprintf("%s=%d\t", str, i);
1078     blkpr(*vp);
1079     xputchar('\n');
1080 }
1081 static void
1082 etracc(str, cp, vp)
1083     char   *str;
1084     Char   *cp;
1085     Char ***vp;
1086 {
1087     xprintf("%s=%s\t", str, cp);
1088     blkpr(*vp);
1089     xputchar('\n');
1090 }
1091 #endif /* EDEBUG */