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;
}
