contrib/tcsh-6/sh.exp.c

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