bin/ksh/c_test.c

   1 /*      $NetBSD: c_test.c,v 1.6 2005/06/26 19:09:00 christos Exp $      */
   2
   3 /*
   4  * test(1); version 7-like  --  author Erik Baalbergen
   5  * modified by Eric Gisin to be used as built-in.
   6  * modified by Arnold Robbins to add SVR3 compatibility
   7  * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
   8  * modified by Michael Rendell to add Korn's [[ .. ]] expressions.
   9  * modified by J.T. Conklin to add POSIX compatibility.
  10  */
  11 #include <sys/cdefs.h>
  12
  13 #ifndef lint
  14 __RCSID("$NetBSD: c_test.c,v 1.6 2005/06/26 19:09:00 christos Exp $");
  15 #endif
  16
  17
  18 #include "sh.h"
  19 #include "ksh_stat.h"
  20 #include "c_test.h"
  21
  22 /* test(1) accepts the following grammar:
  23         oexpr   ::= aexpr | aexpr "-o" oexpr ;
  24         aexpr   ::= nexpr | nexpr "-a" aexpr ;
  25         nexpr   ::= primary | "!" nexpr ;
  26         primary ::= unary-operator operand
  27                 | operand binary-operator operand
  28                 | operand
  29                 | "(" oexpr ")"
  30                 ;
  31
  32         unary-operator ::= "-a"|"-r"|"-w"|"-x"|"-e"|"-f"|"-d"|"-c"|"-b"|"-p"|
  33                            "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|
  34                            "-L"|"-h"|"-S"|"-H";
  35
  36         binary-operator ::= "="|"=="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
  37                             "-nt"|"-ot"|"-ef"|
  38                             "<"|">"     # rules used for [[ .. ]] expressions
  39                             ;
  40         operand ::= <any thing>
  41 */
  42
  43 #define T_ERR_EXIT      2       /* POSIX says > 1 for errors */
  44
  45 struct t_op {
  46         char    op_text[4];
  47         Test_op op_num;
  48 };
  49 static const struct t_op u_ops [] = {
  50         {"-a",  TO_FILAXST },
  51         {"-b",  TO_FILBDEV },
  52         {"-c",  TO_FILCDEV },
  53         {"-d",  TO_FILID },
  54         {"-e",  TO_FILEXST },
  55         {"-f",  TO_FILREG },
  56         {"-G",  TO_FILGID },
  57         {"-g",  TO_FILSETG },
  58         {"-h",  TO_FILSYM },
  59         {"-H",  TO_FILCDF },
  60         {"-k",  TO_FILSTCK },
  61         {"-L",  TO_FILSYM },
  62         {"-n",  TO_STNZE },
  63         {"-O",  TO_FILUID },
  64         {"-o",  TO_OPTION },
  65         {"-p",  TO_FILFIFO },
  66         {"-r",  TO_FILRD },
  67         {"-s",  TO_FILGZ },
  68         {"-S",  TO_FILSOCK },
  69         {"-t",  TO_FILTT },
  70         {"-u",  TO_FILSETU },
  71         {"-w",  TO_FILWR },
  72         {"-x",  TO_FILEX },
  73         {"-z",  TO_STZER },
  74         {"",    TO_NONOP }
  75     };
  76 static const struct t_op b_ops [] = {
  77         {"=",   TO_STEQL },
  78 #ifdef KSH
  79         {"==",  TO_STEQL },
  80 #endif /* KSH */
  81         {"!=",  TO_STNEQ },
  82         {"<",   TO_STLT },
  83         {">",   TO_STGT },
  84         {"-eq", TO_INTEQ },
  85         {"-ne", TO_INTNE },
  86         {"-gt", TO_INTGT },
  87         {"-ge", TO_INTGE },
  88         {"-lt", TO_INTLT },
  89         {"-le", TO_INTLE },
  90         {"-ef", TO_FILEQ },
  91         {"-nt", TO_FILNT },
  92         {"-ot", TO_FILOT },
  93         {"",    TO_NONOP }
  94     };
  95
  96 static int      test_stat ARGS((const char *, struct stat *));
  97 static int      test_eaccess ARGS((const char *, int));
  98 static int      test_oexpr ARGS((Test_env *, int));
  99 static int      test_aexpr ARGS((Test_env *, int));
 100 static int      test_nexpr ARGS((Test_env *, int));
 101 static int      test_primary ARGS((Test_env *, int));
 102 static int      ptest_isa ARGS((Test_env *, Test_meta));
 103 static const char *ptest_getopnd ARGS((Test_env *, Test_op, int));
 104 static int      ptest_eval ARGS((Test_env *, Test_op, const char *,
 105                                 const char *, int));
 106 static void     ptest_error ARGS((Test_env *, int, const char *));
 107
 108 int
 109 c_test(wp)
 110         char **wp;
 111 {
 112         int argc;
 113         int res;
 114         Test_env te;
 115
 116         te.flags = 0;
 117         te.isa = ptest_isa;
 118         te.getopnd = ptest_getopnd;
 119         te.eval = ptest_eval;
 120         te.error = ptest_error;
 121
 122         for (argc = 0; wp[argc]; argc++)
 123                 ;
 124
 125         if (strcmp(wp[0], "[") == 0) {
 126                 if (strcmp(wp[--argc], "]") != 0) {
 127                         bi_errorf("missing ]");
 128                         return T_ERR_EXIT;
 129                 }
 130         }
 131
 132         te.pos.wp = wp + 1;
 133         te.wp_end = wp + argc;
 134
 135         /*
 136          * Handle the special cases from POSIX.2, section 4.62.4.
 137          * Implementation of all the rules isn't necessary since
 138          * our parser does the right thing for the omitted steps.
 139          */
 140         if (argc <= 5) {
 141                 char **owp = wp;
 142                 int invert = 0;
 143                 Test_op op;
 144                 const char *opnd1, *opnd2;
 145
 146                 while (--argc >= 0) {
 147                         if ((*te.isa)(&te, TM_END))
 148                                 return !0;
 149                         if (argc == 3) {
 150                                 opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
 151                                 if ((op = (Test_op) (*te.isa)(&te, TM_BINOP))) {
 152                                         opnd2 = (*te.getopnd)(&te, op, 1);
 153                                         res = (*te.eval)(&te, op, opnd1, opnd2,
 154                                                         1);
 155                                         if (te.flags & TEF_ERROR)
 156                                                 return T_ERR_EXIT;
 157                                         if (invert & 1)
 158                                                 res = !res;
 159                                         return !res;
 160                                 }
 161                                 /* back up to opnd1 */
 162                                 te.pos.wp--;
 163                         }
 164                         if (argc == 1) {
 165                                 opnd1 = (*te.getopnd)(&te, TO_NONOP, 1);
 166                                 /* Historically, -t by itself test if fd 1
 167                                  * is a file descriptor, but POSIX says its
 168                                  * a string test...
 169                                  */
 170                                 if (!Flag(FPOSIX) && strcmp(opnd1, "-t") == 0)
 171                                     break;
 172                                 res = (*te.eval)(&te, TO_STNZE, opnd1,
 173                                                 (char *) 0, 1);
 174                                 if (invert & 1)
 175                                         res = !res;
 176                                 return !res;
 177                         }
 178                         if ((*te.isa)(&te, TM_NOT)) {
 179                                 invert++;
 180                         } else
 181                                 break;
 182                 }
 183                 te.pos.wp = owp + 1;
 184         }
 185
 186         return test_parse(&te);
 187 }
 188
 189 /*
 190  * Generic test routines.
 191  */
 192
 193 Test_op
 194 test_isop(te, meta, s)
 195         Test_env *te;
 196         Test_meta meta;
 197         const char *s;
 198 {
 199         char sc1;
 200         const struct t_op *otab;
 201
 202         otab = meta == TM_UNOP ? u_ops : b_ops;
 203         if (*s) {
 204                 sc1 = s[1];
 205                 for (; otab->op_text[0]; otab++)
 206                         if (sc1 == otab->op_text[1]
 207                             && strcmp(s, otab->op_text) == 0
 208                             && ((te->flags & TEF_DBRACKET)
 209                                 || (otab->op_num != TO_STLT
 210                                     && otab->op_num != TO_STGT)))
 211                                 return otab->op_num;
 212         }
 213         return TO_NONOP;
 214 }
 215
 216 int
 217 test_eval(te, op, opnd1, opnd2, do_eval)
 218         Test_env *te;
 219         Test_op op;
 220         const char *opnd1;
 221         const char *opnd2;
 222         int do_eval;
 223 {
 224         int res;
 225         int not;
 226         struct stat b1, b2;
 227
 228         if (!do_eval)
 229                 return 0;
 230
 231         switch ((int) op) {
 232         /*
 233          * Unary Operators
 234          */
 235           case TO_STNZE: /* -n */
 236                 return *opnd1 != '\0';
 237           case TO_STZER: /* -z */
 238                 return *opnd1 == '\0';
 239           case TO_OPTION: /* -o */
 240                 if ((not = *opnd1 == '!'))
 241                         opnd1++;
 242                 if ((res = option(opnd1)) < 0)
 243                         res = 0;
 244                 else {
 245                         res = Flag(res);
 246                         if (not)
 247                                 res = !res;
 248                 }
 249                 return res;
 250           case TO_FILRD: /* -r */
 251                 return test_eaccess(opnd1, R_OK) == 0;
 252           case TO_FILWR: /* -w */
 253                 return test_eaccess(opnd1, W_OK) == 0;
 254           case TO_FILEX: /* -x */
 255                 return test_eaccess(opnd1, X_OK) == 0;
 256           case TO_FILAXST: /* -a */
 257                 return test_stat(opnd1, &b1) == 0;
 258           case TO_FILEXST: /* -e */
 259                 /* at&t ksh does not appear to do the /dev/fd/ thing for
 260                  * this (unless the os itself handles it)
 261                  */
 262                 return stat(opnd1, &b1) == 0;
 263           case TO_FILREG: /* -r */
 264                 return test_stat(opnd1, &b1) == 0 && S_ISREG(b1.st_mode);
 265           case TO_FILID: /* -d */
 266                 return test_stat(opnd1, &b1) == 0 && S_ISDIR(b1.st_mode);
 267           case TO_FILCDEV: /* -c */
 268 #ifdef S_ISCHR
 269                 return test_stat(opnd1, &b1) == 0 && S_ISCHR(b1.st_mode);
 270 #else
 271                 return 0;
 272 #endif
 273           case TO_FILBDEV: /* -b */
 274 #ifdef S_ISBLK
 275                 return test_stat(opnd1, &b1) == 0 && S_ISBLK(b1.st_mode);
 276 #else
 277                 return 0;
 278 #endif
 279           case TO_FILFIFO: /* -p */
 280 #ifdef S_ISFIFO
 281                 return test_stat(opnd1, &b1) == 0 && S_ISFIFO(b1.st_mode);
 282 #else
 283                 return 0;
 284 #endif
 285           case TO_FILSYM: /* -h -L */
 286 #ifdef S_ISLNK
 287                 return lstat(opnd1, &b1) == 0 && S_ISLNK(b1.st_mode);
 288 #else
 289                 return 0;
 290 #endif
 291           case TO_FILSOCK: /* -S */
 292 #ifdef S_ISSOCK
 293                 return test_stat(opnd1, &b1) == 0 && S_ISSOCK(b1.st_mode);
 294 #else
 295                 return 0;
 296 #endif
 297           case TO_FILCDF:/* -H HP context dependent files (directories) */
 298 #ifdef S_ISCDF
 299           {
 300                 /* Append a + to filename and check to see if result is a
 301                  * setuid directory.  CDF stuff in general is hookey, since
 302                  * it breaks for the following sequence: echo hi > foo+;
 303                  * mkdir foo; echo bye > foo/default; chmod u+s foo
 304                  * (foo+ refers to the file with hi in it, there is no way
 305                  * to get at the file with bye in it - please correct me if
 306                  * I'm wrong about this).
 307                  */
 308                 int len = strlen(opnd1);
 309                 char *p = str_nsave(opnd1, len + 1, ATEMP);
 310
 311                 p[len++] = '+';
 312                 p[len] = '\0';
 313                 return stat(p, &b1) == 0 && S_ISCDF(b1.st_mode);
 314           }
 315 #else
 316                 return 0;
 317 #endif
 318           case TO_FILSETU: /* -u */
 319 #ifdef S_ISUID
 320                 return test_stat(opnd1, &b1) == 0
 321                         && (b1.st_mode & S_ISUID) == S_ISUID;
 322 #else
 323                 return 0;
 324 #endif
 325           case TO_FILSETG: /* -g */
 326 #ifdef S_ISGID
 327                 return test_stat(opnd1, &b1) == 0
 328                         && (b1.st_mode & S_ISGID) == S_ISGID;
 329 #else
 330                 return 0;
 331 #endif
 332           case TO_FILSTCK: /* -k */
 333                 return test_stat(opnd1, &b1) == 0
 334                         && (b1.st_mode & S_ISVTX) == S_ISVTX;
 335           case TO_FILGZ: /* -s */
 336                 return test_stat(opnd1, &b1) == 0 && b1.st_size > 0L;
 337           case TO_FILTT: /* -t */
 338                 if (opnd1 && !bi_getn(opnd1, &res)) {
 339                         te->flags |= TEF_ERROR;
 340                         res = 0;
 341                 } else {
 342                         /* generate error if in FPOSIX mode? */
 343                         res = isatty(opnd1 ? res : 0);
 344                 }
 345                 return res;
 346           case TO_FILUID: /* -O */
 347                 return test_stat(opnd1, &b1) == 0 && b1.st_uid == ksheuid;
 348           case TO_FILGID: /* -G */
 349                 return test_stat(opnd1, &b1) == 0 && b1.st_gid == getegid();
 350         /*
 351          * Binary Operators
 352          */
 353           case TO_STEQL: /* = */
 354                 if (te->flags & TEF_DBRACKET)
 355                         return gmatch(opnd1, opnd2, FALSE);
 356                 return strcmp(opnd1, opnd2) == 0;
 357           case TO_STNEQ: /* != */
 358                 if (te->flags & TEF_DBRACKET)
 359                         return !gmatch(opnd1, opnd2, FALSE);
 360                 return strcmp(opnd1, opnd2) != 0;
 361           case TO_STLT: /* < */
 362                 return strcmp(opnd1, opnd2) < 0;
 363           case TO_STGT: /* > */
 364                 return strcmp(opnd1, opnd2) > 0;
 365           case TO_INTEQ: /* -eq */
 366           case TO_INTNE: /* -ne */
 367           case TO_INTGE: /* -ge */
 368           case TO_INTGT: /* -gt */
 369           case TO_INTLE: /* -le */
 370           case TO_INTLT: /* -lt */
 371                 {
 372                         long v1, v2;
 373
 374                         if (!evaluate(opnd1, &v1, KSH_RETURN_ERROR)
 375                             || !evaluate(opnd2, &v2, KSH_RETURN_ERROR))
 376                         {
 377                                 /* error already printed.. */
 378                                 te->flags |= TEF_ERROR;
 379                                 return 1;
 380                         }
 381                         switch ((int) op) {
 382                           case TO_INTEQ:
 383                                 return v1 == v2;
 384                           case TO_INTNE:
 385                                 return v1 != v2;
 386                           case TO_INTGE:
 387                                 return v1 >= v2;
 388                           case TO_INTGT:
 389                                 return v1 > v2;
 390                           case TO_INTLE:
 391                                 return v1 <= v2;
 392                           case TO_INTLT:
 393                                 return v1 < v2;
 394                         }
 395                 }
 396           case TO_FILNT: /* -nt */
 397                 {
 398                         int s2;
 399                         /* ksh88/ksh93 succeed if file2 can't be stated
 400                          * (subtly different from `does not exist').
 401                          */
 402                         return stat(opnd1, &b1) == 0
 403                                 && (((s2 = stat(opnd2, &b2)) == 0
 404                                       && b1.st_mtime > b2.st_mtime) || s2 < 0);
 405                 }
 406           case TO_FILOT: /* -ot */
 407                 {
 408                         int s1;
 409                         /* ksh88/ksh93 succeed if file1 can't be stated
 410                          * (subtly different from `does not exist').
 411                          */
 412                         return stat(opnd2, &b2) == 0
 413                                 && (((s1 = stat(opnd1, &b1)) == 0
 414                                       && b1.st_mtime < b2.st_mtime) || s1 < 0);
 415                 }
 416           case TO_FILEQ: /* -ef */
 417                 return stat (opnd1, &b1) == 0 && stat (opnd2, &b2) == 0
 418                        && b1.st_dev == b2.st_dev
 419                        && b1.st_ino == b2.st_ino;
 420         }
 421         (*te->error)(te, 0, "internal error: unknown op");
 422         return 1;
 423 }
 424
 425 /* Nasty kludge to handle Korn's bizarre /dev/fd hack */
 426 static int
 427 test_stat(pathx, statb)
 428         const char *pathx;
 429         struct stat *statb;
 430 {
 431 #if !defined(HAVE_DEV_FD)
 432         int fd;
 433
 434         if (strncmp(pathx, "/dev/fd/", 8) == 0 && getn(pathx + 8, &fd))
 435                 return fstat(fd, statb);
 436 #endif /* !HAVE_DEV_FD */
 437
 438         return stat(pathx, statb);
 439 }
 440
 441 /* Routine to handle Korn's /dev/fd hack, and to deal with X_OK on
 442  * non-directories when running as root.
 443  */
 444 static int
 445 test_eaccess(pathx, mode)
 446         const char *pathx;
 447         int mode;
 448 {
 449         int res;
 450
 451 #if !defined(HAVE_DEV_FD)
 452         int fd;
 453
 454         /* Note: doesn't handle //dev/fd, etc.. (this is ok) */
 455         if (strncmp(pathx, "/dev/fd/", 8) == 0 && getn(pathx + 8, &fd)) {
 456                 int flags;
 457
 458                 if ((flags = fcntl(fd, F_GETFL, 0)) < 0
 459                     || (mode & X_OK)
 460                     || ((mode & W_OK) && (flags & O_ACCMODE) == O_RDONLY)
 461                     || ((mode & R_OK) && (flags & O_ACCMODE) == O_WRONLY))
 462                         return -1;
 463                 return 0;
 464         }
 465 #endif /* !HAVE_DEV_FD */
 466
 467         res = eaccess(pathx, mode);
 468         /*
 469          * On most (all?) unixes, access() says everything is executable for
 470          * root - avoid this on files by using stat().
 471          */
 472         if (res == 0 && ksheuid == 0 && (mode & X_OK)) {
 473                 struct stat statb;
 474
 475                 if (stat(pathx, &statb) < 0)
 476                         res = -1;
 477                 else if (S_ISDIR(statb.st_mode))
 478                         res = 0;
 479                 else
 480                         res = (statb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH))
 481                                 ? 0 : -1;
 482         }
 483
 484         return res;
 485 }
 486
 487 int
 488 test_parse(te)
 489         Test_env *te;
 490 {
 491         int res;
 492
 493         res = test_oexpr(te, 1);
 494
 495         if (!(te->flags & TEF_ERROR) && !(*te->isa)(te, TM_END))
 496                 (*te->error)(te, 0, "unexpected operator/operand");
 497
 498         return (te->flags & TEF_ERROR) ? T_ERR_EXIT : !res;
 499 }
 500
 501 static int
 502 test_oexpr(te, do_eval)
 503         Test_env *te;
 504         int do_eval;
 505 {
 506         int res;
 507
 508         res = test_aexpr(te, do_eval);
 509         if (res)
 510                 do_eval = 0;
 511         if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_OR))
 512                 return test_oexpr(te, do_eval) || res;
 513         return res;
 514 }
 515
 516 static int
 517 test_aexpr(te, do_eval)
 518         Test_env *te;
 519         int do_eval;
 520 {
 521         int res;
 522
 523         res = test_nexpr(te, do_eval);
 524         if (!res)
 525                 do_eval = 0;
 526         if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_AND))
 527                 return test_aexpr(te, do_eval) && res;
 528         return res;
 529 }
 530
 531 static int
 532 test_nexpr(te, do_eval)
 533         Test_env *te;
 534         int do_eval;
 535 {
 536         if (!(te->flags & TEF_ERROR) && (*te->isa)(te, TM_NOT))
 537                 return !test_nexpr(te, do_eval);
 538         return test_primary(te, do_eval);
 539 }
 540
 541 static int
 542 test_primary(te, do_eval)
 543         Test_env *te;
 544         int do_eval;
 545 {
 546         const char *opnd1, *opnd2;
 547         int res;
 548         Test_op op;
 549
 550         if (te->flags & TEF_ERROR)
 551                 return 0;
 552         if ((*te->isa)(te, TM_OPAREN)) {
 553                 res = test_oexpr(te, do_eval);
 554                 if (te->flags & TEF_ERROR)
 555                         return 0;
 556                 if (!(*te->isa)(te, TM_CPAREN)) {
 557                         (*te->error)(te, 0, "missing closing paren");
 558                         return 0;
 559                 }
 560                 return res;
 561         }
 562         if ((op = (Test_op) (*te->isa)(te, TM_UNOP))) {
 563                 /* unary expression */
 564                 opnd1 = (*te->getopnd)(te, op, do_eval);
 565                 if (!opnd1) {
 566                         (*te->error)(te, -1, "missing argument");
 567                         return 0;
 568                 }
 569
 570                 return (*te->eval)(te, op, opnd1, (const char *) 0, do_eval);
 571         }
 572         opnd1 = (*te->getopnd)(te, TO_NONOP, do_eval);
 573         if (!opnd1) {
 574                 (*te->error)(te, 0, "expression expected");
 575                 return 0;
 576         }
 577         if ((op = (Test_op) (*te->isa)(te, TM_BINOP))) {
 578                 /* binary expression */
 579                 opnd2 = (*te->getopnd)(te, op, do_eval);
 580                 if (!opnd2) {
 581                         (*te->error)(te, -1, "missing second argument");
 582                         return 0;
 583                 }
 584
 585                 return (*te->eval)(te, op, opnd1, opnd2, do_eval);
 586         }
 587         if (te->flags & TEF_DBRACKET) {
 588                 (*te->error)(te, -1, "missing expression operator");
 589                 return 0;
 590         }
 591         return (*te->eval)(te, TO_STNZE, opnd1, (const char *) 0, do_eval);
 592 }
 593
 594 /*
 595  * Plain test (test and [ .. ]) specific routines.
 596  */
 597
 598 /* Test if the current token is a whatever.  Accepts the current token if
 599  * it is.  Returns 0 if it is not, non-zero if it is (in the case of
 600  * TM_UNOP and TM_BINOP, the returned value is a Test_op).
 601  */
 602 static int
 603 ptest_isa(te, meta)
 604         Test_env *te;
 605         Test_meta meta;
 606 {
 607         /* Order important - indexed by Test_meta values */
 608         static const char *const tokens[] = {
 609                                 "-o", "-a", "!", "(", ")"
 610                         };
 611         int ret;
 612
 613         if (te->pos.wp >= te->wp_end)
 614                 return meta == TM_END;
 615
 616         if (meta == TM_UNOP || meta == TM_BINOP)
 617                 ret = (int) test_isop(te, meta, *te->pos.wp);
 618         else if (meta == TM_END)
 619                 ret = 0;
 620         else
 621                 ret = strcmp(*te->pos.wp, tokens[(int) meta]) == 0;
 622
 623         /* Accept the token? */
 624         if (ret)
 625                 te->pos.wp++;
 626
 627         return ret;
 628 }
 629
 630 static const char *
 631 ptest_getopnd(te, op, do_eval)
 632         Test_env *te;
 633         Test_op op;
 634         int do_eval;
 635 {
 636         if (te->pos.wp >= te->wp_end)
 637                 return op == TO_FILTT ? "1" : (const char *) 0;
 638         return *te->pos.wp++;
 639 }
 640
 641 static int
 642 ptest_eval(te, op, opnd1, opnd2, do_eval)
 643         Test_env *te;
 644         Test_op op;
 645         const char *opnd1;
 646         const char *opnd2;
 647         int do_eval;
 648 {
 649         return test_eval(te, op, opnd1, opnd2, do_eval);
 650 }
 651
 652 static void
 653 ptest_error(te, offset, msg)
 654         Test_env *te;
 655         int offset;
 656         const char *msg;
 657 {
 658         const char *op = te->pos.wp + offset >= te->wp_end ?
 659                                 (const char *) 0 : te->pos.wp[offset];
 660
 661         te->flags |= TEF_ERROR;
 662         if (op)
 663                 bi_errorf("%s: %s", op, msg);
 664         else
 665                 bi_errorf("%s", msg);
 666 }