|
0
|
1 /*
|
|
|
2 * CDDL HEADER START
|
|
|
3 *
|
|
|
4 * The contents of this file are subject to the terms of the
|
|
|
5 * Common Development and Distribution License, Version 1.0 only
|
|
|
6 * (the "License"). You may not use this file except in compliance
|
|
|
7 * with the License.
|
|
|
8 *
|
|
|
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
|
|
|
10 * or http://www.opensolaris.org/os/licensing.
|
|
|
11 * See the License for the specific language governing permissions
|
|
|
12 * and limitations under the License.
|
|
|
13 *
|
|
|
14 * When distributing Covered Code, include this CDDL HEADER in each
|
|
|
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
|
|
16 * If applicable, add the following below this CDDL HEADER, with the
|
|
|
17 * fields enclosed by brackets "[]" replaced with your own identifying
|
|
|
18 * information: Portions Copyright [yyyy] [name of copyright owner]
|
|
|
19 *
|
|
|
20 * CDDL HEADER END
|
|
|
21 */
|
|
|
22 /*
|
|
|
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
|
|
|
24 * Use is subject to license terms.
|
|
|
25 */
|
|
|
26
|
|
|
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
|
|
|
28 /* All Rights Reserved */
|
|
|
29
|
|
|
30 #pragma ident "@(#)bfs.c 1.15 05/07/26 SMI"
|
|
|
31
|
|
|
32 #include <setjmp.h>
|
|
|
33 #include <signal.h>
|
|
|
34 #include <stdlib.h>
|
|
|
35 #include <regexpr.h>
|
|
|
36 #include <limits.h>
|
|
|
37 #include <sys/types.h>
|
|
|
38 #include <unistd.h>
|
|
|
39 #include <sys/stat.h>
|
|
|
40 #include <locale.h>
|
|
|
41 #include <stdio.h>
|
|
|
42 #include <string.h>
|
|
|
43 #include <wait.h>
|
|
|
44 #include <fcntl.h>
|
|
|
45 int setjmp();
|
|
|
46 static jmp_buf env;
|
|
|
47
|
|
|
48 extern int scrwidth(wchar_t);
|
|
|
49
|
|
|
50 #define BRKTYP char
|
|
|
51 #define BRKSIZ 8192
|
|
|
52 #define BRKTWO 4
|
|
|
53 #define BFSAND
|
|
|
54 #define BFSLIM 511
|
|
|
55 #define BFSTRU 511
|
|
|
56 #define BFSBUF 512
|
|
|
57
|
|
|
58 struct Comd {
|
|
|
59 int Cnumadr;
|
|
|
60 int Cadr[2];
|
|
|
61 char Csep;
|
|
|
62 char Cop;
|
|
|
63 };
|
|
|
64
|
|
|
65 static int Dot, Dollar;
|
|
|
66 static int markarray[26], *mark;
|
|
|
67 static int fstack[15] = {1, -1};
|
|
|
68 static int infildes = 0;
|
|
|
69 static int outfildes = 1;
|
|
|
70 static char internal[512], *intptr;
|
|
|
71 static char comdlist[100];
|
|
|
72 static char *endds;
|
|
|
73 static char charbuf = '\n';
|
|
|
74 static int peeked;
|
|
|
75 static char currex[100];
|
|
|
76 static int trunc = BFSTRU;
|
|
|
77 static int crunch = -1;
|
|
|
78 static int segblk[512], segoff[512], txtfd, prevblk, prevoff;
|
|
|
79 static int oldfd = 0;
|
|
|
80 static int flag4 = 0;
|
|
|
81 static int flag3 = 0;
|
|
|
82 static int flag2 = 0;
|
|
|
83 static int flag1 = 0;
|
|
|
84 static int flag = 0;
|
|
|
85 static int lprev = 1;
|
|
|
86 static int status[1];
|
|
|
87 static BRKTYP *lincnt;
|
|
|
88 static char *perbuf;
|
|
|
89 static char *rebuf;
|
|
|
90 static char *glbuf;
|
|
|
91 static char tty, *bigfile;
|
|
|
92 static char fle[80];
|
|
|
93 static char prompt = 1;
|
|
|
94 static char verbose = 1; /* 1=print # of bytes read in; 0=silent. */
|
|
|
95 static char varray[10][100]; /* Holds xv cmd parameters. */
|
|
|
96 static double outcnt;
|
|
|
97 static char strtmp[32];
|
|
|
98
|
|
|
99 static void reset();
|
|
|
100 static void begin(struct Comd *p);
|
|
|
101 static int bigopen(char file[]);
|
|
|
102 static void sizeprt(int blk, int off);
|
|
|
103 static void bigread(int l, char rec[]);
|
|
|
104 static int gcomd(struct Comd *p, int k);
|
|
|
105 static int fcomd(struct Comd *p);
|
|
|
106 static void ecomd();
|
|
|
107 static int kcomd(struct Comd *p);
|
|
|
108 static int xncomd(struct Comd *p);
|
|
|
109 static int pcomd(struct Comd *p);
|
|
|
110 static int qcomd();
|
|
|
111 static int xcomds(struct Comd *p);
|
|
|
112 static int xbcomd(struct Comd *p);
|
|
|
113 static int xccomd(struct Comd *p);
|
|
|
114 static int xfcomd(struct Comd *p);
|
|
|
115 static int xocomd(struct Comd *p);
|
|
|
116 static int xtcomd(struct Comd *p);
|
|
|
117 static int xvcomd();
|
|
|
118 static int wcomd(struct Comd *p);
|
|
|
119 static int nlcomd(struct Comd *p);
|
|
|
120 static int eqcomd(struct Comd *p);
|
|
|
121 static int colcomd(struct Comd *p);
|
|
|
122 static int excomd();
|
|
|
123 static int xcomdlist(struct Comd *p);
|
|
|
124 static int defaults(struct Comd *p, int prt, int max,
|
|
|
125 int def1, int def2, int setdot, int errsok);
|
|
|
126 static int getcomd(struct Comd *p, int prt);
|
|
|
127 static int getadrs(struct Comd *p, int prt);
|
|
|
128 static int getadr(struct Comd *p, int prt);
|
|
|
129 static int getnumb(struct Comd *p, int prt);
|
|
|
130 static int rdnumb(int prt);
|
|
|
131 static int getrel(struct Comd *p, int prt);
|
|
|
132 static int getmark(struct Comd *p, int prt);
|
|
|
133 static int getrex(struct Comd *p, int prt, char c);
|
|
|
134 static int hunt(int prt, char rex[], int start, int down, int wrap, int errsok);
|
|
|
135 static int jump(int prt, char label[]);
|
|
|
136 static int getstr(int prt, char buf[], char brk, char ignr, int nonl);
|
|
|
137 static int regerr(int c);
|
|
|
138 static int err(int prt, char msg[]);
|
|
|
139 static char mygetc();
|
|
|
140 static int readc(int f, char *c);
|
|
|
141 static int percent(char line[256]);
|
|
|
142 static int newfile(int prt, char f[]);
|
|
|
143 static void push(int s[], int d);
|
|
|
144 static int pop(int s[]);
|
|
|
145 static int peekc();
|
|
|
146 static void eat();
|
|
|
147 static int more();
|
|
|
148 static void quit();
|
|
|
149 static void out(char *ln);
|
|
|
150 static char *untab(char l[]);
|
|
|
151 static int patoi(char *b);
|
|
|
152 static int equal(char *a, char *b);
|
|
|
153
|
|
|
154 int
|
|
|
155 main(int argc, char *argv[])
|
|
|
156 {
|
|
|
157 struct Comd comdstruct, *p;
|
|
|
158 (void) setlocale(LC_ALL, "");
|
|
|
159 if (argc < 2 || argc > 3) {
|
|
|
160 (void) err(1, "arg count");
|
|
|
161 quit();
|
|
|
162 }
|
|
|
163 mark = markarray-'a';
|
|
|
164 if (argc == 3) {
|
|
|
165 verbose = 0;
|
|
|
166 }
|
|
|
167 setbuf(stdout, 0);
|
|
|
168 if (bigopen(bigfile = argv[argc-1]))
|
|
|
169 quit();
|
|
|
170 tty = isatty(0);
|
|
|
171 p = &comdstruct;
|
|
|
172 /* Look for 0 or more non-'%' char followed by a '%' */
|
|
|
173 perbuf = compile("[^%]*%", (char *)0, (char *)0);
|
|
|
174 if (regerrno)
|
|
|
175 (void) regerr(regerrno);
|
|
|
176 (void) setjmp(env);
|
|
|
177 #if defined(__STDC__)
|
|
|
178 (void) signal(SIGINT, (void (*)(int))reset);
|
|
|
179 #else
|
|
|
180 (void) signal(SIGINT, reset);
|
|
|
181 #endif
|
|
|
182 (void) err(0, "");
|
|
|
183 (void) printf("\n");
|
|
|
184 flag = 0;
|
|
|
185 prompt = 0;
|
|
|
186 /*CONSTCOND*/ for (;;)
|
|
|
187 begin(p);
|
|
|
188
|
|
|
189 /* NOTREACHED */
|
|
|
190 return (0);
|
|
|
191 }
|
|
|
192
|
|
|
193 static void
|
|
|
194 reset() /* for longjmp on signal */
|
|
|
195 {
|
|
|
196 longjmp(env, 1);
|
|
|
197 }
|
|
|
198
|
|
|
199 static void
|
|
|
200 begin(struct Comd *p)
|
|
|
201 {
|
|
|
202 char line[256];
|
|
|
203 strtagn:
|
|
|
204 if (flag == 0)
|
|
|
205 eat();
|
|
|
206 if (infildes != 100) {
|
|
|
207 if (infildes == 0 && prompt)
|
|
|
208 (void) printf("*");
|
|
|
209 flag3 = 1;
|
|
|
210 if (getstr(1, line, 0, 0, 0))
|
|
|
211 exit(1);
|
|
|
212 flag3 = 0;
|
|
|
213 if (percent(line) < 0)
|
|
|
214 goto strtagn;
|
|
|
215 (void) newfile(1, "");
|
|
|
216 }
|
|
|
217 if (!(getcomd(p, 1) < 0)) {
|
|
|
218 switch (p->Cop) {
|
|
|
219 case 'e':
|
|
|
220 if (!flag)
|
|
|
221 ecomd();
|
|
|
222 else
|
|
|
223 (void) err(0, "");
|
|
|
224 break;
|
|
|
225
|
|
|
226 case 'f':
|
|
|
227 (void) fcomd(p);
|
|
|
228 break;
|
|
|
229
|
|
|
230 case 'g':
|
|
|
231 if (flag == 0)
|
|
|
232 (void) gcomd(p, 1);
|
|
|
233 else
|
|
|
234 (void) err(0, "");
|
|
|
235 break;
|
|
|
236
|
|
|
237 case 'k':
|
|
|
238 (void) kcomd(p);
|
|
|
239 break;
|
|
|
240
|
|
|
241 case 'p':
|
|
|
242 (void) pcomd(p);
|
|
|
243 break;
|
|
|
244
|
|
|
245 case 'q':
|
|
|
246 (void) qcomd();
|
|
|
247 break;
|
|
|
248
|
|
|
249 case 'v':
|
|
|
250 if (flag == 0)
|
|
|
251 (void) gcomd(p, 0);
|
|
|
252 else
|
|
|
253 (void) err(0, "");
|
|
|
254 break;
|
|
|
255
|
|
|
256 case 'x':
|
|
|
257 if (!flag)
|
|
|
258 (void) xcomds(p);
|
|
|
259 else
|
|
|
260 (void) err(0, "");
|
|
|
261 break;
|
|
|
262
|
|
|
263 case 'w':
|
|
|
264 (void) wcomd(p);
|
|
|
265 break;
|
|
|
266
|
|
|
267 case '\n':
|
|
|
268 (void) nlcomd(p);
|
|
|
269 break;
|
|
|
270
|
|
|
271 case '=':
|
|
|
272 (void) eqcomd(p);
|
|
|
273 break;
|
|
|
274
|
|
|
275 case ':':
|
|
|
276 (void) colcomd(p);
|
|
|
277 break;
|
|
|
278
|
|
|
279 case '!':
|
|
|
280 (void) excomd();
|
|
|
281 break;
|
|
|
282
|
|
|
283 case 'P':
|
|
|
284 prompt = !prompt;
|
|
|
285 break;
|
|
|
286
|
|
|
287 default:
|
|
|
288 if (flag)
|
|
|
289 (void) err(0, "");
|
|
|
290 else
|
|
|
291 (void) err(1, "bad command");
|
|
|
292 break;
|
|
|
293 }
|
|
|
294 }
|
|
|
295 }
|
|
|
296
|
|
|
297 static int
|
|
|
298 bigopen(char file[])
|
|
|
299 {
|
|
|
300 int l, off, cnt;
|
|
|
301 int blk, newline, n, s;
|
|
|
302 char block[512];
|
|
|
303 size_t totsiz;
|
|
|
304 BRKTYP *tptr;
|
|
|
305 if ((txtfd = open(file, 0)) < 0)
|
|
|
306 return (err(1, "can't open"));
|
|
|
307 blk = -1;
|
|
|
308 newline = 1;
|
|
|
309 l = cnt = s = 0;
|
|
|
310 off = 512;
|
|
|
311 totsiz = 0;
|
|
|
312 if ((lincnt = (BRKTYP *)malloc(BRKSIZ)) == (BRKTYP *)NULL)
|
|
|
313 return (err(1, "too many lines"));
|
|
|
314 endds = (BRKTYP *)lincnt;
|
|
|
315 totsiz += BRKSIZ;
|
|
|
316 while ((n = read(txtfd, block, 512)) > 0) {
|
|
|
317 blk++;
|
|
|
318 for (off = 0; off < n; off++) {
|
|
|
319 if (newline) {
|
|
|
320 newline = 0;
|
|
|
321 if (l > 0 && !(l&07777)) {
|
|
|
322 totsiz += BRKSIZ;
|
|
|
323 tptr = (BRKTYP *)
|
|
|
324 realloc(lincnt, totsiz);
|
|
|
325 if (tptr == NULL)
|
|
|
326 return
|
|
|
327 (err(1, "too many lines"));
|
|
|
328 else
|
|
|
329 lincnt = tptr;
|
|
|
330 }
|
|
|
331 lincnt[l] = (char)cnt;
|
|
|
332 cnt = 0;
|
|
|
333 if (!(l++ & 077)) {
|
|
|
334 segblk[s] = blk;
|
|
|
335 segoff[s++] = off;
|
|
|
336 }
|
|
|
337 if (l < 0 || l > 32767)
|
|
|
338 return (err(1, "too many lines"));
|
|
|
339 }
|
|
|
340 if (block[off] == '\n') newline = 1;
|
|
|
341 cnt++;
|
|
|
342 }
|
|
|
343 }
|
|
|
344 if (!(l&07777)) {
|
|
|
345 totsiz += BRKTWO;
|
|
|
346 tptr = (BRKTYP *)realloc(lincnt, totsiz);
|
|
|
347 if (tptr == NULL)
|
|
|
348 return (err(1, "too many lines"));
|
|
|
349 else
|
|
|
350 lincnt = tptr;
|
|
|
351 }
|
|
|
352 lincnt[Dot = Dollar = l] = (char)cnt;
|
|
|
353 sizeprt(blk, off);
|
|
|
354 return (0);
|
|
|
355 }
|
|
|
356
|
|
|
357 static void
|
|
|
358 sizeprt(int blk, int off)
|
|
|
359 {
|
|
|
360 if (verbose)
|
|
|
361 (void) printf("%.0f", 512.*blk+off);
|
|
|
362 }
|
|
|
363
|
|
|
364 static int saveblk = -1;
|
|
|
365
|
|
|
366 static void
|
|
|
367 bigread(int l, char rec[])
|
|
|
368 {
|
|
|
369 int i;
|
|
|
370 char *r, *b;
|
|
|
371 int off;
|
|
|
372 static char savetxt[512];
|
|
|
373
|
|
|
374 if ((i = l-lprev) == 1) prevoff += lincnt[lprev]BFSAND;
|
|
|
375 else if (i >= 0 && i <= 32)
|
|
|
376 for (i = lprev; i < l; i++) prevoff += lincnt[i]BFSAND;
|
|
|
377 else if (i < 0 && i >= -32)
|
|
|
378 for (i = lprev-1; i >= l; i--) prevoff -= lincnt[i]BFSAND;
|
|
|
379 else {
|
|
|
380 prevblk = segblk[i = (l-1)>>6];
|
|
|
381 prevoff = segoff[i];
|
|
|
382 for (i = (i<<6)+1; i < l; i++) prevoff += lincnt[i]BFSAND;
|
|
|
383 }
|
|
|
384
|
|
|
385 prevblk += prevoff>>9;
|
|
|
386 prevoff &= 0777;
|
|
|
387 lprev = l;
|
|
|
388 if (prevblk != saveblk) {
|
|
|
389 (void) lseek(txtfd, ((long)(saveblk = prevblk))<<9, 0);
|
|
|
390 (void) read(txtfd, savetxt, 512);
|
|
|
391 }
|
|
|
392 r = rec;
|
|
|
393 off = prevoff;
|
|
|
394 /*CONSTCOND*/while (1) {
|
|
|
395 for (b = savetxt+off; b < savetxt+512; b++) {
|
|
|
396 if ((*r++ = *b) == '\n') {
|
|
|
397 *(r-1) = '\0';
|
|
|
398 return;
|
|
|
399 }
|
|
|
400 if (((unsigned)r - (unsigned)rec) > BFSLIM) {
|
|
|
401
|
|
|
402 (void) write(2,
|
|
|
403 "Line too long--output truncated\n", 32);
|
|
|
404 return;
|
|
|
405 }
|
|
|
406 }
|
|
|
407 (void) read(txtfd, savetxt, 512);
|
|
|
408 off = 0;
|
|
|
409 saveblk++;
|
|
|
410 }
|
|
|
411 }
|
|
|
412
|
|
|
413 static void
|
|
|
414 ecomd()
|
|
|
415 {
|
|
|
416 int i = 0;
|
|
|
417 while (peekc() == ' ')
|
|
|
418 (void) mygetc();
|
|
|
419 while ((fle[i++] = mygetc()) != '\n');
|
|
|
420 fle[--i] = '\0';
|
|
|
421 /* Without this, ~20 "e" cmds gave "can't open" msg. */
|
|
|
422 (void) close(txtfd);
|
|
|
423 free(endds);
|
|
|
424 /* Reset parameters. */
|
|
|
425 lprev = 1;
|
|
|
426 prevblk = 0;
|
|
|
427 prevoff = 0;
|
|
|
428 saveblk = -1;
|
|
|
429 if (bigopen(bigfile = fle))
|
|
|
430 quit();
|
|
|
431 (void) printf("\n");
|
|
|
432 }
|
|
|
433
|
|
|
434 static int
|
|
|
435 fcomd(struct Comd *p)
|
|
|
436 {
|
|
|
437 if (more() || defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
438 return (-1);
|
|
|
439 (void) printf("%s\n", bigfile);
|
|
|
440 return (0);
|
|
|
441 }
|
|
|
442
|
|
|
443 static int
|
|
|
444 gcomd(struct Comd *p, int k)
|
|
|
445 {
|
|
|
446 char d;
|
|
|
447 int i, end;
|
|
|
448 char line[BFSBUF];
|
|
|
449 if (defaults(p, 1, 2, 1, Dollar, 0, 0))
|
|
|
450 return (-1);
|
|
|
451 if ((d = mygetc()) == '\n')
|
|
|
452 return (err(1, "syntax"));
|
|
|
453 if (peekc() == d)
|
|
|
454 (void) mygetc();
|
|
|
455 else
|
|
|
456 if (getstr(1, currex, d, 0, 1))
|
|
|
457 return (-1);
|
|
|
458 glbuf = compile(currex, (char *)0, (char *)0);
|
|
|
459 if (regerrno) {
|
|
|
460 (void) regerr(regerrno);
|
|
|
461 return (-1);
|
|
|
462 } else {
|
|
|
463 if (glbuf)
|
|
|
464 free(glbuf);
|
|
|
465 }
|
|
|
466
|
|
|
467 if (getstr(1, comdlist, 0, 0, 0))
|
|
|
468 return (-1);
|
|
|
469 i = p->Cadr[0];
|
|
|
470 end = p->Cadr[1];
|
|
|
471 while (i <= end) {
|
|
|
472 bigread(i, line);
|
|
|
473 if (!(step(line, glbuf))) {
|
|
|
474 if (!k) {
|
|
|
475 Dot = i;
|
|
|
476 if (xcomdlist(p))
|
|
|
477 return (err(1, "bad comd list"));
|
|
|
478 }
|
|
|
479 i++;
|
|
|
480 } else {
|
|
|
481 if (k) {
|
|
|
482 Dot = i;
|
|
|
483 if (xcomdlist(p))
|
|
|
484 return (err(1, "bad comd list"));
|
|
|
485 }
|
|
|
486 i++;
|
|
|
487 }
|
|
|
488 }
|
|
|
489 return (0);
|
|
|
490 }
|
|
|
491
|
|
|
492 static int
|
|
|
493 kcomd(struct Comd *p)
|
|
|
494 {
|
|
|
495 char c;
|
|
|
496 if ((c = peekc()) < 'a' || c > 'z')
|
|
|
497 return (err(1, "bad mark"));
|
|
|
498 (void) mygetc();
|
|
|
499 if (more() || defaults(p, 1, 1, Dot, 0, 1, 0))
|
|
|
500 return (-1);
|
|
|
501 mark[c] = Dot = p->Cadr[0];
|
|
|
502 return (0);
|
|
|
503 }
|
|
|
504
|
|
|
505 static int
|
|
|
506 xncomd(struct Comd *p)
|
|
|
507 {
|
|
|
508 char c;
|
|
|
509 if (more() || defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
510 return (-1);
|
|
|
511
|
|
|
512 for (c = 'a'; c <= 'z'; c++)
|
|
|
513 if (mark[c])
|
|
|
514 (void) printf("%c\n", c);
|
|
|
515
|
|
|
516 return (0);
|
|
|
517 }
|
|
|
518
|
|
|
519 static int
|
|
|
520 pcomd(struct Comd *p)
|
|
|
521 {
|
|
|
522 int i;
|
|
|
523 char line[BFSBUF];
|
|
|
524 if (more() || defaults(p, 1, 2, Dot, Dot, 1, 0))
|
|
|
525 return (-1);
|
|
|
526 for (i = p->Cadr[0]; i <= p->Cadr[1] && i > 0; i++) {
|
|
|
527 bigread(i, line);
|
|
|
528 out(line);
|
|
|
529 }
|
|
|
530 return (0);
|
|
|
531 }
|
|
|
532
|
|
|
533 static int
|
|
|
534 qcomd()
|
|
|
535 {
|
|
|
536 if (more())
|
|
|
537 return (-1);
|
|
|
538 quit();
|
|
|
539 return (0);
|
|
|
540 }
|
|
|
541
|
|
|
542 static int
|
|
|
543 xcomds(struct Comd *p)
|
|
|
544 {
|
|
|
545 switch (mygetc()) {
|
|
|
546 case 'b': return (xbcomd(p));
|
|
|
547 case 'c': return (xccomd(p));
|
|
|
548 case 'f': return (xfcomd(p));
|
|
|
549 case 'n': return (xncomd(p));
|
|
|
550 case 'o': return (xocomd(p));
|
|
|
551 case 't': return (xtcomd(p));
|
|
|
552 case 'v': return (xvcomd());
|
|
|
553 default: return (err(1, "bad command"));
|
|
|
554 }
|
|
|
555 }
|
|
|
556
|
|
|
557 static int
|
|
|
558 xbcomd(struct Comd *p)
|
|
|
559 {
|
|
|
560 int fail, n;
|
|
|
561 char d;
|
|
|
562 char str[50];
|
|
|
563
|
|
|
564 fail = 0;
|
|
|
565 if (defaults(p, 0, 2, Dot, Dot, 0, 1))
|
|
|
566 fail = 1;
|
|
|
567 else {
|
|
|
568 if ((d = mygetc()) == '\n')
|
|
|
569 return (err(1, "syntax"));
|
|
|
570 if (d == 'z') {
|
|
|
571 if (status[0] != 0)
|
|
|
572 return (0);
|
|
|
573 (void) mygetc();
|
|
|
574 if (getstr(1, str, 0, 0, 0))
|
|
|
575 return (-1);
|
|
|
576 return (jump(1, str));
|
|
|
577 }
|
|
|
578 if (d == 'n') {
|
|
|
579 if (status[0] == 0)
|
|
|
580 return (0);
|
|
|
581 (void) mygetc();
|
|
|
582 if (getstr(1, str, 0, 0, 0))
|
|
|
583 return (-1);
|
|
|
584 return (jump(1, str));
|
|
|
585 }
|
|
|
586 if (getstr(1, str, d, ' ', 0))
|
|
|
587 return (-1);
|
|
|
588 if ((n = hunt(0, str, p->Cadr[0]-1, 1, 0, 1)) < 0)
|
|
|
589 fail = 1;
|
|
|
590 if (getstr(1, str, 0, 0, 0))
|
|
|
591 return (-1);
|
|
|
592 if (more())
|
|
|
593 return (err(1, "syntax"));
|
|
|
594 }
|
|
|
595 if (!fail) {
|
|
|
596 Dot = n;
|
|
|
597 return (jump(1, str));
|
|
|
598 }
|
|
|
599 return (0);
|
|
|
600 }
|
|
|
601
|
|
|
602 static int
|
|
|
603 xccomd(struct Comd *p)
|
|
|
604 {
|
|
|
605 char arg[100];
|
|
|
606 if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
607 return (-1);
|
|
|
608 if (equal(arg, ""))
|
|
|
609 crunch = -crunch;
|
|
|
610 else if (equal(arg, "0"))
|
|
|
611 crunch = -1;
|
|
|
612 else if (equal(arg, "1"))
|
|
|
613 crunch = 1;
|
|
|
614 else
|
|
|
615 return (err(1, "syntax"));
|
|
|
616
|
|
|
617 return (0);
|
|
|
618 }
|
|
|
619
|
|
|
620 static int
|
|
|
621 xfcomd(struct Comd *p)
|
|
|
622 {
|
|
|
623 char fl[100];
|
|
|
624 char *f;
|
|
|
625 if (defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
626 return (-1);
|
|
|
627
|
|
|
628 while (peekc() == ' ')
|
|
|
629 (void) mygetc();
|
|
|
630 for (f = fl; (*f = mygetc()) != '\n'; f++);
|
|
|
631 if (f == fl)
|
|
|
632 return (err(1, "no file"));
|
|
|
633 *f = '\0';
|
|
|
634
|
|
|
635 return (newfile(1, fl));
|
|
|
636 }
|
|
|
637
|
|
|
638 static int
|
|
|
639 xocomd(struct Comd *p)
|
|
|
640 {
|
|
|
641 int fd;
|
|
|
642 char arg[100];
|
|
|
643
|
|
|
644 if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
645 return (-1);
|
|
|
646
|
|
|
647 if (!arg[0]) {
|
|
|
648 if (outfildes == 1)
|
|
|
649 return (err(1, "no diversion"));
|
|
|
650 (void) close(outfildes);
|
|
|
651 outfildes = 1;
|
|
|
652 } else {
|
|
|
653 if (outfildes != 1)
|
|
|
654 return (err(1, "already diverted"));
|
|
|
655 if ((fd = open(arg, O_WRONLY|O_CREAT|O_TRUNC,
|
|
|
656 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))) < 0)
|
|
|
657 return (err(1, "can't create"));
|
|
|
658 outfildes = fd;
|
|
|
659 }
|
|
|
660 return (0);
|
|
|
661 }
|
|
|
662
|
|
|
663 static int
|
|
|
664 xtcomd(struct Comd *p)
|
|
|
665 {
|
|
|
666 int t;
|
|
|
667
|
|
|
668 while (peekc() == ' ')
|
|
|
669 (void) mygetc();
|
|
|
670 if ((t = rdnumb(1)) < 0 || more() || defaults(p, 1, 0, 0, 0, 0, 0))
|
|
|
671 return (-1);
|
|
|
672
|
|
|
673 trunc = t;
|
|
|
674 return (0);
|
|
|
675 }
|
|
|
676
|
|
|
677 static int
|
|
|
678 xvcomd()
|
|
|
679 {
|
|
|
680 char c;
|
|
|
681 int i;
|
|
|
682 int temp0, temp1, temp2;
|
|
|
683 int fildes[2];
|
|
|
684
|
|
|
685 if ((c = peekc()) < '0' || c > '9')
|
|
|
686 return (err(1, "digit required"));
|
|
|
687 (void) mygetc();
|
|
|
688 c -= '0';
|
|
|
689 while (peekc() == ' ')
|
|
|
690 (void) mygetc();
|
|
|
691 if (peekc() == '\\')
|
|
|
692 (void) mygetc();
|
|
|
693 else if (peekc() == '!') {
|
|
|
694 if (pipe(fildes) < 0) {
|
|
|
695 (void) printf("Try again");
|
|
|
696 return (-1);
|
|
|
697 }
|
|
|
698 temp0 = dup(0);
|
|
|
699 temp1 = dup(1);
|
|
|
700 temp2 = infildes;
|
|
|
701 (void) close(0);
|
|
|
702 (void) dup(fildes[0]);
|
|
|
703 (void) close(1);
|
|
|
704 (void) dup(fildes[1]);
|
|
|
705 (void) close(fildes[0]);
|
|
|
706 (void) close(fildes[1]);
|
|
|
707 (void) mygetc();
|
|
|
708 flag4 = 1;
|
|
|
709 (void) excomd();
|
|
|
710 (void) close(1);
|
|
|
711 infildes = 0;
|
|
|
712 }
|
|
|
713 for (i = 0; (varray[c][i] = mygetc()) != '\n'; i++);
|
|
|
714 varray[c][i] = '\0';
|
|
|
715 if (flag4) {
|
|
|
716 infildes = temp2;
|
|
|
717 (void) close(0);
|
|
|
718 (void) dup(temp0);
|
|
|
719 (void) close(temp0);
|
|
|
720 (void) dup(temp1);
|
|
|
721 (void) close(temp1);
|
|
|
722 flag4 = 0;
|
|
|
723 charbuf = ' ';
|
|
|
724 }
|
|
|
725 return (0);
|
|
|
726 }
|
|
|
727
|
|
|
728 static int
|
|
|
729 wcomd(struct Comd *p)
|
|
|
730 {
|
|
|
731 int i, fd, savefd;
|
|
|
732 int savecrunch, savetrunc;
|
|
|
733 char arg[100], line[BFSBUF];
|
|
|
734
|
|
|
735 if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 2, 1, Dollar, 1, 0))
|
|
|
736 return (-1);
|
|
|
737 if (!arg[0])
|
|
|
738 return (err(1, "no file name"));
|
|
|
739 if (equal(arg, bigfile))
|
|
|
740 return (err(1, "no change indicated"));
|
|
|
741 if ((fd = open(arg, O_WRONLY|O_CREAT|O_TRUNC,
|
|
|
742 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))) < 0)
|
|
|
743 return (err(1, "can't create"));
|
|
|
744
|
|
|
745 savefd = outfildes;
|
|
|
746 savetrunc = trunc;
|
|
|
747 savecrunch = crunch;
|
|
|
748 outfildes = fd;
|
|
|
749 trunc = BFSTRU;
|
|
|
750 crunch = -1;
|
|
|
751
|
|
|
752 outcnt = 0;
|
|
|
753 for (i = p->Cadr[0]; i <= p->Cadr[1] && i > 0; i++) {
|
|
|
754 bigread(i, line);
|
|
|
755 out(line);
|
|
|
756 }
|
|
|
757 if (verbose)
|
|
|
758 (void) printf("%.0f\n", outcnt);
|
|
|
759 (void) close(fd);
|
|
|
760
|
|
|
761 outfildes = savefd;
|
|
|
762 trunc = savetrunc;
|
|
|
763 crunch = savecrunch;
|
|
|
764 return (0);
|
|
|
765 }
|
|
|
766
|
|
|
767 static int
|
|
|
768 nlcomd(struct Comd *p)
|
|
|
769 {
|
|
|
770 if (defaults(p, 1, 2, Dot+1, Dot+1, 1, 0)) {
|
|
|
771 (void) mygetc();
|
|
|
772 return (-1);
|
|
|
773 }
|
|
|
774 return (pcomd(p));
|
|
|
775 }
|
|
|
776
|
|
|
777 static int
|
|
|
778 eqcomd(struct Comd *p)
|
|
|
779 {
|
|
|
780 if (more() || defaults(p, 1, 1, Dollar, 0, 0, 0))
|
|
|
781 return (-1);
|
|
|
782 (void) printf("%d\n", p->Cadr[0]);
|
|
|
783 return (0);
|
|
|
784 }
|
|
|
785
|
|
|
786 static int
|
|
|
787 colcomd(struct Comd *p)
|
|
|
788 {
|
|
|
789 return (defaults(p, 1, 0, 0, 0, 0, 0));
|
|
|
790 }
|
|
|
791
|
|
|
792 static int
|
|
|
793 xcomdlist(struct Comd *p)
|
|
|
794 {
|
|
|
795 flag = 1;
|
|
|
796 flag2 = 1;
|
|
|
797 (void) newfile(1, "");
|
|
|
798 while (flag2)
|
|
|
799 begin(p);
|
|
|
800 if (flag == 0)
|
|
|
801 return (1);
|
|
|
802 flag = 0;
|
|
|
803 return (0);
|
|
|
804 }
|
|
|
805
|
|
|
806 static int
|
|
|
807 excomd()
|
|
|
808 {
|
|
|
809 pid_t i;
|
|
|
810 int j;
|
|
|
811 if (infildes != 100)
|
|
|
812 charbuf = '\n';
|
|
|
813 while ((i = fork()) < (pid_t)0)
|
|
|
814 (void) sleep(10);
|
|
|
815 if (i == (pid_t)0) {
|
|
|
816 /* Guarantees child can be intr. */
|
|
|
817 (void) signal(SIGINT, SIG_DFL);
|
|
|
818 if (infildes == 100 || flag4) {
|
|
|
819 (void) execl("/usr/bin/sh", "sh", "-c", intptr, 0);
|
|
|
820 exit(0);
|
|
|
821 }
|
|
|
822 if (infildes != 0) {
|
|
|
823 (void) close(0);
|
|
|
824 (void) dup(infildes);
|
|
|
825 }
|
|
|
826 for (j = 3; j < 15; j++) (void) close(j);
|
|
|
827 (void) execl("/usr/bin/sh", "sh", "-t", 0);
|
|
|
828 exit(0);
|
|
|
829 }
|
|
|
830 (void) signal(SIGINT, SIG_IGN);
|
|
|
831 while (wait(status) != i);
|
|
|
832 status[0] = status[0] >> 8;
|
|
|
833
|
|
|
834 #if defined(__STDC__)
|
|
|
835 (void) signal(SIGINT, (void (*)(int))reset);
|
|
|
836 #else
|
|
|
837 (void) signal(SIGINT, reset); /* Restore signal to previous status */
|
|
|
838 #endif
|
|
|
839
|
|
|
840 if (((infildes == 0) || ((infildes == 100) &&
|
|
|
841 (fstack[fstack[0]] == 0)))&& verbose && (!flag4))
|
|
|
842 (void) printf("!\n");
|
|
|
843 return (0);
|
|
|
844 }
|
|
|
845
|
|
|
846 static int
|
|
|
847 defaults(struct Comd *p, int prt, int max,
|
|
|
848 int def1, int def2, int setdot, int errsok)
|
|
|
849 {
|
|
|
850 if (!def1)
|
|
|
851 def1 = Dot;
|
|
|
852 if (!def2)
|
|
|
853 def2 = def1;
|
|
|
854 if (p->Cnumadr >= max)
|
|
|
855 return (errsok?-1:err(prt, "adr count"));
|
|
|
856 if (p->Cnumadr < 0) {
|
|
|
857 p->Cadr[++p->Cnumadr] = def1;
|
|
|
858 p->Cadr[++p->Cnumadr] = def2;
|
|
|
859 } else if (p->Cnumadr < 1)
|
|
|
860 p->Cadr[++p->Cnumadr] = p->Cadr[0];
|
|
|
861 if (p->Cadr[0] < 1 || p->Cadr[0] > Dollar ||
|
|
|
862 p->Cadr[1] < 1 || p->Cadr[1] > Dollar)
|
|
|
863 return (errsok?-1:err(prt, "range"));
|
|
|
864 if (p->Cadr[0] > p->Cadr[1])
|
|
|
865 return (errsok?-1:err(prt, "adr1 > adr2"));
|
|
|
866 if (setdot)
|
|
|
867 Dot = p->Cadr[1];
|
|
|
868 return (0);
|
|
|
869 }
|
|
|
870
|
|
|
871 static int
|
|
|
872 getcomd(struct Comd *p, int prt)
|
|
|
873 {
|
|
|
874 int r;
|
|
|
875 int c;
|
|
|
876
|
|
|
877 p->Cnumadr = -1;
|
|
|
878 p->Csep = ' ';
|
|
|
879 switch (c = peekc()) {
|
|
|
880 case ',':
|
|
|
881 case ';': p->Cop = mygetc();
|
|
|
882 return (0);
|
|
|
883 }
|
|
|
884
|
|
|
885 if ((r = getadrs(p, prt)) < 0)
|
|
|
886 return (r);
|
|
|
887
|
|
|
888 if ((c = peekc()) < 0)
|
|
|
889 return (err(prt, "syntax"));
|
|
|
890 if (c == '\n')
|
|
|
891 p->Cop = '\n';
|
|
|
892 else
|
|
|
893 p->Cop = mygetc();
|
|
|
894
|
|
|
895 return (0);
|
|
|
896 }
|
|
|
897
|
|
|
898 static int
|
|
|
899 getadrs(struct Comd *p, int prt)
|
|
|
900 {
|
|
|
901 int r;
|
|
|
902 char c;
|
|
|
903
|
|
|
904 if ((r = getadr(p, prt)) < 0)
|
|
|
905 return (r);
|
|
|
906
|
|
|
907 switch (c = peekc()) {
|
|
|
908 case ';':
|
|
|
909 Dot = p->Cadr[0];
|
|
|
910 (void) mygetc();
|
|
|
911 p->Csep = c;
|
|
|
912 return (getadr(p, prt));
|
|
|
913 case ',':
|
|
|
914 (void) mygetc();
|
|
|
915 p->Csep = c;
|
|
|
916 return (getadr(p, prt));
|
|
|
917 }
|
|
|
918
|
|
|
919 return (0);
|
|
|
920 }
|
|
|
921
|
|
|
922 static int
|
|
|
923 getadr(struct Comd *p, int prt)
|
|
|
924 {
|
|
|
925 int r;
|
|
|
926 char c;
|
|
|
927
|
|
|
928 r = 0;
|
|
|
929 while (peekc() == ' ')
|
|
|
930 (void) mygetc(); /* Ignore leading spaces */
|
|
|
931 switch (c = peekc()) {
|
|
|
932 case '\n':
|
|
|
933 case ',':
|
|
|
934 case ';': return (0);
|
|
|
935 case '\'': (void) mygetc();
|
|
|
936 r = getmark(p, prt);
|
|
|
937 break;
|
|
|
938
|
|
|
939 case '0':
|
|
|
940 case '1':
|
|
|
941 case '2':
|
|
|
942 case '3':
|
|
|
943 case '4':
|
|
|
944 case '5':
|
|
|
945 case '6':
|
|
|
946 case '7':
|
|
|
947 case '8':
|
|
|
948 case '9': r = getnumb(p, prt);
|
|
|
949 break;
|
|
|
950 case '.': (void) mygetc();
|
|
|
951 p->Cadr[++p->Cnumadr] = Dot;
|
|
|
952 break;
|
|
|
953 case '+':
|
|
|
954 case '-': p->Cadr[++p->Cnumadr] = Dot;
|
|
|
955 break;
|
|
|
956 case '$': (void) mygetc();
|
|
|
957 p->Cadr[++p->Cnumadr] = Dollar;
|
|
|
958 break;
|
|
|
959 case '^': (void) mygetc();
|
|
|
960 p->Cadr[++p->Cnumadr] = Dot - 1;
|
|
|
961 break;
|
|
|
962 case '/':
|
|
|
963 case '?':
|
|
|
964 case '>':
|
|
|
965 case '<': (void) mygetc();
|
|
|
966 r = getrex(p, prt, c);
|
|
|
967 break;
|
|
|
968 default: return (0);
|
|
|
969 }
|
|
|
970
|
|
|
971 if (r == 0)
|
|
|
972 r = getrel(p, prt);
|
|
|
973 return (r);
|
|
|
974 }
|
|
|
975
|
|
|
976 static int
|
|
|
977 getnumb(struct Comd *p, int prt)
|
|
|
978 {
|
|
|
979 int i;
|
|
|
980
|
|
|
981 if ((i = rdnumb(prt)) < 0)
|
|
|
982 return (-1);
|
|
|
983 p->Cadr[++p->Cnumadr] = i;
|
|
|
984 return (0);
|
|
|
985 }
|
|
|
986
|
|
|
987 static int
|
|
|
988 rdnumb(int prt)
|
|
|
989 {
|
|
|
990 char num[20], *n;
|
|
|
991 int i;
|
|
|
992
|
|
|
993 n = num;
|
|
|
994 while ((*n = peekc()) >= '0' && *n <= '9') {
|
|
|
995 n++;
|
|
|
996 (void) mygetc();
|
|
|
997 }
|
|
|
998
|
|
|
999 *n = '\0';
|
|
|
1000 if ((i = patoi(num)) >= 0)
|
|
|
1001 return (i);
|
|
|
1002 return (err(prt, "bad num"));
|
|
|
1003 }
|
|
|
1004
|
|
|
1005 static int
|
|
|
1006 getrel(struct Comd *p, int prt)
|
|
|
1007 {
|
|
|
1008 int op, n;
|
|
|
1009 char c;
|
|
|
1010 int j;
|
|
|
1011
|
|
|
1012 n = 0;
|
|
|
1013 op = 1;
|
|
|
1014 while ((c = peekc()) == '+' || c == '-') {
|
|
|
1015 if (c == '+')
|
|
|
1016 n++;
|
|
|
1017 else
|
|
|
1018 n--;
|
|
|
1019 (void) mygetc();
|
|
|
1020 }
|
|
|
1021 j = n;
|
|
|
1022 if (n < 0)
|
|
|
1023 op = -1;
|
|
|
1024 if (c == '\n')
|
|
|
1025 p->Cadr[p->Cnumadr] += n;
|
|
|
1026 else {
|
|
|
1027 if ((n = rdnumb(0)) > 0 && p->Cnumadr >= 0) {
|
|
|
1028 p->Cadr[p->Cnumadr] += op*n;
|
|
|
1029 (void) getrel(p, prt);
|
|
|
1030 } else {
|
|
|
1031 p->Cadr[p->Cnumadr] += j;
|
|
|
1032 }
|
|
|
1033 }
|
|
|
1034 return (0);
|
|
|
1035 }
|
|
|
1036
|
|
|
1037 static int
|
|
|
1038 getmark(struct Comd *p, int prt)
|
|
|
1039 {
|
|
|
1040 char c;
|
|
|
1041
|
|
|
1042 if ((c = peekc()) < 'a' || c > 'z')
|
|
|
1043 return (err(prt, "bad mark"));
|
|
|
1044 (void) mygetc();
|
|
|
1045
|
|
|
1046 if (!mark[c])
|
|
|
1047 return (err(prt, "undefined mark"));
|
|
|
1048 p->Cadr[++p->Cnumadr] = mark[c];
|
|
|
1049 return (0);
|
|
|
1050 }
|
|
|
1051
|
|
|
1052 static int
|
|
|
1053 getrex(struct Comd *p, int prt, char c)
|
|
|
1054 {
|
|
|
1055 int down, wrap, start;
|
|
|
1056
|
|
|
1057 if (peekc() == c)
|
|
|
1058 (void) mygetc();
|
|
|
1059 else if (getstr(prt, currex, c, 0, 1))
|
|
|
1060 return (-1);
|
|
|
1061
|
|
|
1062 switch (c) {
|
|
|
1063 case '/': down = 1; wrap = 1; break;
|
|
|
1064 case '?': down = 0; wrap = 1; break;
|
|
|
1065 case '>': down = 1; wrap = 0; break;
|
|
|
1066 case '<': down = 0; wrap = 0; break;
|
|
|
1067 }
|
|
|
1068
|
|
|
1069 if (p->Csep == ';')
|
|
|
1070 start = p->Cadr[0];
|
|
|
1071 else
|
|
|
1072 start = Dot;
|
|
|
1073
|
|
|
1074 if ((p->Cadr[++p->Cnumadr] = hunt(prt, currex, start, down, wrap, 0))
|
|
|
1075 < 0)
|
|
|
1076 return (-1);
|
|
|
1077 return (0);
|
|
|
1078 }
|
|
|
1079
|
|
|
1080 static int
|
|
|
1081 hunt(int prt, char rex[], int start, int down, int wrap, int errsok)
|
|
|
1082 {
|
|
|
1083 int i, end1, incr;
|
|
|
1084 int start1, start2;
|
|
|
1085 char line[BFSBUF];
|
|
|
1086
|
|
|
1087 if (down) {
|
|
|
1088 start1 = start + 1;
|
|
|
1089 end1 = Dollar;
|
|
|
1090 start2 = 1;
|
|
|
1091 incr = 1;
|
|
|
1092 } else {
|
|
|
1093 start1 = start - 1;
|
|
|
1094 end1 = 1;
|
|
|
1095 start2 = Dollar;
|
|
|
1096 incr = -1;
|
|
|
1097 }
|
|
|
1098
|
|
|
1099 rebuf = compile(rex, (char *)0, (char *)0);
|
|
|
1100 if (regerrno)
|
|
|
1101 (void) regerr(regerrno);
|
|
|
1102 else
|
|
|
1103 if (rebuf)
|
|
|
1104 free(rebuf);
|
|
|
1105
|
|
|
1106 for (i = start1; i != end1+incr; i += incr) {
|
|
|
1107 bigread(i, line);
|
|
|
1108 if (step(line, rebuf)) {
|
|
|
1109 return (i);
|
|
|
1110 }
|
|
|
1111 }
|
|
|
1112
|
|
|
1113 if (!wrap)
|
|
|
1114 return (errsok?-1:err(prt, "not found"));
|
|
|
1115
|
|
|
1116 for (i = start2; i != start1; i += incr) {
|
|
|
1117 bigread(i, line);
|
|
|
1118 if (step(line, rebuf)) {
|
|
|
1119 return (i);
|
|
|
1120 }
|
|
|
1121 }
|
|
|
1122
|
|
|
1123 return (errsok?-1:err(prt, "not found"));
|
|
|
1124 }
|
|
|
1125
|
|
|
1126 static int
|
|
|
1127 jump(int prt, char label[])
|
|
|
1128 {
|
|
|
1129 char *l;
|
|
|
1130 char line[256];
|
|
|
1131
|
|
|
1132 if (infildes == 0 && tty)
|
|
|
1133 return (err(prt, "jump on tty"));
|
|
|
1134 if (infildes == 100)
|
|
|
1135 intptr = internal;
|
|
|
1136 else
|
|
|
1137 (void) lseek(infildes, 0L, 0);
|
|
|
1138
|
|
|
1139 (void) snprintf(strtmp,
|
|
|
1140 sizeof (strtmp) * sizeof (char), "^: *%s$", label);
|
|
|
1141 rebuf = compile(strtmp, (char *)0, (char *)0);
|
|
|
1142 if (regerrno) {
|
|
|
1143 (void) regerr(regerrno);
|
|
|
1144 return (-1);
|
|
|
1145 }
|
|
|
1146
|
|
|
1147 for (l = line; readc(infildes, l); l++) {
|
|
|
1148 if (*l == '\n') {
|
|
|
1149 *l = '\0';
|
|
|
1150 if (step(line, rebuf)) {
|
|
|
1151 charbuf = '\n';
|
|
|
1152 return (peeked = 0);
|
|
|
1153 }
|
|
|
1154 l = line - 1;
|
|
|
1155 }
|
|
|
1156 }
|
|
|
1157
|
|
|
1158 return (err(prt, "label not found"));
|
|
|
1159 }
|
|
|
1160
|
|
|
1161 static int
|
|
|
1162 getstr(int prt, char buf[], char brk, char ignr, int nonl)
|
|
|
1163 {
|
|
|
1164 char *b, c, prevc;
|
|
|
1165
|
|
|
1166 prevc = 0;
|
|
|
1167 for (b = buf; c = peekc(); prevc = c) {
|
|
|
1168 if (c == '\n') {
|
|
|
1169 if (prevc == '\\' && (!flag3)) *(b-1) = mygetc();
|
|
|
1170 else if (prevc == '\\' && flag3) {
|
|
|
1171 *b++ = mygetc();
|
|
|
1172 } else if (nonl)
|
|
|
1173 break;
|
|
|
1174 else
|
|
|
1175 return (*b = '\0');
|
|
|
1176 } else {
|
|
|
1177 (void) mygetc();
|
|
|
1178 if (c == brk) {
|
|
|
1179 if (prevc == '\\') *(b-1) = c;
|
|
|
1180 else return (*b = '\0');
|
|
|
1181 } else if (b != buf || c != ignr) *b++ = c;
|
|
|
1182 }
|
|
|
1183 }
|
|
|
1184 return (err(prt, "syntax"));
|
|
|
1185 }
|
|
|
1186
|
|
|
1187 static int
|
|
|
1188 regerr(int c)
|
|
|
1189 {
|
|
|
1190 if (prompt) {
|
|
|
1191 switch (c) {
|
|
|
1192 case 11: (void) printf("Range endpoint too large.\n");
|
|
|
1193 break;
|
|
|
1194 case 16: (void) printf("Bad number.\n");
|
|
|
1195 break;
|
|
|
1196 case 25: (void) printf("``\\digit'' out of range.\n");
|
|
|
1197 break;
|
|
|
1198 case 41: (void) printf("No remembered search string.\n");
|
|
|
1199 break;
|
|
|
1200 case 42: (void) printf("() imbalance.\n");
|
|
|
1201 break;
|
|
|
1202 case 43: (void) printf("Too many (.\n");
|
|
|
1203 break;
|
|
|
1204 case 44: (void) printf("More than 2 numbers given in { }.\n");
|
|
|
1205 break;
|
|
|
1206 case 45: (void) printf("} expected after \\.\n");
|
|
|
1207 break;
|
|
|
1208 case 46: (void) printf("First number exceeds second in { }.\n");
|
|
|
1209 break;
|
|
|
1210 case 49: (void) printf("[] imbalance.\n");
|
|
|
1211 break;
|
|
|
1212 case 50: (void) printf("Regular expression overflow.\n");
|
|
|
1213 break;
|
|
|
1214 case 67: (void) printf("Illegal byte sequence.\n");
|
|
|
1215 break;
|
|
|
1216 default: (void) printf("RE error.\n");
|
|
|
1217 break;
|
|
|
1218 }
|
|
|
1219 } else {
|
|
|
1220 (void) printf("?\n");
|
|
|
1221 }
|
|
|
1222 return (-1);
|
|
|
1223 }
|
|
|
1224
|
|
|
1225 static int
|
|
|
1226 err(int prt, char msg[])
|
|
|
1227 {
|
|
|
1228 if (prt) (prompt? (void) printf("%s\n", msg): (void) printf("?\n"));
|
|
|
1229 if (infildes != 0) {
|
|
|
1230 infildes = pop(fstack);
|
|
|
1231 charbuf = '\n';
|
|
|
1232 peeked = 0;
|
|
|
1233 flag3 = 0;
|
|
|
1234 flag2 = 0;
|
|
|
1235 flag = 0;
|
|
|
1236 }
|
|
|
1237 return (-1);
|
|
|
1238 }
|
|
|
1239
|
|
|
1240 static char
|
|
|
1241 mygetc()
|
|
|
1242 {
|
|
|
1243 if (!peeked) {
|
|
|
1244 while ((!(infildes == oldfd && flag)) && (!flag1) &&
|
|
|
1245 (!readc(infildes, &charbuf))) {
|
|
|
1246 if (infildes == 100 && (!flag)) flag1 = 1;
|
|
|
1247 if ((infildes = pop(fstack)) == -1) quit();
|
|
|
1248 if ((!flag1) && infildes == 0 && flag3 && prompt)
|
|
|
1249 (void) printf("*");
|
|
|
1250 }
|
|
|
1251 if (infildes == oldfd && flag) flag2 = 0;
|
|
|
1252 flag1 = 0;
|
|
|
1253 } else peeked = 0;
|
|
|
1254 return (charbuf);
|
|
|
1255 }
|
|
|
1256
|
|
|
1257 static int
|
|
|
1258 readc(int f, char *c)
|
|
|
1259 {
|
|
|
1260 if (f == 100) {
|
|
|
1261 if (!(*c = *intptr++)) {
|
|
|
1262 intptr--;
|
|
|
1263 charbuf = '\n';
|
|
|
1264 return (0);
|
|
|
1265 }
|
|
|
1266 } else if (read(f, c, 1) != 1) {
|
|
|
1267 (void) close(f);
|
|
|
1268 charbuf = '\n';
|
|
|
1269 return (0);
|
|
|
1270 }
|
|
|
1271 return (1);
|
|
|
1272 }
|
|
|
1273
|
|
|
1274 static int
|
|
|
1275 percent(char line[256])
|
|
|
1276 {
|
|
|
1277 char *lp, *var;
|
|
|
1278 char *front, *per, c[2], *olp, p[2], fr[256];
|
|
|
1279 int i, j;
|
|
|
1280
|
|
|
1281 per = p;
|
|
|
1282 var = c;
|
|
|
1283 front = fr;
|
|
|
1284 j = 0;
|
|
|
1285 while (!j) {
|
|
|
1286 j = 1;
|
|
|
1287 olp = line;
|
|
|
1288 intptr = internal;
|
|
|
1289 while (step(olp, perbuf)) {
|
|
|
1290 while (loc1 < loc2) *front++ = *loc1++;
|
|
|
1291 *(--front) = '\0';
|
|
|
1292 front = fr;
|
|
|
1293 *per++ = '%';
|
|
|
1294 *per = '\0';
|
|
|
1295 per = p;
|
|
|
1296 *var = *loc2;
|
|
|
1297 if ((i = 1 + strlen(front)) >= 2 && fr[i-2] == '\\') {
|
|
|
1298 (void) strcat(front, "");
|
|
|
1299 --intptr;
|
|
|
1300 (void) strcat(per, "");
|
|
|
1301 } else {
|
|
|
1302 if (!(*var >= '0' && *var <= '9'))
|
|
|
1303 return (err(1, "usage: %digit"));
|
|
|
1304 (void) strcat(front, "");
|
|
|
1305 (void) strcat(varray[*var-'0'], "");
|
|
|
1306 j = 0;
|
|
|
1307 loc2++; /* Compensate for removing --lp above */
|
|
|
1308 }
|
|
|
1309 olp = loc2;
|
|
|
1310 }
|
|
|
1311 (void) strcat(olp, "");
|
|
|
1312 *intptr = '\0';
|
|
|
1313 if (!j) {
|
|
|
1314 intptr = internal;
|
|
|
1315 lp = line;
|
|
|
1316 (void)
|
|
|
1317 strncpy(intptr, lp, sizeof (intptr)*sizeof (char));
|
|
|
1318 }
|
|
|
1319 }
|
|
|
1320 return (0);
|
|
|
1321 }
|
|
|
1322
|
|
|
1323 static int
|
|
|
1324 newfile(int prt, char f[])
|
|
|
1325 {
|
|
|
1326 int fd;
|
|
|
1327
|
|
|
1328 if (!*f) {
|
|
|
1329 if (flag != 0) {
|
|
|
1330 oldfd = infildes;
|
|
|
1331 intptr = comdlist;
|
|
|
1332 } else intptr = internal;
|
|
|
1333 fd = 100;
|
|
|
1334 } else if ((fd = open(f, 0)) < 0) {
|
|
|
1335 (void) snprintf(strtmp, sizeof (strtmp) * sizeof (char),
|
|
|
1336 "cannot open %s", f);
|
|
|
1337 return (err(prt, strtmp));
|
|
|
1338 }
|
|
|
1339
|
|
|
1340 push(fstack, infildes);
|
|
|
1341 if (flag4) oldfd = fd;
|
|
|
1342 infildes = fd;
|
|
|
1343 return (peeked = 0);
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 static void
|
|
|
1347 push(int s[], int d)
|
|
|
1348 {
|
|
|
1349 s[++s[0]] = d;
|
|
|
1350 }
|
|
|
1351
|
|
|
1352 static int
|
|
|
1353 pop(int s[])
|
|
|
1354 {
|
|
|
1355 return (s[s[0]--]);
|
|
|
1356 }
|
|
|
1357
|
|
|
1358 static int
|
|
|
1359 peekc()
|
|
|
1360 {
|
|
|
1361 int c;
|
|
|
1362
|
|
|
1363 c = mygetc();
|
|
|
1364 peeked = 1;
|
|
|
1365
|
|
|
1366 return (c);
|
|
|
1367 }
|
|
|
1368
|
|
|
1369 static void
|
|
|
1370 eat()
|
|
|
1371 {
|
|
|
1372 if (charbuf != '\n')
|
|
|
1373 while (mygetc() != '\n');
|
|
|
1374 peeked = 0;
|
|
|
1375 }
|
|
|
1376
|
|
|
1377 static int
|
|
|
1378 more()
|
|
|
1379 {
|
|
|
1380 if (mygetc() != '\n')
|
|
|
1381 return (err(1, "syntax"));
|
|
|
1382 return (0);
|
|
|
1383 }
|
|
|
1384
|
|
|
1385 static void
|
|
|
1386 quit()
|
|
|
1387 {
|
|
|
1388 exit(0);
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 static void
|
|
|
1392 out(char *ln)
|
|
|
1393 {
|
|
|
1394 char *rp, *wp, prev;
|
|
|
1395 int w, width;
|
|
|
1396 char *oldrp;
|
|
|
1397 wchar_t cl;
|
|
|
1398 int p;
|
|
|
1399 ptrdiff_t lim;
|
|
|
1400 if (crunch > 0) {
|
|
|
1401
|
|
|
1402 ln = untab(ln);
|
|
|
1403 rp = wp = ln - 1;
|
|
|
1404 prev = ' ';
|
|
|
1405
|
|
|
1406 while (*++rp) {
|
|
|
1407 if (prev != ' ' || *rp != ' ')
|
|
|
1408 *++wp = *rp;
|
|
|
1409 prev = *rp;
|
|
|
1410 }
|
|
|
1411 *++wp = '\n';
|
|
|
1412 lim = (ptrdiff_t)wp - (ptrdiff_t)ln;
|
|
|
1413 *++wp = '\0';
|
|
|
1414
|
|
|
1415 if (*ln == '\n')
|
|
|
1416 return;
|
|
|
1417 } else
|
|
|
1418 ln[lim = strlen(ln)] = '\n';
|
|
|
1419
|
|
|
1420 if (MB_CUR_MAX <= 1) {
|
|
|
1421 if (lim > trunc)
|
|
|
1422 ln[lim = trunc] = '\n';
|
|
|
1423 } else {
|
|
|
1424 if ((trunc < (BFSBUF -1)) || (lim > trunc)) {
|
|
|
1425 w = 0;
|
|
|
1426 oldrp = rp = ln;
|
|
|
1427 /*CONSTCOND*/while (1) {
|
|
|
1428 if ((p = mbtowc(&cl, rp, MB_LEN_MAX)) == 0) {
|
|
|
1429 break;
|
|
|
1430 }
|
|
|
1431 if (p == -1) {
|
|
|
1432 width = p = 1;
|
|
|
1433 } else {
|
|
|
1434 width = scrwidth(cl);
|
|
|
1435 if (width == 0)
|
|
|
1436 width = 1;
|
|
|
1437 }
|
|
|
1438 if ((w += width) > trunc)
|
|
|
1439 break;
|
|
|
1440 rp += p;
|
|
|
1441 }
|
|
|
1442 *rp = '\n';
|
|
|
1443 lim = (ptrdiff_t)rp - (ptrdiff_t)oldrp;
|
|
|
1444 }
|
|
|
1445 }
|
|
|
1446
|
|
|
1447 outcnt += write(outfildes, ln, lim+1);
|
|
|
1448 }
|
|
|
1449
|
|
|
1450 static char *
|
|
|
1451 untab(char l[])
|
|
|
1452 {
|
|
|
1453 static char line[BFSBUF];
|
|
|
1454 char *q, *s;
|
|
|
1455
|
|
|
1456 s = l;
|
|
|
1457 q = line;
|
|
|
1458 do {
|
|
|
1459 if (*s == '\t')
|
|
|
1460 do
|
|
|
1461 *q++ = ' ';
|
|
|
1462 while (((ptrdiff_t)q-(ptrdiff_t)line)%8);
|
|
|
1463 else *q++ = *s;
|
|
|
1464 } while (*s++);
|
|
|
1465 return (line);
|
|
|
1466 }
|
|
|
1467
|
|
|
1468 /*
|
|
|
1469 * Function to convert ascii string to integer. Converts
|
|
|
1470 * positive numbers only. Returns -1 if non-numeric
|
|
|
1471 * character encountered.
|
|
|
1472 */
|
|
|
1473
|
|
|
1474 static int
|
|
|
1475 patoi(char *b)
|
|
|
1476 {
|
|
|
1477 int i;
|
|
|
1478 char *a;
|
|
|
1479
|
|
|
1480 a = b;
|
|
|
1481 i = 0;
|
|
|
1482 while (*a >= '0' && *a <= '9') i = 10 * i + *a++ - '0';
|
|
|
1483
|
|
|
1484 if (*a)
|
|
|
1485 return (-1);
|
|
|
1486 return (i);
|
|
|
1487 }
|
|
|
1488
|
|
|
1489 /*
|
|
|
1490 * Compares 2 strings. Returns 1 if equal, 0 if not.
|
|
|
1491 */
|
|
|
1492
|
|
|
1493 static int
|
|
|
1494 equal(char *a, char *b)
|
|
|
1495 {
|
|
|
1496 char *x, *y;
|
|
|
1497
|
|
|
1498 x = a;
|
|
|
1499 y = b;
|
|
|
1500 while (*x == *y++)
|
|
|
1501 if (*x++ == 0)
|
|
|
1502 return (1);
|
|
|
1503 return (0);
|
|
|
1504 }
|
