Import tcsh-6.17.00
[dragonfly.git] / contrib / tcsh-6 / sh.dol.c
CommitLineData
57e3f2b5 1/* $Header: /p/tcsh/cvsroot/tcsh/sh.dol.c,v 3.77 2009/06/19 16:25:00 christos Exp $ */
7d8fb588
MS
2/*
3 * sh.dol.c: Variable substitutions
4 */
5/*-
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33#include "sh.h"
34
57e3f2b5 35RCSID("$tcsh: sh.dol.c,v 3.77 2009/06/19 16:25:00 christos Exp $")
7d8fb588
MS
36
37/*
38 * C shell
39 */
40
41/*
42 * These routines perform variable substitution and quoting via ' and ".
43 * To this point these constructs have been preserved in the divided
44 * input words. Here we expand variables and turn quoting via ' and " into
45 * QUOTE bits on characters (which prevent further interpretation).
46 * If the `:q' modifier was applied during history expansion, then
47 * some QUOTEing may have occurred already, so we dont "trim()" here.
48 */
49
50static Char Dpeekc; /* Peek for DgetC */
51static eChar Dpeekrd; /* Peek for Dreadc */
52static Char *Dcp, *const *Dvp; /* Input vector for Dreadc */
53
54#define DEOF CHAR_ERR
55
56#define unDgetC(c) Dpeekc = c
57
58#define QUOTES (_QF|_QB|_ESC) /* \ ' " ` */
59
60/*
61 * The following variables give the information about the current
62 * $ expansion, recording the current word position, the remaining
63 * words within this expansion, the count of remaining words, and the
64 * information about any : modifier which is being applied.
65 */
66static Char *dolp; /* Remaining chars from this word */
67static Char **dolnxt; /* Further words */
68static int dolcnt; /* Count of further words */
69static struct Strbuf dolmod; /* = Strbuf_INIT; : modifier characters */
70static int dolmcnt; /* :gx -> INT_MAX, else 1 */
71static int dol_flag_a; /* :ax -> 1, else 0 */
72
73static Char **Dfix2 (Char *const *);
74static int Dpack (struct Strbuf *);
75static int Dword (struct blk_buf *);
76static void dolerror (Char *);
77static eChar DgetC (int);
78static void Dgetdol (void);
79static void fixDolMod (void);
80static void setDolp (Char *);
81static void unDredc (eChar);
82static eChar Dredc (void);
83static void Dtestq (Char);
84
85/*
86 * Fix up the $ expansions and quotations in the
87 * argument list to command t.
88 */
89void
90Dfix(struct command *t)
91{
92 Char **pp;
93 Char *p;
94
95 if (noexec)
96 return;
97 /* Note that t_dcom isn't trimmed thus !...:q's aren't lost */
98 for (pp = t->t_dcom; (p = *pp++) != NULL;) {
99 for (; *p; p++) {
100 if (cmap(*p, _DOL | QUOTES)) { /* $, \, ', ", ` */
101 Char **expanded;
102
103 expanded = Dfix2(t->t_dcom); /* found one */
104 blkfree(t->t_dcom);
105 t->t_dcom = expanded;
106 return;
107 }
108 }
109 }
110}
111
112/*
113 * $ substitute one word, for i/o redirection
114 */
115Char *
116Dfix1(Char *cp)
117{
118 Char *Dv[2], **expanded;
119
120 if (noexec)
121 return (0);
122 Dv[0] = cp;
123 Dv[1] = NULL;
124 expanded = Dfix2(Dv);
125 if (expanded[0] == NULL || expanded[1] != NULL) {
126 blkfree(expanded);
127 setname(short2str(cp));
128 stderror(ERR_NAME | ERR_AMBIG);
129 }
130 cp = Strsave(expanded[0]);
131 blkfree(expanded);
132 return (cp);
133}
134
135/*
136 * Subroutine to do actual fixing after state initialization.
137 */
138static Char **
139Dfix2(Char *const *v)
140{
57e3f2b5
SS
141 struct blk_buf *bb = bb_alloc();
142 Char **vec;
7d8fb588
MS
143
144 Dvp = v;
145 Dcp = STRNULL; /* Setup input vector for Dreadc */
146 unDgetC(0);
147 unDredc(0); /* Clear out any old peeks (at error) */
148 dolp = 0;
149 dolcnt = 0; /* Clear out residual $ expands (...) */
57e3f2b5
SS
150 cleanup_push(bb, bb_free);
151 while (Dword(bb))
7d8fb588 152 continue;
57e3f2b5
SS
153 cleanup_ignore(bb);
154 cleanup_until(bb);
155 vec = bb_finish(bb);
156 xfree(bb);
157 return vec;
7d8fb588
MS
158}
159
160/*
161 * Pack up more characters in this word
162 */
163static int
164Dpack(struct Strbuf *wbuf)
165{
166 eChar c;
167
168 for (;;) {
169 c = DgetC(DODOL);
170 if (c == '\\') {
171 c = DgetC(0);
172 if (c == DEOF) {
173 unDredc(c);
174 return 1;
175 }
176 if (c == '\n')
177 c = ' ';
178 else
179 c |= QUOTE;
180 }
181 if (c == DEOF) {
182 unDredc(c);
183 return 1;
184 }
185 if (cmap(c, _SP | _NL | _QF | _QB)) { /* sp \t\n'"` */
186 unDgetC(c);
187 if (cmap(c, QUOTES))
188 return 0;
189 return 1;
190 }
191 Strbuf_append1(wbuf, (Char) c);
192 }
193}
194
195/*
196 * Get a word. This routine is analogous to the routine
197 * word() in sh.lex.c for the main lexical input. One difference
198 * here is that we don't get a newline to terminate our expansion.
199 * Rather, DgetC will return a DEOF when we hit the end-of-input.
200 */
201static int
202Dword(struct blk_buf *bb)
203{
204 eChar c, c1;
57e3f2b5 205 struct Strbuf *wbuf = Strbuf_alloc();
7d8fb588
MS
206 int dolflg;
207 int sofar = 0;
57e3f2b5 208 Char *str;
7d8fb588 209
57e3f2b5 210 cleanup_push(wbuf, Strbuf_free);
7d8fb588
MS
211 for (;;) {
212 c = DgetC(DODOL);
213 switch (c) {
214
215 case DEOF:
216 if (sofar == 0) {
57e3f2b5 217 cleanup_until(wbuf);
7d8fb588
MS
218 return (0);
219 }
220 /* finish this word and catch the code above the next time */
221 unDredc(c);
222 /*FALLTHROUGH*/
223
224 case '\n':
225 goto end;
226
227 case ' ':
228 case '\t':
229 continue;
230
231 case '`':
232 /* We preserve ` quotations which are done yet later */
57e3f2b5 233 Strbuf_append1(wbuf, (Char) c);
7d8fb588
MS
234 /*FALLTHROUGH*/
235 case '\'':
236 case '"':
237 /*
238 * Note that DgetC never returns a QUOTES character from an
239 * expansion, so only true input quotes will get us here or out.
240 */
241 c1 = c;
242 dolflg = c1 == '"' ? DODOL : 0;
243 for (;;) {
244 c = DgetC(dolflg);
245 if (c == c1)
246 break;
57e3f2b5
SS
247 if (c == '\n' || c == DEOF) {
248 cleanup_until(bb);
7d8fb588 249 stderror(ERR_UNMATCHED, (int)c1);
57e3f2b5 250 }
7d8fb588 251 if ((c & (QUOTE | TRIM)) == ('\n' | QUOTE)) {
57e3f2b5
SS
252 if (wbuf->len != 0 && (wbuf->s[wbuf->len - 1] & TRIM) == '\\')
253 wbuf->len--;
7d8fb588
MS
254 }
255 switch (c1) {
256
257 case '"':
258 /*
259 * Leave any `s alone for later. Other chars are all
260 * quoted, thus `...` can tell it was within "...".
261 */
57e3f2b5 262 Strbuf_append1(wbuf, c == '`' ? '`' : c | QUOTE);
7d8fb588
MS
263 break;
264
265 case '\'':
266 /* Prevent all further interpretation */
57e3f2b5 267 Strbuf_append1(wbuf, c | QUOTE);
7d8fb588
MS
268 break;
269
270 case '`':
271 /* Leave all text alone for later */
57e3f2b5 272 Strbuf_append1(wbuf, (Char) c);
7d8fb588
MS
273 break;
274
275 default:
276 break;
277 }
278 }
279 if (c1 == '`')
57e3f2b5 280 Strbuf_append1(wbuf, '`');
7d8fb588 281 sofar = 1;
57e3f2b5 282 if (Dpack(wbuf) != 0)
7d8fb588
MS
283 goto end;
284 continue;
285
286 case '\\':
287 c = DgetC(0); /* No $ subst! */
288 if (c == '\n' || c == DEOF)
289 continue;
290 c |= QUOTE;
291 break;
292
293 default:
294 break;
295 }
296 unDgetC(c);
297 sofar = 1;
57e3f2b5 298 if (Dpack(wbuf) != 0)
7d8fb588
MS
299 goto end;
300 }
301
302 end:
57e3f2b5
SS
303 cleanup_ignore(wbuf);
304 cleanup_until(wbuf);
305 str = Strbuf_finish(wbuf);
306 bb_append(bb, str);
307 xfree(wbuf);
7d8fb588
MS
308 return 1;
309}
310
311
312/*
313 * Get a character, performing $ substitution unless flag is 0.
314 * Any QUOTES character which is returned from a $ expansion is
315 * QUOTEd so that it will not be recognized above.
316 */
317static eChar
318DgetC(int flag)
319{
320 Char c;
321
322top:
323 if ((c = Dpeekc) != 0) {
324 Dpeekc = 0;
325 return (c);
326 }
327 if (lap < labuf.len) {
328 c = labuf.s[lap++] & (QUOTE | TRIM);
329quotspec:
330 if (cmap(c, QUOTES))
331 return (c | QUOTE);
332 return (c);
333 }
334 if (dolp) {
335 if ((c = *dolp++ & (QUOTE | TRIM)) != 0)
336 goto quotspec;
337 if (dolcnt > 0) {
338 setDolp(*dolnxt++);
339 --dolcnt;
340 return (' ');
341 }
342 dolp = 0;
343 }
344 if (dolcnt > 0) {
345 setDolp(*dolnxt++);
346 --dolcnt;
347 goto top;
348 }
349 c = Dredc();
350 if (c == '$' && flag) {
351 Dgetdol();
352 goto top;
353 }
354 return (c);
355}
356
357static Char *nulvec[] = { NULL };
358static struct varent nulargv = {nulvec, STRargv, VAR_READWRITE,
359 { NULL, NULL, NULL }, 0 };
360
361static void
362dolerror(Char *s)
363{
364 setname(short2str(s));
365 stderror(ERR_NAME | ERR_RANGE);
366}
367
368/*
369 * Handle the multitudinous $ expansion forms.
370 * Ugh.
371 */
372static void
373Dgetdol(void)
374{
375 Char *np;
376 struct varent *vp = NULL;
57e3f2b5 377 struct Strbuf *name = Strbuf_alloc();
7d8fb588
MS
378 eChar c, sc;
379 int subscr = 0, lwb = 1, upb = 0;
380 int dimen = 0, bitset = 0, length = 0;
381 static Char *dolbang = NULL;
382
57e3f2b5 383 cleanup_push(name, Strbuf_free);
7d8fb588
MS
384 dolmod.len = dolmcnt = dol_flag_a = 0;
385 c = sc = DgetC(0);
386 if (c == DEOF) {
387 stderror(ERR_SYNTAX);
388 return;
389 }
390 if (c == '{')
391 c = DgetC(0); /* sc is { to take } later */
392 if ((c & TRIM) == '#')
393 dimen++, c = DgetC(0); /* $# takes dimension */
394 else if (c == '?')
395 bitset++, c = DgetC(0); /* $? tests existence */
396 else if (c == '%')
397 length++, c = DgetC(0); /* $% returns length in chars */
398 switch (c) {
399
400 case '!':
401 if (dimen || bitset || length)
402 stderror(ERR_SYNTAX);
403 if (backpid != 0) {
404 xfree(dolbang);
405 setDolp(dolbang = putn(backpid));
406 }
57e3f2b5 407 cleanup_until(name);
7d8fb588
MS
408 goto eatbrac;
409
410 case '$':
411 if (dimen || bitset || length)
412 stderror(ERR_SYNTAX);
413 setDolp(doldol);
57e3f2b5 414 cleanup_until(name);
7d8fb588
MS
415 goto eatbrac;
416
417 case '<'|QUOTE: {
418 static struct Strbuf wbuf; /* = Strbuf_INIT; */
419
420 if (bitset)
421 stderror(ERR_NOTALLOWED, "$?<");
422 if (dimen)
423 stderror(ERR_NOTALLOWED, "$#<");
424 if (length)
425 stderror(ERR_NOTALLOWED, "$%<");
426 wbuf.len = 0;
427 {
428 char cbuf[MB_LEN_MAX];
429 size_t cbp = 0;
430 int old_pintr_disabled;
431
432 for (;;) {
433 int len;
434 ssize_t res;
435 Char wc;
436
437 pintr_push_enable(&old_pintr_disabled);
438 res = force_read(OLDSTD, cbuf + cbp, 1);
439 cleanup_until(&old_pintr_disabled);
440 if (res != 1)
441 break;
442 cbp++;
443 len = normal_mbtowc(&wc, cbuf, cbp);
444 if (len == -1) {
445 reset_mbtowc();
446 if (cbp < MB_LEN_MAX)
447 continue; /* Maybe a partial character */
448 wc = (unsigned char)*cbuf | INVALID_BYTE;
449 }
450 if (len <= 0)
451 len = 1;
452 if (cbp != (size_t)len)
453 memmove(cbuf, cbuf + len, cbp - len);
454 cbp -= len;
455 if (wc == '\n')
456 break;
457 Strbuf_append1(&wbuf, wc);
458 }
459 while (cbp != 0) {
460 int len;
461 Char wc;
462
463 len = normal_mbtowc(&wc, cbuf, cbp);
464 if (len == -1) {
465 reset_mbtowc();
466 wc = (unsigned char)*cbuf | INVALID_BYTE;
467 }
468 if (len <= 0)
469 len = 1;
470 if (cbp != (size_t)len)
471 memmove(cbuf, cbuf + len, cbp - len);
472 cbp -= len;
473 if (wc == '\n')
474 break;
475 Strbuf_append1(&wbuf, wc);
476 }
477 Strbuf_terminate(&wbuf);
478 }
479
480 fixDolMod();
481 setDolp(wbuf.s); /* Kept allocated until next $< expansion */
57e3f2b5 482 cleanup_until(name);
7d8fb588
MS
483 goto eatbrac;
484 }
485
486 case '*':
57e3f2b5
SS
487 Strbuf_append(name, STRargv);
488 Strbuf_terminate(name);
7d8fb588
MS
489 vp = adrof(STRargv);
490 subscr = -1; /* Prevent eating [...] */
491 break;
492
493 case DEOF:
494 case '\n':
495 np = dimen ? STRargv : (bitset ? STRstatus : NULL);
496 if (np) {
497 bitset = 0;
57e3f2b5
SS
498 Strbuf_append(name, np);
499 Strbuf_terminate(name);
7d8fb588
MS
500 vp = adrof(np);
501 subscr = -1; /* Prevent eating [...] */
502 unDredc(c);
503 break;
504 }
505 else
506 stderror(ERR_SYNTAX);
507 /*NOTREACHED*/
508
509 default:
510 if (Isdigit(c)) {
511 if (dimen)
512 stderror(ERR_NOTALLOWED, "$#<num>");
513 subscr = 0;
514 do {
515 subscr = subscr * 10 + c - '0';
516 c = DgetC(0);
517 } while (c != DEOF && Isdigit(c));
518 unDredc(c);
519 if (subscr < 0)
520 stderror(ERR_RANGE);
521 if (subscr == 0) {
522 if (bitset) {
523 dolp = dolzero ? STR1 : STR0;
57e3f2b5 524 cleanup_until(name);
7d8fb588
MS
525 goto eatbrac;
526 }
527 if (ffile == 0)
528 stderror(ERR_DOLZERO);
529 if (length) {
530 length = Strlen(ffile);
531 addla(putn(length));
532 }
533 else {
534 fixDolMod();
535 setDolp(ffile);
536 }
57e3f2b5 537 cleanup_until(name);
7d8fb588
MS
538 goto eatbrac;
539 }
540#if 0
541 if (bitset)
542 stderror(ERR_NOTALLOWED, "$?<num>");
543 if (length)
544 stderror(ERR_NOTALLOWED, "$%<num>");
545#endif
546 vp = adrof(STRargv);
547 if (vp == 0) {
548 vp = &nulargv;
57e3f2b5 549 cleanup_until(name);
7d8fb588
MS
550 goto eatmod;
551 }
552 break;
553 }
554 if (c == DEOF || !alnum(c)) {
555 np = dimen ? STRargv : (bitset ? STRstatus : NULL);
556 if (np) {
557 bitset = 0;
57e3f2b5
SS
558 Strbuf_append(name, np);
559 Strbuf_terminate(name);
7d8fb588
MS
560 vp = adrof(np);
561 subscr = -1; /* Prevent eating [...] */
562 unDredc(c);
563 break;
564 }
565 else
566 stderror(ERR_VARALNUM);
567 }
568 for (;;) {
57e3f2b5 569 Strbuf_append1(name, (Char) c);
7d8fb588
MS
570 c = DgetC(0);
571 if (c == DEOF || !alnum(c))
572 break;
573 }
57e3f2b5 574 Strbuf_terminate(name);
7d8fb588 575 unDredc(c);
57e3f2b5 576 vp = adrof(name->s);
7d8fb588
MS
577 }
578 if (bitset) {
57e3f2b5
SS
579 dolp = (vp || getenv(short2str(name->s))) ? STR1 : STR0;
580 cleanup_until(name);
7d8fb588
MS
581 goto eatbrac;
582 }
583 if (vp == NULL || vp->vec == NULL) {
57e3f2b5 584 np = str2short(getenv(short2str(name->s)));
7d8fb588
MS
585 if (np) {
586 static Char *env_val; /* = NULL; */
587
57e3f2b5 588 cleanup_until(name);
7d8fb588 589 fixDolMod();
57e3f2b5
SS
590 if (length) {
591 addla(putn(Strlen(np)));
592 } else {
593 xfree(env_val);
594 env_val = Strsave(np);
595 setDolp(env_val);
596 }
7d8fb588
MS
597 goto eatbrac;
598 }
57e3f2b5 599 udvar(name->s);
7d8fb588
MS
600 /* NOTREACHED */
601 }
57e3f2b5 602 cleanup_until(name);
7d8fb588
MS
603 c = DgetC(0);
604 upb = blklen(vp->vec);
605 if (dimen == 0 && subscr == 0 && c == '[') {
57e3f2b5
SS
606 name = Strbuf_alloc();
607 cleanup_push(name, Strbuf_free);
608 np = name->s;
7d8fb588
MS
609 for (;;) {
610 c = DgetC(DODOL); /* Allow $ expand within [ ] */
611 if (c == ']')
612 break;
613 if (c == '\n' || c == DEOF)
614 stderror(ERR_INCBR);
57e3f2b5 615 Strbuf_append1(name, (Char) c);
7d8fb588 616 }
57e3f2b5
SS
617 Strbuf_terminate(name);
618 np = name->s;
7d8fb588
MS
619 if (dolp || dolcnt) /* $ exp must end before ] */
620 stderror(ERR_EXPORD);
621 if (!*np)
622 stderror(ERR_SYNTAX);
623 if (Isdigit(*np)) {
624 int i;
625
626 for (i = 0; Isdigit(*np); i = i * 10 + *np++ - '0')
627 continue;
57e3f2b5
SS
628 if (i < 0 || i > upb && !any("-*", *np)) {
629 cleanup_until(name);
7d8fb588
MS
630 dolerror(vp->v_name);
631 return;
632 }
633 lwb = i;
634 if (!*np)
635 upb = lwb, np = STRstar;
636 }
637 if (*np == '*')
638 np++;
639 else if (*np != '-')
640 stderror(ERR_MISSING, '-');
641 else {
642 int i = upb;
643
644 np++;
645 if (Isdigit(*np)) {
646 i = 0;
647 while (Isdigit(*np))
648 i = i * 10 + *np++ - '0';
649 if (i < 0 || i > upb) {
57e3f2b5 650 cleanup_until(name);
7d8fb588
MS
651 dolerror(vp->v_name);
652 return;
653 }
654 }
655 if (i < lwb)
656 upb = lwb - 1;
657 else
658 upb = i;
659 }
660 if (lwb == 0) {
661 if (upb != 0) {
57e3f2b5 662 cleanup_until(name);
7d8fb588
MS
663 dolerror(vp->v_name);
664 return;
665 }
666 upb = -1;
667 }
668 if (*np)
669 stderror(ERR_SYNTAX);
57e3f2b5 670 cleanup_until(name);
7d8fb588
MS
671 }
672 else {
673 if (subscr > 0) {
674 if (subscr > upb)
675 lwb = 1, upb = 0;
676 else
677 lwb = upb = subscr;
678 }
679 unDredc(c);
680 }
681 if (dimen) {
682 /* this is a kludge. It prevents Dgetdol() from */
683 /* pushing erroneous ${#<error> values into the labuf. */
684 if (sc == '{') {
685 c = Dredc();
686 if (c != '}')
687 stderror(ERR_MISSING, '}');
688 unDredc(c);
689 }
690 addla(putn(upb - lwb + 1));
691 }
692 else if (length) {
693 int i;
694
695 for (i = lwb - 1, length = 0; i < upb; i++)
696 length += Strlen(vp->vec[i]);
697#ifdef notdef
698 /* We don't want that, since we can always compute it by adding $#xxx */
699 length += i - 1; /* Add the number of spaces in */
700#endif
701 addla(putn(length));
702 }
703 else {
704eatmod:
705 fixDolMod();
706 dolnxt = &vp->vec[lwb - 1];
707 dolcnt = upb - lwb + 1;
708 }
709eatbrac:
710 if (sc == '{') {
711 c = Dredc();
712 if (c != '}')
713 stderror(ERR_MISSING, '}');
714 }
715}
716
717static void
718fixDolMod(void)
719{
720 eChar c;
721
722 c = DgetC(0);
723 if (c == ':') {
724 do {
725 c = DgetC(0), dolmcnt = 1, dol_flag_a = 0;
726 if (c == 'g' || c == 'a') {
727 if (c == 'g')
728 dolmcnt = INT_MAX;
729 else
730 dol_flag_a = 1;
731 c = DgetC(0);
732 }
733 if ((c == 'g' && dolmcnt != INT_MAX) ||
734 (c == 'a' && dol_flag_a == 0)) {
735 if (c == 'g')
736 dolmcnt = INT_MAX;
737 else
738 dol_flag_a = 1;
739 c = DgetC(0);
740 }
741
742 if (c == 's') { /* [eichin:19910926.0755EST] */
743 int delimcnt = 2;
744 eChar delim = DgetC(0);
745 Strbuf_append1(&dolmod, (Char) c);
746 Strbuf_append1(&dolmod, (Char) delim);
747
748 if (delim == DEOF || !delim || letter(delim)
749 || Isdigit(delim) || any(" \t\n", delim)) {
750 seterror(ERR_BADSUBST);
751 break;
752 }
753 while ((c = DgetC(0)) != DEOF) {
754 Strbuf_append1(&dolmod, (Char) c);
755 if(c == delim) delimcnt--;
756 if(!delimcnt) break;
757 }
758 if(delimcnt) {
759 seterror(ERR_BADSUBST);
760 break;
761 }
762 continue;
763 }
764 if (!any("luhtrqxes", c))
765 stderror(ERR_BADMOD, (int)c);
766 Strbuf_append1(&dolmod, (Char) c);
767 if (c == 'q')
768 dolmcnt = INT_MAX;
769 }
770 while ((c = DgetC(0)) == ':');
771 unDredc(c);
772 }
773 else
774 unDredc(c);
775}
776
777static void
778setDolp(Char *cp)
779{
780 Char *dp;
781 size_t i;
782
783 if (dolmod.len == 0 || dolmcnt == 0) {
784 dolp = cp;
785 return;
786 }
787 cp = Strsave(cp);
788 for (i = 0; i < dolmod.len; i++) {
789 int didmod = 0;
790
791 /* handle s// [eichin:19910926.0510EST] */
792 if(dolmod.s[i] == 's') {
793 Char delim;
794 Char *lhsub, *rhsub, *np;
795 size_t lhlen = 0, rhlen = 0;
796
797 delim = dolmod.s[++i];
798 if (!delim || letter(delim)
799 || Isdigit(delim) || any(" \t\n", delim)) {
800 seterror(ERR_BADSUBST);
801 break;
802 }
803 lhsub = &dolmod.s[++i];
804 while(dolmod.s[i] != delim && dolmod.s[++i]) {
805 lhlen++;
806 }
807 dolmod.s[i] = 0;
808 rhsub = &dolmod.s[++i];
809 while(dolmod.s[i] != delim && dolmod.s[++i]) {
810 rhlen++;
811 }
812 dolmod.s[i] = 0;
813
814 strip(lhsub);
57e3f2b5 815 strip(rhsub);
7d8fb588
MS
816 strip(cp);
817 dp = cp;
818 do {
819 dp = Strstr(dp, lhsub);
820 if (dp) {
821 ptrdiff_t diff = dp - cp;
57e3f2b5
SS
822 size_t len = (Strlen(cp) + 1 - lhlen + rhlen);
823 np = xmalloc(len * sizeof(Char));
7d8fb588
MS
824 (void) Strncpy(np, cp, diff);
825 (void) Strcpy(np + diff, rhsub);
826 (void) Strcpy(np + diff + rhlen, dp + lhlen);
827
828 dp = np + diff + 1;
829 xfree(cp);
830 cp = np;
57e3f2b5 831 cp[--len] = '\0';
7d8fb588 832 didmod = 1;
57e3f2b5
SS
833 if (diff >= len)
834 break;
7d8fb588
MS
835 } else {
836 /* should this do a seterror? */
837 break;
838 }
839 }
840 while (dol_flag_a != 0);
841 /*
842 * restore dolmod for additional words
843 */
844 dolmod.s[i] = rhsub[-1] = (Char) delim;
845 } else {
846
847 do {
848 if ((dp = domod(cp, dolmod.s[i])) != NULL) {
849 didmod = 1;
850 if (Strcmp(cp, dp) == 0) {
851 xfree(cp);
852 cp = dp;
853 break;
854 }
855 else {
856 xfree(cp);
857 cp = dp;
858 }
859 }
860 else
861 break;
862 }
863 while (dol_flag_a != 0);
864 }
865 if (didmod && dolmcnt != INT_MAX)
866 dolmcnt--;
867#ifdef notdef
868 else
869 break;
870#endif
871 }
872
873 addla(cp);
874
875 dolp = STRNULL;
876 if (seterr)
877 stderror(ERR_OLD);
878}
879
880static void
881unDredc(eChar c)
882{
883
884 Dpeekrd = c;
885}
886
887static eChar
888Dredc(void)
889{
890 Char c;
891
892 if ((c = Dpeekrd) != 0) {
893 Dpeekrd = 0;
894 return (c);
895 }
896 if (Dcp && (c = *Dcp++))
897 return (c & (QUOTE | TRIM));
898 if (*Dvp == 0) {
899 Dcp = 0;
900 return (DEOF);
901 }
902 Dcp = *Dvp++;
903 return (' ');
904}
905
906static int gflag;
907
908static void
909Dtestq(Char c)
910{
911
912 if (cmap(c, QUOTES))
913 gflag = 1;
914}
915
916static void
917inheredoc_cleanup(void *dummy)
918{
919 USE(dummy);
920 inheredoc = 0;
921}
922
923/*
924 * Form a shell temporary file (in unit 0) from the words
925 * of the shell input up to EOF or a line the same as "term".
926 * Unit 0 should have been closed before this call.
927 */
928void
929heredoc(Char *term)
930{
931 eChar c;
932 Char *Dv[2];
933 struct Strbuf lbuf = Strbuf_INIT, mbuf = Strbuf_INIT;
934 Char obuf[BUFSIZE + 1];
935#define OBUF_END (obuf + sizeof(obuf) / sizeof (*obuf) - 1)
936 Char *lbp, *obp, *mbp;
937 Char **vp;
938 int quoted;
939 char *tmp;
940#ifndef WINNT_NATIVE
941 struct timeval tv;
942
943again:
944#endif /* WINNT_NATIVE */
945 tmp = short2str(shtemp);
946#ifndef O_CREAT
947# define O_CREAT 0
948 if (xcreat(tmp, 0600) < 0)
949 stderror(ERR_SYSTEM, tmp, strerror(errno));
950#endif
951 xclose(0);
952#ifndef O_TEMPORARY
953# define O_TEMPORARY 0
954#endif
955#ifndef O_EXCL
956# define O_EXCL 0
957#endif
958 if (xopen(tmp, O_RDWR|O_CREAT|O_EXCL|O_TEMPORARY|O_LARGEFILE, 0600) ==
959 -1) {
960 int oerrno = errno;
961#ifndef WINNT_NATIVE
962 if (errno == EEXIST) {
963 if (unlink(tmp) == -1) {
964 (void) gettimeofday(&tv, NULL);
965 xfree(shtemp);
966 mbp = putn((((int)tv.tv_sec) ^
967 ((int)tv.tv_usec) ^ ((int)getpid())) & 0x00ffffff);
968 shtemp = Strspl(STRtmpsh, mbp);
969 xfree(mbp);
970 }
971 goto again;
972 }
973#endif /* WINNT_NATIVE */
974 (void) unlink(tmp);
975 errno = oerrno;
976 stderror(ERR_SYSTEM, tmp, strerror(errno));
977 }
978 (void) unlink(tmp); /* 0 0 inode! */
979 Dv[0] = term;
980 Dv[1] = NULL;
981 gflag = 0;
982 trim(Dv);
983 rscan(Dv, Dtestq);
984 quoted = gflag;
985 obp = obuf;
986 obuf[BUFSIZE] = 0;
987 inheredoc = 1;
988 cleanup_push(&inheredoc, inheredoc_cleanup);
989#ifdef WINNT_NATIVE
990 __dup_stdin = 1;
991#endif /* WINNT_NATIVE */
7d8fb588
MS
992 cleanup_push(&lbuf, Strbuf_cleanup);
993 cleanup_push(&mbuf, Strbuf_cleanup);
994 for (;;) {
995 Char **words;
996
997 /*
998 * Read up a line
999 */
1000 lbuf.len = 0;
1001 for (;;) {
1002 c = readc(1); /* 1 -> Want EOF returns */
1003 if (c == CHAR_ERR || c == '\n')
1004 break;
1005 if ((c &= TRIM) != 0)
1006 Strbuf_append1(&lbuf, (Char) c);
1007 }
1008 Strbuf_terminate(&lbuf);
1009
1010 /*
1011 * Check for EOF or compare to terminator -- before expansion
1012 */
1013 if (c == CHAR_ERR || eq(lbuf.s, term))
1014 break;
1015
1016 /*
1017 * If term was quoted or -n just pass it on
1018 */
1019 if (quoted || noexec) {
1020 Strbuf_append1(&lbuf, '\n');
1021 Strbuf_terminate(&lbuf);
1022 for (lbp = lbuf.s; (c = *lbp++) != 0;) {
1023 *obp++ = (Char) c;
1024 if (obp == OBUF_END) {
1025 tmp = short2str(obuf);
1026 (void) xwrite(0, tmp, strlen (tmp));
1027 obp = obuf;
1028 }
1029 }
1030 continue;
1031 }
1032
1033 /*
1034 * Term wasn't quoted so variable and then command expand the input
1035 * line
1036 */
1037 Dcp = lbuf.s;
1038 Dvp = Dv + 1;
1039 mbuf.len = 0;
1040 for (;;) {
1041 c = DgetC(DODOL);
1042 if (c == DEOF)
1043 break;
1044 if ((c &= TRIM) == 0)
1045 continue;
1046 /* \ quotes \ $ ` here */
1047 if (c == '\\') {
1048 c = DgetC(0);
1049 if (!any("$\\`", c))
1050 unDgetC(c | QUOTE), c = '\\';
1051 else
1052 c |= QUOTE;
1053 }
1054 Strbuf_append1(&mbuf, (Char) c);
1055 }
1056 Strbuf_terminate(&mbuf);
1057
1058 /*
1059 * If any ` in line do command substitution
1060 */
1061 mbp = mbuf.s;
1062 if (Strchr(mbp, '`') != NULL) {
1063 /*
1064 * 1 arg to dobackp causes substitution to be literal. Words are
1065 * broken only at newlines so that all blanks and tabs are
1066 * preserved. Blank lines (null words) are not discarded.
1067 */
1068 words = dobackp(mbp, 1);
1069 }
1070 else
1071 /* Setup trivial vector similar to return of dobackp */
1072 Dv[0] = mbp, Dv[1] = NULL, words = Dv;
1073
1074 /*
1075 * Resurrect the words from the command substitution each separated by
1076 * a newline. Note that the last newline of a command substitution
1077 * will have been discarded, but we put a newline after the last word
1078 * because this represents the newline after the last input line!
1079 */
1080 for (vp= words; *vp; vp++) {
1081 for (mbp = *vp; *mbp; mbp++) {
1082 *obp++ = *mbp & TRIM;
1083 if (obp == OBUF_END) {
1084 tmp = short2str(obuf);
1085 (void) xwrite(0, tmp, strlen (tmp));
1086 obp = obuf;
1087 }
1088 }
1089 *obp++ = '\n';
1090 if (obp == OBUF_END) {
1091 tmp = short2str(obuf);
1092 (void) xwrite(0, tmp, strlen (tmp));
1093 obp = obuf;
1094 }
1095 }
1096 if (words != Dv)
1097 blkfree(words);
1098 }
1099 *obp = 0;
1100 tmp = short2str(obuf);
1101 (void) xwrite(0, tmp, strlen (tmp));
1102 (void) lseek(0, (off_t) 0, L_SET);
1103 cleanup_until(&inheredoc);
1104}