![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c_test.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / bob / korn|
Return to c_test.c CVS log | Up to [MW Coherent from dump] / coherent / a / usr / bob / korn |
1.1 root 1: /*
2: * test(1); version 7-like -- author Erik Baalbergen
3: * modified by Eric Gisin to be used as built-in.
4: * modified by Arnold Robbins to add SVR3 compatibility
5: * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
6: */
7:
8: static char *RCSid = "$Header: c_test.c,v 3.1 88/11/03 09:14:43 egisin Exp $";
9:
10: #include <stddef.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <signal.h>
14: #include <errno.h>
15: #include <setjmp.h>
16: #include <sys/types.h>
17: #include <sys/stat.h>
18: #include "sh.h"
19:
20: /* test(1) accepts the following grammar:
21: expr ::= bexpr | bexpr "-o" expr ;
22: bexpr ::= primary | primary "-a" bexpr ;
23: primary ::= unary-operator operand
24: | operand binary-operator operand
25: | operand
26: | "(" expr ")"
27: | "!" expr
28: ;
29: unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
30: "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
31:
32: binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
33: "-nt"|"-ot"|"-ef";
34: operand ::= <any legal UNIX file name>
35: */
36:
37: #define EOI 0
38: #define FILRD 1
39: #define FILWR 2
40: #define FILREG 3
41: #define FILID 4
42: #define FILGZ 5
43: #define FILTT 6
44: #define STZER 7
45: #define STNZE 8
46: #define STEQL 9
47: #define STNEQ 10
48: #define INTEQ 11
49: #define INTNE 12
50: #define INTGE 13
51: #define INTGT 14
52: #define INTLE 15
53: #define INTLT 16
54: #define UNEGN 17
55: #define BAND 18
56: #define BOR 19
57: #define LPAREN 20
58: #define RPAREN 21
59: #define OPERAND 22
60: #define FILEX 23
61: #define FILCDEV 24
62: #define FILBDEV 25
63: #define FILFIFO 26
64: #define FILSETU 27
65: #define FILSETG 28
66: #define FILSTCK 29
67: #define FILSYM 30
68: #define FILNT 31
69: #define FILOT 32
70: #define FILEQ 33
71: #define FILSOCK 34
72: #define FILUID 35
73: #define FILGID 36
74: #define OPTION 37
75:
76: #define UNOP 1
77: #define BINOP 2
78: #define BUNOP 3
79: #define BBINOP 4
80: #define PAREN 5
81:
82: struct t_op {
83: char *op_text;
84: short op_num, op_type;
85: } Const ops [] = {
86: {"-r", FILRD, UNOP},
87: {"-w", FILWR, UNOP},
88: {"-x", FILEX, UNOP},
89: {"-f", FILREG, UNOP},
90: {"-d", FILID, UNOP},
91: {"-c", FILCDEV,UNOP},
92: {"-b", FILBDEV,UNOP},
93: {"-p", FILFIFO,UNOP},
94: {"-u", FILSETU,UNOP},
95: {"-g", FILSETG,UNOP},
96: {"-k", FILSTCK,UNOP},
97: {"-s", FILGZ, UNOP},
98: {"-t", FILTT, UNOP},
99: {"-z", STZER, UNOP},
100: {"-n", STNZE, UNOP},
101: #if 0 /* conficts with binary -o */
102: {"-o", OPTION, UNOP},
103: #endif
104: {"-U", FILUID, UNOP},
105: {"-G", FILGID, UNOP},
106: {"-L", FILSYM, UNOP},
107: {"-S", FILSOCK,UNOP},
108: {"=", STEQL, BINOP},
109: {"!=", STNEQ, BINOP},
110: {"-eq", INTEQ, BINOP},
111: {"-ne", INTNE, BINOP},
112: {"-ge", INTGE, BINOP},
113: {"-gt", INTGT, BINOP},
114: {"-le", INTLE, BINOP},
115: {"-lt", INTLT, BINOP},
116: {"-nt", FILNT, BINOP},
117: {"-ot", FILOT, BINOP},
118: {"-ef", FILEQ, BINOP},
119: {"!", UNEGN, BUNOP},
120: {"-a", BAND, BBINOP},
121: {"-o", BOR, BBINOP},
122: {"(", LPAREN, PAREN},
123: {")", RPAREN, PAREN},
124: {0, 0, 0}
125: };
126:
127: char **t_wp;
128: struct t_op Const *t_wp_op;
129:
130: int
131: c_test(wp)
132: char **wp;
133: {
134: t_wp = wp+1;
135: if (strcmp(wp[0], "[") == 0) {
136: while (*wp != NULL)
137: wp++;
138: if (strcmp(*--wp, "]") != 0)
139: errorf("[: missing ]\n");
140: *wp = NULL;
141: }
142: #if 0
143: if (*t_wp == NULL)
144: mypr("*t_wp == NULL\n");
145: else if (!expr(t_lex(*t_wp)))
146: mypr("expr returned 0\n");
147: #endif
148: return *t_wp == NULL || !expr(t_lex(*t_wp));
149: }
150:
151: static
152: syntax()
153: {
154: errorf("test: syntax error\n");
155: }
156:
157: expr(n)
158: {
159: int res;
160:
161: if (n == EOI)
162: syntax();
163: res = bexpr(n);
164: if (t_lex(*++t_wp) == BOR)
165: return expr(t_lex(*++t_wp)) || res;
166: t_wp--;
167: return res;
168: }
169:
170: bexpr(n)
171: {
172: int res;
173:
174: if (n == EOI)
175: syntax();
176: res = primary(n);
177: if (t_lex(*++t_wp) == BAND)
178: return bexpr(t_lex(*++t_wp)) && res;
179: t_wp--;
180: return res;
181: }
182:
183: primary(n)
184: int n; /* token */
185: {
186: register char *opnd1, *opnd2;
187: int res;
188:
189: if (n == EOI)
190: syntax();
191: if (n == UNEGN)
192: return !expr(t_lex(*++t_wp));
193: if (n == LPAREN) {
194: res = expr(t_lex(*++t_wp));
195: if (t_lex(*++t_wp) != RPAREN)
196: syntax();
197: return res;
198: }
199: if (n == OPERAND) {
200: opnd1 = *t_wp;
201: (void) t_lex(*++t_wp);
202: if (t_wp_op && t_wp_op->op_type == BINOP) {
203: struct t_op Const *op = t_wp_op;
204:
205: if ((opnd2 = *++t_wp) == (char *)0)
206: syntax();
207:
208: switch (op->op_num) {
209: case STEQL:
210: return strcmp(opnd1, opnd2) == 0;
211: case STNEQ:
212: return strcmp(opnd1, opnd2) != 0;
213: case INTEQ:
214: return evaluate(opnd1) == evaluate(opnd2);
215: case INTNE:
216: return evaluate(opnd1) != evaluate(opnd2);
217: case INTGE:
218: return evaluate(opnd1) >= evaluate(opnd2);
219: case INTGT:
220: return evaluate(opnd1) > evaluate(opnd2);
221: case INTLE:
222: return evaluate(opnd1) <= evaluate(opnd2);
223: case INTLT:
224: return evaluate(opnd1) < evaluate(opnd2);
225: case FILNT:
226: return newerf (opnd1, opnd2);
227: case FILOT:
228: return olderf (opnd1, opnd2);
229: case FILEQ:
230: return equalf (opnd1, opnd2);
231: }
232: }
233: t_wp--;
234: return strlen(opnd1) > 0;
235: }
236: if (t_wp_op->op_type == UNOP) {
237: /* unary expression */
238: if (*++t_wp == NULL && n != FILTT)
239: syntax();
240: switch (n) {
241: case OPTION:
242: return flag[option(*t_wp)];
243: case STZER:
244: return strlen(*t_wp) == 0;
245: case STNZE:
246: return strlen(*t_wp) != 0;
247: case FILTT:
248: if (!digit(**t_wp))
249: return filstat("0", n);
250: default: /* all other FIL* */
251: return filstat(*t_wp, n);
252: }
253: }
254: syntax();
255: }
256:
257: filstat(nm, mode)
258: char *nm;
259: {
260: struct stat s;
261:
262: switch (mode) {
263: case FILRD:
264: return access(nm, 4) == 0;
265: case FILWR:
266: return access(nm, 2) == 0;
267: case FILEX:
268: return access(nm, 1) == 0;
269: case FILREG:
270: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFREG;
271: case FILID:
272: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFDIR;
273: case FILCDEV:
274: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFCHR;
275: case FILBDEV:
276: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFBLK;
277: case FILFIFO:
278: #ifdef S_IFIFO
279: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFIFO;
280: #else
281: return 0;
282: #endif
283: case FILSETU:
284: return stat(nm, &s) == 0 && (s.st_mode & S_ISUID) == S_ISUID;
285: case FILSETG:
286: return stat(nm, &s) == 0 && (s.st_mode & S_ISGID) == S_ISGID;
287: case FILSTCK:
288: return stat(nm, &s) == 0 && (s.st_mode & S_ISVTX) == S_ISVTX;
289: case FILGZ:
290: return stat(nm, &s) == 0 && s.st_size > 0L;
291: case FILTT:
292: return isatty(getn(nm));
293: case FILUID:
294: return stat(nm, &s) == 0 && s.st_uid == geteuid();
295: case FILGID:
296: return stat(nm, &s) == 0 && s.st_gid == getegid();
297: #ifdef S_IFLNK
298: case FILSYM:
299: return lstat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFLNK;
300: #endif
301: #ifdef S_IFSOCK
302: case FILSOCK:
303: return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFSOCK;
304: #endif
305: default:
306: return 1;
307: }
308: }
309:
310: int
311: t_lex(s)
312: register char *s;
313: {
314: register struct t_op Const *op = ops;
315:
316: if (s == 0)
317: return EOI;
318: while (op->op_text) {
319: if (strcmp(s, op->op_text) == 0) {
320: t_wp_op = op;
321: return op->op_num;
322: }
323: op++;
324: }
325: t_wp_op = (struct t_op *)0;
326: return OPERAND;
327: }
328:
329: newerf (f1, f2)
330: char *f1, *f2;
331: {
332: struct stat b1, b2;
333:
334: return (stat (f1, &b1) == 0 &&
335: stat (f2, &b2) == 0 &&
336: b1.st_mtime > b2.st_mtime);
337: }
338:
339: olderf (f1, f2)
340: char *f1, *f2;
341: {
342: struct stat b1, b2;
343:
344: return (stat (f1, &b1) == 0 &&
345: stat (f2, &b2) == 0 &&
346: b1.st_mtime < b2.st_mtime);
347: }
348:
349: equalf (f1, f2)
350: char *f1, *f2;
351: {
352: struct stat b1, b2;
353:
354: return (stat (f1, &b1) == 0 &&
355: stat (f2, &b2) == 0 &&
356: b1.st_dev == b2.st_dev &&
357: b1.st_ino == b2.st_ino);
358: }
359:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.