int main(int argc, char **argv) { int res; char *p; if ((p = strrchr(argv[0], '/')) == NULL) p = argv[0]; else p++; if (strcmp(p, "[") == 0) { if (strcmp(argv[--argc], "]") != 0) error("missing ]"); argv[argc] = NULL; } /* no expression => false */ if (--argc <= 0) return 1; nargc = argc; t_wp = &argv[1]; parenlevel = 0; if (nargc == 4 && strcmp(*t_wp, "!") == 0) { /* Things like ! "" -o x do not fit in the normal grammar. */ --nargc; ++t_wp; res = oexpr(t_lex(*t_wp)); } else res = !oexpr(t_lex(*t_wp)); if (--nargc > 0) syntax(*t_wp, "unexpected operator"); return res; }
int main(int argc, char **argv) { gid_t egid, gid; uid_t euid, uid; int res; char *p; if ((p = strrchr(argv[0], '/')) == NULL) p = argv[0]; else p++; if (strcmp(p, "[") == 0) { if (strcmp(argv[--argc], "]") != 0) error("missing ]"); argv[argc] = NULL; } /* no expression => false */ if (--argc <= 0) return 1; #ifndef SHELL setlocale(LC_CTYPE, ""); #endif /* XXX work around the absence of an eaccess(2) syscall */ egid = getegid(); euid = geteuid(); gid = getgid(); uid = getuid(); setregid(egid, gid); setreuid(euid, uid); nargc = argc; t_wp = &argv[1]; parenlevel = 0; if (nargc == 4 && strcmp(*t_wp, "!") == 0) { /* Things like ! "" -o x do not fit in the normal grammar. */ --nargc; ++t_wp; res = oexpr(t_lex(*t_wp)); } else res = !oexpr(t_lex(*t_wp)); if (--nargc > 0) syntax(*t_wp, "unexpected operator"); setregid(gid, egid); setreuid(uid, euid); return res; }
static arith_t primary(enum token n) { arith_t res; if (n == EOI) { syntax(NULL, "argument expected"); } if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); default: return filstat(*t_wp, n); } } if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
int bb_test(int argc, char **argv) { int res; if (LONE_CHAR(argv[0], '[')) { --argc; if (NOT_LONE_CHAR(argv[argc], ']')) { bb_error_msg("missing ]"); return 2; } argv[argc] = NULL; } else if (strcmp(argv[0], "[[") == 0) { --argc; if (strcmp(argv[argc], "]]")) { bb_error_msg("missing ]]"); return 2; } argv[argc] = NULL; } res = setjmp(leaving); if (res) return res; /* resetting ngroups is probably unnecessary. it will * force a new call to getgroups(), which prevents using * group data fetched during a previous call. but the * only way the group data could be stale is if there's * been an intervening call to setgroups(), and this * isn't likely in the case of a shell. paranoia * prevails... */ ngroups = 0; /* Implement special cases from POSIX.2, section 4.62.4 */ if (argc == 1) return 1; if (argc == 2) return *argv[1] == '\0'; //assert(argc); if (LONE_CHAR(argv[1], '!')) { bool _off; if (argc == 3) return *argv[2] != '\0'; _off = argc - 4; t_lex(argv[2 + _off]); if (t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1 + _off]; return binop() == 0; } } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) { bb_error_msg("%s: unknown operand", *t_wp); return 2; } return res; }
static arith_t primary(enum token n) { arith_t res; if (n == EOI) { syntax(NULL, "argument expected"); } if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); if (n == STREZ) return t_wp[0][0] == '\0'; if (n == STRNZ) return t_wp[0][0] != '\0'; if (n == FILTT) return isatty(getn(*t_wp)); return filstat(*t_wp, n); } t_lex(t_wp[1]); if (t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return t_wp[0][0] != '\0'; }
int testcmd(int argc, char **argv) { const struct t_op *op; enum token n; int res = 1; if (*argv[0] == '[') { if (*argv[--argc] != ']') error("missing ]"); argv[argc] = NULL; } t_wp_op = NULL; recheck: argv++; argc--; if (argc < 1) return res; /* * POSIX prescriptions: he who wrote this deserves the Nobel * peace prize. */ switch (argc) { case 3: op = getop(argv[1]); if (op && op->op_type == BINOP) { n = OPERAND; goto eval; } /* fall through */ case 4: if (!strcmp(argv[0], "(") && !strcmp(argv[argc - 1], ")")) { argv[--argc] = NULL; argv++; argc--; } else if (!strcmp(argv[0], "!")) { res = 0; goto recheck; } } n = t_lex(argv); eval: t_wp = argv; res ^= oexpr(n); argv = t_wp; if (argv[0] != NULL && argv[1] != NULL) syntax(argv[0], "unexpected operator"); return res; }
/* The code below starts the part that still needs reworking for the * new geometry based tokens/logic */ static int primary(enum token n, struct exists_data *ed) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { ed->t_wp_op = NULL; if ((nn = t_lex(*++(ed->t_wp), ed)) == RPAREN) return 0; /* missing expression */ res = oexpr(nn, ed); if (t_lex(*++(ed->t_wp), ed) != RPAREN) { bu_vls_printf(ed->message , "closing paren expected"); return 0; } return res; } if (ed->t_wp_op && ed->t_wp_op->op_type == UNOP) { /* unary expression */ if (!ed->no_op) { if (*++(ed->t_wp) == NULL) { bu_vls_printf(ed->message , "argument expected"); return 0; } } switch (n) { case OCOMB: bu_log("comb case"); /*return is_comb();*/ case OEXIST: return db_object_exists(ed); /*return db_lookup();*/ case ONULL: bu_log("null case"); /*return is_null();*/ case ONNULL: /* default case */ return db_object_exists_and_non_null(ed); case OPRIM: bu_log("primitive case"); /*return is_prim();*/ case OBVOL: bu_log("bounding volume case"); /*return has_vol();*/ default: /* not reached */ return 0; } } if (t_lex(ed->t_wp[1], ed), ed->t_wp_op && ed->t_wp_op->op_type == BINOP) { return binop(ed); } return 0; }
static arith_t oexpr(enum token n) { arith_t res; res = aexpr(n); if (t_lex(*++t_wp) == BOR) { return oexpr(t_lex(*++t_wp)) || res; } t_wp--; return res; }
static int oexpr(shinstance *psh, enum token n) { int res; res = aexpr(psh, n); if (t_lex(psh, *++psh->t_wp) == BOR) return oexpr(psh, t_lex(psh, *++psh->t_wp)) || res; psh->t_wp--; return res; }
static int oexpr(enum token n) { int res; res = aexpr(n); if (t_lex(*++t_wp) == BOR) return oexpr(t_lex(*++t_wp)) || res; t_wp--; return res; }
/** * Checks for the existence of a specified object. */ int ged_exists(struct ged *gedp, int argc, const char *argv_orig[]) { /* struct directory *dp;*/ static const char *usage = "object"; struct exists_data ed; struct bu_vls message = BU_VLS_INIT_ZERO; int result; char **argv = bu_dup_argv(argc, argv_orig); GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR); GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR); /* initialize result */ bu_vls_trunc(gedp->ged_result_str, 0); /* must be wanting help */ if (argc == 1) { bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage); return GED_HELP; } /* if (argc != 2) { bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage); return GED_ERROR; } */ ed.t_wp = &argv[1]; ed.gedp = gedp; ed.t_wp_op = NULL; ed.message = &message; result = oexpr(t_lex(*(ed.t_wp), &ed), &ed); if (result) bu_vls_printf(gedp->ged_result_str, "1"); else bu_vls_printf(gedp->ged_result_str, "0"); if (bu_vls_strlen(ed.message) > 0) { bu_vls_printf(gedp->ged_result_str, "%s", bu_vls_addr(ed.message)); bu_vls_free(&message); return GED_ERROR; } bu_vls_free(&message); if (*(ed.t_wp) != NULL && *++(ed.t_wp) != NULL) { return GED_ERROR; } else { return GED_OK; } }
static int oexpr(enum token n) { int res; res = aexpr(n); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) == BOR) return oexpr(t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) || res; t_wp--; nargc++; return res; }
int main(int argc, char *argv[]) { int res; if (strcmp(argv[0], "[") == 0) { if (strcmp(argv[--argc], "]")) errx(2, "missing ]"); argv[argc] = NULL; } /* Implement special cases from POSIX.2, section 4.62.4 */ switch (argc) { case 1: return 1; case 2: return (*argv[1] == '\0'); case 3: if (argv[1][0] == '!' && argv[1][1] == '\0') { return !(*argv[2] == '\0'); } break; case 4: if (argv[1][0] != '!' || argv[1][1] != '\0') { if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1]; return (binop() == 0); } } break; case 5: if (argv[1][0] == '!' && argv[1][1] == '\0') { if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[2]; return !(binop() == 0); } } break; } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) syntax(*t_wp, "unknown operand"); return res; }
extern int test_main(int argc, char** argv) { int res; if (strcmp(applet_name, "[") == 0) { if (strcmp(argv[--argc], "]")) error_msg_and_die("missing ]"); argv[argc] = NULL; } /* Implement special cases from POSIX.2, section 4.62.4 */ switch (argc) { case 1: exit( 1); case 2: exit (*argv[1] == '\0'); case 3: if (argv[1][0] == '!' && argv[1][1] == '\0') { exit (!(*argv[2] == '\0')); } break; case 4: if (argv[1][0] != '!' || argv[1][1] != '\0') { if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1]; exit (binop() == 0); } } break; case 5: if (argv[1][0] == '!' && argv[1][1] == '\0') { if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[2]; exit (!(binop() == 0)); } } break; } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) syntax(*t_wp, "unknown operand"); return( res); }
static int oexpr(enum token n, struct exists_data *ed) { int res; res = aexpr(n, ed); if (*(ed->t_wp) == NULL) return res; if (t_lex(*++(ed->t_wp), ed) == BOR) { ed->t_wp_op = NULL; return oexpr(t_lex(*++(ed->t_wp), ed), ed) || res; } (ed->t_wp)--; return res; }
static int oexpr(enum token n) { int res; res = aexpr(n); if (res == -42 || *t_wp == NULL) return res; if (t_lex(*++t_wp) == BOR) { int res2 = oexpr(t_lex(*++t_wp)); return res2 != -42 ? res2 || res : res2; } t_wp--; return res; }
static int primary(enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { if ((nn = t_lex(++t_wp)) == RPAREN) return 0; /* missing expression */ res = oexpr(nn); if (t_lex(++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); #ifdef HAVE_FACCESSAT case FILRD: return test_file_access(*t_wp, R_OK); case FILWR: return test_file_access(*t_wp, W_OK); case FILEX: return test_file_access(*t_wp, X_OK); #endif default: return filstat(*t_wp, n); } } if (t_lex(t_wp + 1), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
static int primary(enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { parenlevel++; if ((nn = t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL)) == RPAREN) { parenlevel--; return 0; /* missing expression */ } res = oexpr(nn); if (t_lex(nargc > 0 ? (--nargc, *++t_wp) : NULL) != RPAREN) syntax(NULL, "closing paren expected"); parenlevel--; return res; } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (--nargc == 0) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*++t_wp) == 0; case STRNZ: return strlen(*++t_wp) != 0; case FILTT: return isatty(getn(*++t_wp)); default: return filstat(*++t_wp, n); } } if (t_lex(nargc > 0 ? t_wp[1] : NULL), t_wp_op && t_wp_op->op_type == BINOP) { return binop(); } return strlen(*t_wp) > 0; }
static int primary(enum token n) { int res; if (n == EOI) syntax(NULL, "argument expected"); if (n == LPAREN) { res = oexpr(t_lex(*++t_wp)); if (t_lex(*++t_wp) != RPAREN) syntax(NULL, "closing paren expected"); return res; } /* * We need this, if not binary operations with more than 4 * arguments will always fall into unary. */ if(t_lex_type(t_wp[1]) == BINOP) { t_lex(t_wp[1]); if (t_wp_op && t_wp_op->op_type == BINOP) return binop(); } if (t_wp_op && t_wp_op->op_type == UNOP) { /* unary expression */ if (*++t_wp == NULL) syntax(t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*t_wp) == 0; case STRNZ: return strlen(*t_wp) != 0; case FILTT: return isatty(getn(*t_wp)); default: return filstat(*t_wp, n); } } return strlen(*t_wp) > 0; }
int testcmd(int argc, char **argv) { int res; if (strcmp(argv[0], "[") == 0) { if (strcmp(argv[--argc], "]")) error("missing ]"); argv[argc] = NULL; } if (argc < 2) return 1; t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) syntax(*t_wp, "unexpected operator"); return res; }
static int primary(shinstance *psh, enum token n) { enum token nn; int res; if (n == EOI) return 0; /* missing expression */ if (n == LPAREN) { if ((nn = t_lex(psh, *++psh->t_wp)) == RPAREN) return 0; /* missing expression */ res = oexpr(psh, nn); if (t_lex(psh, *++psh->t_wp) != RPAREN) syntax(psh, NULL, "closing paren expected"); return res; } if (psh->t_wp_op && psh->t_wp_op->op_type == UNOP) { /* unary expression */ if (*++psh->t_wp == NULL) syntax(psh, psh->t_wp_op->op_text, "argument expected"); switch (n) { case STREZ: return strlen(*psh->t_wp) == 0; case STRNZ: return strlen(*psh->t_wp) != 0; case FILTT: return shfile_isatty(&psh->fdtab, getn(psh, *psh->t_wp)); default: return filstat(psh, *psh->t_wp, n); } } if (t_lex(psh, psh->t_wp[1]), psh->t_wp_op && psh->t_wp_op->op_type == BINOP) { return binop(psh); } return strlen(*psh->t_wp) > 0; }
int testcmd(shinstance *psh, int argc, char **argv) { int res; if (strcmp(argv[0], "[") == 0) { if (strcmp(argv[--argc], "]")) error(psh, "missing ]"); argv[argc] = NULL; } if (argc < 2) return 1; psh->t_wp_op = NULL; psh->t_wp = &argv[1]; res = !oexpr(psh, t_lex(psh, *psh->t_wp)); if (*psh->t_wp != NULL && *++psh->t_wp != NULL) syntax(psh, *psh->t_wp, "unexpected operator"); return res; }
int kmk_builtin_test(int argc, char **argv, char **envp, char ***ppapszArgvSpawn) { int res; char **argv_spawn; int i; g_progname = argv[0]; /* look for the '--', '--help' and '--version'. */ argv_spawn = NULL; for (i = 1; i < argc; i++) { if ( argv[i][0] == '-' && argv[i][1] == '-') { if (argv[i][2] == '\0') { argc = i; argv[i] = NULL; /* skip blank arguments (happens inside kmk) */ while (argv[++i]) { const char *psz = argv[i]; while (isspace(*psz)) psz++; if (*psz) break; } argv_spawn = &argv[i]; break; } if (!strcmp(argv[i], "--help")) return usage(argv[0]); if (!strcmp(argv[i], "--version")) return kbuild_version(argv[0]); } } /* are we '['? then check for ']'. */ if (strcmp(g_progname, "[") == 0) { /** @todo should skip the path in g_progname */ if (strcmp(argv[--argc], "]")) return errx(1, "missing ]"); argv[argc] = NULL; } /* evaluate the expression */ if (argc < 2) res = 1; else { t_wp = &argv[1]; res = oexpr(t_lex(*t_wp)); if (res != -42 && *t_wp != NULL && *++t_wp != NULL) res = syntax(*t_wp, "unexpected operator"); if (res == -42) return 1; /* don't mix syntax errors with the argv_spawn ignore */ res = !res; } /* anything to execute on success? */ if (argv_spawn) { if (res != 0 || !argv_spawn[0]) res = 0; /* ignored */ else { #ifdef kmk_builtin_test /* try exec the specified process */ # if defined(_MSC_VER) res = _spawnvp(_P_WAIT, argv_spawn[0], argv_spawn); if (res == -1) res = err(1, "_spawnvp(_P_WAIT,%s,..)", argv_spawn[0]); # else execvp(argv_spawn[0], argv_spawn); res = err(1, "execvp(%s,..)", argv_spawn[0]); # endif #else /* in kmk */ /* let job.c spawn the process, make a job.c style argv_spawn copy. */ char *buf, *cur, **argv_new; size_t sz = 0; int argc_new = 0; while (argv_spawn[argc_new]) { size_t len = strlen(argv_spawn[argc_new]) + 1; sz += (len + sizeof(void *) - 1) & ~(sizeof(void *) - 1); argc_new++; } argv_new = xmalloc((argc_new + 1) * sizeof(char *)); buf = cur = xmalloc(sz); for (i = 0; i < argc_new; i++) { size_t len = strlen(argv_spawn[i]) + 1; argv_new[i] = memcpy(cur, argv_spawn[i], len); cur += (len + sizeof(void *) - 1) & ~(sizeof(void *) - 1); } argv_new[i] = NULL; *ppapszArgvSpawn = argv_new; res = 0; #endif /* in kmk */ } } return res; }
int ri_inter (void) { /* This is the shortest version of the interpreter, containing only those RASL operators which * are produced by the REFAL compiler. */ /* July, 27, 1985. D.T. */ /* Some macros have been expanded because the PC compiler can't handle too many macros. (its stack overflows.) * DT July 1 1986. */ /* Some other macros have been replaced by functions to reduce the size of object module. March 7 1987. DT. */ register short n; int error; char c, ins = 0; long mdig, bifnum; char *arg; /* short m;*/ error = 0; restart: while (error == 0) { ins = *p; # if MDEBUG if (dump_toggle) printf ("%lx: %d\n", p, ins); # endif switch (ins) { case ACT1: ASGN_CHARP (++p, arg); p += sizeof (char *); act1 (arg); curk ++; break; case BL: p++; bl; break; case BLR: p++; ri_blr (); break; case BR: p++; br; break; case CL: p++; cl; break; case SYM: c = (unsigned char) * ++p; p++; sym (c); break; case SYMR: c = (unsigned char) * ++p; p++; symr (c); break; case EMP: p++; emp; break; case EST: curk --; est; p = break0; break; case MULE: /* n = * ++p; ++p; mule ((int) n); */ ASGN_LONG (++p, mdig); p += sizeof (long); mule (mdig); break; case MULS: /*n = * ++p; muls (n); p++; break;*/ ASGN_LONG (++p, mdig); p += sizeof (long); muls (mdig); break; case PLEN: p++; plen; p++; break; case PLENS: p++; plens; break; case PLENP: p++; plenp; break; case PS: ++p; ps; break; case PSR: ++p; psr; break; case OEXP: n = (unsigned char) * ++p; ++p; oexp (n); break; case OEXPR: n = (unsigned char) * ++p; ++p; oexpr (n); break; case OVSYM: n = (unsigned char) * ++p; ovsym (n); ++p; break; case OVSYMR: n = (unsigned char) * ++p; ovsymr (n); p++; break; case TERM: p++; term; break; case TERMR: p++; termr; break; case RDY: n = (unsigned char) * ++p; ++p; rdy (n); break; case SETB: /* n = (unsigned char) * ++p; m = (unsigned char) * ++p; ++p; setb (n,m); break; */ { long l_n, l_m; ASGN_LONG (++p, l_n); p += sizeof (long); ASGN_LONG (p, l_m); p += sizeof (long); setb (l_n, l_m); } break; case LEN: p++; len; break; case LENS: c = (unsigned char) *++p; p++; lens (c); break; case LENP: ++p; lenp; break; case SYMS: n = (unsigned char) * ++p; p++; syms (n); break; case SYMSR: n = (unsigned char) * ++p; p++; symsr (n) break; case TEXT: n = (unsigned char) * ++p; p++; text (n); break; case NS: c = (unsigned char) * ++p; ++p; ns (c); break; case TPLE: /* n = * ++p; p++; tple (n); break; */ ASGN_LONG (++p, mdig); p += sizeof (long); tple (mdig); break; case TPLS: /* n = * ++p; p++; tpls (n); break; */ ASGN_LONG (++p, mdig); p += sizeof (long); tpls (mdig); break; case TRAN: ASGN_CHARP (++p, arg); p += sizeof (char *); tran (arg); break; case VSYM: p++; vsym; break; case VSYMR: ++p; vsymr; break; case OUTEST: curk --; out (2); est; p = break0; break; case ECOND: if (tel - te + nel + 100 >= size_table_element) { if (fp_debugInfo != NULL) ri_print_error_code(fp_debugInfo,13); ri_error (13); } ASGN_CHARP (++p, arg); b = st[sp].b1; b = st[sp].b1; act1 (arg); tel += (teoff = nel); est; p = break0; break; case POPVF: ++p; tel -= teoff; nel = teoff + 3; sp = stoff-1; teoff = st[sp].nel; stoff = (long) st[sp].b2; break; case PUSHVF: if (sp + 20 >= size_local_stack) { if (fp_debugInfo != NULL) ri_print_error_code(fp_debugInfo,14); ri_error (14); } ++p; b = tbel (2) -> prec; blr; pushst (b->prec,b,NULL,NULL); sp++; pushst (b,stoff,teoff, IMP_); b = b -> prec; stoff = sp + 1; break; case STLEN: ++p; sp = stoff; break; case CSYM: ASGN_CHARP (++p, arg); p += sizeof (char *); csym (arg); break; case CSYMR: ASGN_CHARP (++p, arg); p += sizeof (char *); csymr (arg); break; case NSYM: ASGN_LONG (++p, mdig); p += sizeof (long); nsym (mdig); break; case NSYMR: ASGN_LONG (++p, mdig); p += sizeof (long); nsymr (mdig); break; case NCS: ASGN_CHARP (++p, arg); p += sizeof (char *); ncs (arg); break; case NNS: ASGN_LONG (++p, mdig); p += sizeof (long); nns (mdig); break; /* builtin functions: R.N. - 20 Jul 85 */ case BUILT_IN: /* a call to a built in function no arguments. */ curk --; ASGN_LONG (p+1, bifnum); error = ri_bif (bifnum,NULL); p = break0; break; /* builtin functions with one argument: D.T. - July 27, 1985. */ case BUILT_IN1: /* a call to a function with one argument. */ /* Arguments are stored before function address. */ curk --; ASGN_CHARP(++p, arg); ASGN_LONG (p + (sizeof (char *)), bifnum); error = ri_bif (bifnum, arg); p = break0; break; default: ri_default (ins, &error); break; } } if (error != 0) { fprintf (stderr,"RASL instruction: %4d at address: %lx\n", *p, (unsigned long) p); if (fp_debugInfo != NULL) fprintf (fp_debugInfo,"RASL instruction: %4d at address: %lx\n", *p, (unsigned long) p); ri_error(4); } return 0; }
int bb_test(int argc, char **argv) { int res; if (strcmp(argv[0], "[") == 0) { if (strcmp(argv[--argc], "]")) { bb_error_msg("missing ]"); return 2; } argv[argc] = NULL; } else if (strcmp(argv[0], "[[") == 0) { if (strcmp(argv[--argc], "]]")) { bb_error_msg("missing ]]"); return 2; } argv[argc] = NULL; } res = setjmp(leaving); if (res) return res; /* resetting ngroups is probably unnecessary. it will * force a new call to getgroups(), which prevents using * group data fetched during a previous call. but the * only way the group data could be stale is if there's * been an intervening call to setgroups(), and this * isn't likely in the case of a shell. paranoia * prevails... */ ngroups = 0; /* Implement special cases from POSIX.2, section 4.62.4 */ switch (argc) { case 1: return 1; case 2: return *argv[1] == '\0'; case 3: if (argv[1][0] == '!' && argv[1][1] == '\0') { return *argv[2] != '\0'; } break; case 4: if (argv[1][0] != '!' || argv[1][1] != '\0') { if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[1]; return binop() == 0; } } break; case 5: if (argv[1][0] == '!' && argv[1][1] == '\0') { if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) { t_wp = &argv[2]; return binop() != 0; } } break; } t_wp = &argv[1]; res = !oexpr(t_lex(*t_wp)); if (*t_wp != NULL && *++t_wp != NULL) { bb_error_msg("%s: unknown operand", *t_wp); return 2; } return res; }