Apple-2gs-SW/hush
1
0
Fork 0
mirror of https://github.com/sheumann/hush.git synced 2024-08-20 19:29:02 +00:00
Code Issues Projects Releases Wiki Activity

Run through indent, fix comments

Browse Source
This commit is contained in:
Glenn L McGrath 2002-08-23 06:05:11 +00:00
parent 03195fc16f
commit acfc0d872e
1 changed files with 103 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

238
coreutils/test.c
View File

@ -110,47 +110,49 @@ enum token_types {
static const struct t_op { static const struct t_op {
const char *op_text; const char *op_text;
short op_num, op_type; short op_num, op_type;
} ops [] = { } ops[] = {
{"-r", FILRD, UNOP}, {
{"-w", FILWR, UNOP}, "-r", FILRD, UNOP}, {
{"-x", FILEX, UNOP}, "-w", FILWR, UNOP}, {
{"-e", FILEXIST,UNOP}, "-x", FILEX, UNOP}, {
{"-f", FILREG, UNOP}, "-e", FILEXIST, UNOP}, {
{"-d", FILDIR, UNOP}, "-f", FILREG, UNOP}, {
{"-c", FILCDEV,UNOP}, "-d", FILDIR, UNOP}, {
{"-b", FILBDEV,UNOP}, "-c", FILCDEV, UNOP}, {
{"-p", FILFIFO,UNOP}, "-b", FILBDEV, UNOP}, {
{"-u", FILSUID,UNOP}, "-p", FILFIFO, UNOP}, {
{"-g", FILSGID,UNOP}, "-u", FILSUID, UNOP}, {
{"-k", FILSTCK,UNOP}, "-g", FILSGID, UNOP}, {
{"-s", FILGZ, UNOP}, "-k", FILSTCK, UNOP}, {
{"-t", FILTT, UNOP}, "-s", FILGZ, UNOP}, {
{"-z", STREZ, UNOP}, "-t", FILTT, UNOP}, {
{"-n", STRNZ, UNOP}, "-z", STREZ, UNOP}, {
{"-h", FILSYM, UNOP}, /* for backwards compat */ "-n", STRNZ, UNOP}, {
{"-O", FILUID, UNOP}, "-h", FILSYM, UNOP}, /* for backwards compat */
{"-G", FILGID, UNOP}, {
{"-L", FILSYM, UNOP}, "-O", FILUID, UNOP}, {
{"-S", FILSOCK,UNOP}, "-G", FILGID, UNOP}, {
{"=", STREQ, BINOP}, "-L", FILSYM, UNOP}, {
{"!=", STRNE, BINOP}, "-S", FILSOCK, UNOP}, {
{"<", STRLT, BINOP}, "=", STREQ, BINOP}, {
{">", STRGT, BINOP}, "!=", STRNE, BINOP}, {
{"-eq", INTEQ, BINOP}, "<", STRLT, BINOP}, {
{"-ne", INTNE, BINOP}, ">", STRGT, BINOP}, {
{"-ge", INTGE, BINOP}, "-eq", INTEQ, BINOP}, {
{"-gt", INTGT, BINOP}, "-ne", INTNE, BINOP}, {
{"-le", INTLE, BINOP}, "-ge", INTGE, BINOP}, {
{"-lt", INTLT, BINOP}, "-gt", INTGT, BINOP}, {
{"-nt", FILNT, BINOP}, "-le", INTLE, BINOP}, {
{"-ot", FILOT, BINOP}, "-lt", INTLT, BINOP}, {
{"-ef", FILEQ, BINOP}, "-nt", FILNT, BINOP}, {
{"!", UNOT, BUNOP}, "-ot", FILOT, BINOP}, {
{"-a", BAND, BBINOP}, "-ef", FILEQ, BINOP}, {
{"-o", BOR, BBINOP}, "!", UNOT, BUNOP}, {
{"(", LPAREN, PAREN}, "-a", BAND, BBINOP}, {
{")", RPAREN, PAREN}, "-o", BOR, BBINOP}, {
{0, 0, 0} "(", LPAREN, PAREN}, {
")", RPAREN, PAREN}, {
0, 0, 0}
}; };
static char **t_wp; static char **t_wp;
@ -158,7 +160,7 @@ static struct t_op const *t_wp_op;
static gid_t *group_array = NULL; static gid_t *group_array = NULL;
static int ngroups; static int ngroups;
static enum token t_lex(char* s); static enum token t_lex(char *s);
static int oexpr(enum token n); static int oexpr(enum token n);
static int aexpr(enum token n); static int aexpr(enum token n);
static int nexpr(enum token n); static int nexpr(enum token n);
@ -174,10 +176,9 @@ static int test_eaccess(char *path, int mode);
static int is_a_group_member(gid_t gid); static int is_a_group_member(gid_t gid);
static void initialize_group_array(void); static void initialize_group_array(void);
extern int extern int test_main(int argc, char **argv)
test_main(int argc, char** argv)
{ {
int res; int res;
if (strcmp(applet_name, "[") == 0) { if (strcmp(applet_name, "[") == 0) {
if (strcmp(argv[--argc], "]")) if (strcmp(argv[--argc], "]"))
@ -187,29 +188,27 @@ test_main(int argc, char** argv)
/* Implement special cases from POSIX.2, section 4.62.4 */ /* Implement special cases from POSIX.2, section 4.62.4 */
switch (argc) { switch (argc) {
case 1: case 1:
exit( 1); exit(1);
case 2: case 2:
exit (*argv[1] == '\0'); exit(*argv[1] == '\0');
case 3: case 3:
if (argv[1][0] == '!' && argv[1][1] == '\0') { if (argv[1][0] == '!' && argv[1][1] == '\0') {
exit (!(*argv[2] == '\0')); exit(!(*argv[2] == '\0'));
} }
break; break;
case 4: case 4:
if (argv[1][0] != '!' || argv[1][1] != '\0') { if (argv[1][0] != '!' || argv[1][1] != '\0') {
if (t_lex(argv[2]), if (t_lex(argv[2]), t_wp_op && t_wp_op->op_type == BINOP) {
t_wp_op && t_wp_op->op_type == BINOP) {
t_wp = &argv[1]; t_wp = &argv[1];
exit (binop() == 0); exit(binop() == 0);
} }
} }
break; break;
case 5: case 5:
if (argv[1][0] == '!' && argv[1][1] == '\0') { if (argv[1][0] == '!' && argv[1][1] == '\0') {
if (t_lex(argv[3]), if (t_lex(argv[3]), t_wp_op && t_wp_op->op_type == BINOP) {
t_wp_op && t_wp_op->op_type == BINOP) {
t_wp = &argv[2]; t_wp = &argv[2];
exit (!(binop() == 0)); exit(!(binop() == 0));
} }
} }
break; break;
@ -221,36 +220,31 @@ test_main(int argc, char** argv)
if (*t_wp != NULL && *++t_wp != NULL) if (*t_wp != NULL && *++t_wp != NULL)
syntax(*t_wp, "unknown operand"); syntax(*t_wp, "unknown operand");
return( res); return (res);
} }
static void static void syntax(const char *op, const char *msg)
syntax(op, msg)
const char *op;
const char *msg;
{ {
if (op && *op) if (op && *op) {
error_msg_and_die("%s: %s", op, msg); error_msg_and_die("%s: %s", op, msg);
else } else {
error_msg_and_die("%s", msg); error_msg_and_die("%s", msg);
}
} }
static int static int oexpr(enum token n)
oexpr(n)
enum token n;
{ {
int res; int res;
res = aexpr(n); res = aexpr(n);
if (t_lex(*++t_wp) == BOR) if (t_lex(*++t_wp) == BOR) {
return oexpr(t_lex(*++t_wp)) || res; return oexpr(t_lex(*++t_wp)) || res;
}
t_wp--; t_wp--;
return res; return res;
} }
static int static int aexpr(enum token n)
aexpr(n)
enum token n;
{ {
int res; int res;
@ -261,23 +255,20 @@ aexpr(n)
return res; return res;
} }
static int static int nexpr(enum token n)
nexpr(n)
enum token n; /* token */
{ {
if (n == UNOT) if (n == UNOT)
return !nexpr(t_lex(*++t_wp)); return !nexpr(t_lex(*++t_wp));
return primary(n); return primary(n);
} }
static int static int primary(enum token n)
primary(n)
enum token n;
{ {
int res; int res;
if (n == EOI) if (n == EOI) {
syntax(NULL, "argument expected"); syntax(NULL, "argument expected");
}
if (n == LPAREN) { if (n == LPAREN) {
res = oexpr(t_lex(*++t_wp)); res = oexpr(t_lex(*++t_wp));
if (t_lex(*++t_wp) != RPAREN) if (t_lex(*++t_wp) != RPAREN)
@ -302,13 +293,12 @@ primary(n)
if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) { if (t_lex(t_wp[1]), t_wp_op && t_wp_op->op_type == BINOP) {
return binop(); return binop();
} }
return strlen(*t_wp) > 0; return strlen(*t_wp) > 0;
} }
static int static int binop()
binop()
{ {
const char *opnd1, *opnd2; const char *opnd1, *opnd2;
struct t_op const *op; struct t_op const *op;
@ -317,9 +307,9 @@ binop()
(void) t_lex(*++t_wp); (void) t_lex(*++t_wp);
op = t_wp_op; op = t_wp_op;
if ((opnd2 = *++t_wp) == (char *)0) if ((opnd2 = *++t_wp) == (char *) 0)
syntax(op->op_text, "argument expected"); syntax(op->op_text, "argument expected");
switch (op->op_num) { switch (op->op_num) {
case STREQ: case STREQ:
return strcmp(opnd1, opnd2) == 0; return strcmp(opnd1, opnd2) == 0;
@ -342,20 +332,17 @@ binop()
case INTLT: case INTLT:
return getn(opnd1) < getn(opnd2); return getn(opnd1) < getn(opnd2);
case FILNT: case FILNT:
return newerf (opnd1, opnd2); return newerf(opnd1, opnd2);
case FILOT: case FILOT:
return olderf (opnd1, opnd2); return olderf(opnd1, opnd2);
case FILEQ: case FILEQ:
return equalf (opnd1, opnd2); return equalf(opnd1, opnd2);
} }
/* NOTREACHED */ /* NOTREACHED */
return 1; return 1;
} }
static int static int filstat(char *nm, enum token mode)
filstat(nm, mode)
char *nm;
enum token mode;
{ {
struct stat s; struct stat s;
unsigned int i; unsigned int i;
@ -370,7 +357,7 @@ filstat(nm, mode)
return 0; return 0;
} }
if (stat(nm, &s) != 0) if (stat(nm, &s) != 0)
return 0; return 0;
switch (mode) { switch (mode) {
@ -427,21 +414,19 @@ filstat(nm, mode)
return 1; return 1;
} }
filetype: filetype:
return ((s.st_mode & S_IFMT) == i); return ((s.st_mode & S_IFMT) == i);
filebit: filebit:
return ((s.st_mode & i) != 0); return ((s.st_mode & i) != 0);
} }
static enum token static enum token t_lex(char *s)
t_lex(s)
char *s;
{ {
struct t_op const *op = ops; struct t_op const *op = ops;
if (s == 0) { if (s == 0) {
t_wp_op = (struct t_op *)0; t_wp_op = (struct t_op *) 0;
return EOI; return EOI;
} }
while (op->op_text) { while (op->op_text) {
@ -451,14 +436,12 @@ t_lex(s)
} }
op++; op++;
} }
t_wp_op = (struct t_op *)0; t_wp_op = (struct t_op *) 0;
return OPERAND; return OPERAND;
} }
/* atoi with error detection */ /* atoi with error detection */
static int static int getn(const char *s)
getn(s)
const char *s;
{ {
char *p; char *p;
long r; long r;
@ -467,69 +450,57 @@ getn(s)
r = strtol(s, &p, 10); r = strtol(s, &p, 10);
if (errno != 0) if (errno != 0)
error_msg_and_die("%s: out of range", s); error_msg_and_die("%s: out of range", s);
while (isspace(*p)) while (isspace(*p))
p++; p++;
if (*p) if (*p)
error_msg_and_die("%s: bad number", s); error_msg_and_die("%s: bad number", s);
return (int) r; return (int) r;
} }
static int static int newerf(const char *f1, const char *f2)
newerf (f1, f2)
const char *f1, *f2;
{ {
struct stat b1, b2; struct stat b1, b2;
return (stat (f1, &b1) == 0 && return (stat(f1, &b1) == 0 &&
stat (f2, &b2) == 0 && stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
b1.st_mtime > b2.st_mtime);
} }
static int static int olderf(const char *f1, const char *f2)
olderf (f1, f2)
const char *f1, *f2;
{ {
struct stat b1, b2; struct stat b1, b2;
return (stat (f1, &b1) == 0 && return (stat(f1, &b1) == 0 &&
stat (f2, &b2) == 0 && stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
b1.st_mtime < b2.st_mtime);
} }
static int static int equalf(const char *f1, const char *f2)
equalf (f1, f2)
const char *f1, *f2;
{ {
struct stat b1, b2; struct stat b1, b2;
return (stat (f1, &b1) == 0 && return (stat(f1, &b1) == 0 &&
stat (f2, &b2) == 0 && stat(f2, &b2) == 0 &&
b1.st_dev == b2.st_dev && b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
b1.st_ino == b2.st_ino);
} }
/* Do the same thing access(2) does, but use the effective uid and gid, /* Do the same thing access(2) does, but use the effective uid and gid,
and don't make the mistake of telling root that any file is and don't make the mistake of telling root that any file is
executable. */ executable. */
static int static int test_eaccess(char *path, int mode)
test_eaccess (path, mode)
char *path;
int mode;
{ {
struct stat st; struct stat st;
unsigned int euid = geteuid(); unsigned int euid = geteuid();
if (stat (path, &st) < 0) if (stat(path, &st) < 0)
return (-1); return (-1);
if (euid == 0) { if (euid == 0) {
/* Root can read or write any file. */ /* Root can read or write any file. */
if (mode != X_OK) if (mode != X_OK)
return (0); return (0);
/* Root can execute any file that has any one of the execute /* Root can execute any file that has any one of the execute
bits set. */ bits set. */
@ -537,9 +508,9 @@ int mode;
return (0); return (0);
} }
if (st.st_uid == euid) /* owner */ if (st.st_uid == euid) /* owner */
mode <<= 6; mode <<= 6;
else if (is_a_group_member (st.st_gid)) else if (is_a_group_member(st.st_gid))
mode <<= 3; mode <<= 3;
if (st.st_mode & mode) if (st.st_mode & mode)
@ -548,8 +519,7 @@ int mode;
return (-1); return (-1);
} }
static void static void initialize_group_array()
initialize_group_array ()
{ {
ngroups = getgroups(0, NULL); ngroups = getgroups(0, NULL);
group_array = xrealloc(group_array, ngroups * sizeof(gid_t)); group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
@ -557,9 +527,7 @@ initialize_group_array ()
} }
/* Return non-zero if GID is one that we have in our groups list. */ /* Return non-zero if GID is one that we have in our groups list. */
static int static int is_a_group_member(gid_t gid)
is_a_group_member (gid)
gid_t gid;
{ {
register int i; register int i;
@ -568,7 +536,7 @@ gid_t gid;
return (1); return (1);
if (ngroups == 0) if (ngroups == 0)
initialize_group_array (); initialize_group_array();
/* Search through the list looking for GID. */ /* Search through the list looking for GID. */
for (i = 0; i < ngroups; i++) for (i = 0; i < ngroups; i++)