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