1 /* $Header: consarg.c,v 3.0.1.7 90/10/15 15:55:28 lwall Locked $
3 * Copyright (c) 1989, Larry Wall
5 * You may distribute under the terms of the GNU General Public License
6 * as specified in the README file that comes with the perl 3.0 kit.
9 * Revision 3.0.1.7 90/10/15 15:55:28 lwall
10 * patch29: defined @foo was behaving inconsistently
11 * patch29: -5 % 5 was wrong
12 * patch29: package behavior is now more consistent
14 * Revision 3.0.1.6 90/08/09 02:38:51 lwall
15 * patch19: fixed problem with % of negative number
17 * Revision 3.0.1.5 90/03/27 15:36:45 lwall
18 * patch16: support for machines that can't cast negative floats to unsigned ints
20 * Revision 3.0.1.4 90/03/12 16:24:40 lwall
21 * patch13: return (@array) did counter-intuitive things
23 * Revision 3.0.1.3 90/02/28 16:47:54 lwall
24 * patch9: the x operator is now up to 10 times faster
25 * patch9: @_ clobbered by ($foo,$bar) = split
27 * Revision 3.0.1.2 89/11/17 15:11:34 lwall
28 * patch5: defined $foo{'bar'} should not create element
30 * Revision 3.0.1.1 89/11/11 04:14:30 lwall
31 * patch2: '-' x 26 made warnings about undefined value
32 * patch2: eval with no args caused strangeness
33 * patch2: local(@foo) didn't work, but local(@foo,$bar) did
35 * Revision 3.0 89/10/18 15:10:30 lwall
42 static int nothing_in_common();
43 static int arg_common();
44 static int spat_common();
47 make_split(stab,arg,limarg)
54 if (arg->arg_type != O_MATCH) {
55 Newz(201,spat,1,SPAT);
56 spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
57 curstash->tbl_spatroot = spat;
59 spat->spat_runtime = arg;
60 arg = make_match(O_MATCH,stab2arg(A_STAB,defstab),spat);
65 if (limarg->arg_type == O_ITEM) {
66 Copy(limarg+1,arg+3,1,ARG);
67 limarg[1].arg_type = A_NULL;
72 arg[3].arg_type = A_EXPR;
73 arg[3].arg_ptr.arg_arg = limarg;
77 arg[3].arg_type = A_NULL;
78 arg->arg_type = O_SPLIT;
79 spat = arg[2].arg_ptr.arg_spat;
80 spat->spat_repl = stab2arg(A_STAB,aadd(stab));
81 if (spat->spat_short) { /* exact match can bypass regexec() */
82 if (!((spat->spat_flags & SPAT_SCANFIRST) &&
83 (spat->spat_flags & SPAT_ALL) )) {
84 str_free(spat->spat_short);
85 spat->spat_short = Nullstr;
92 mod_match(type,left,pat)
103 if ((pat->arg_type == O_MATCH ||
104 pat->arg_type == O_SUBST ||
105 pat->arg_type == O_TRANS ||
106 pat->arg_type == O_SPLIT
108 pat[1].arg_ptr.arg_stab == defstab ) {
109 switch (pat->arg_type) {
111 newarg = make_op(type == O_MATCH ? O_MATCH : O_NMATCH,
113 left,Nullarg,Nullarg);
116 newarg = l(make_op(type == O_MATCH ? O_SUBST : O_NSUBST,
118 left,Nullarg,Nullarg));
121 newarg = l(make_op(type == O_MATCH ? O_TRANS : O_NTRANS,
123 left,Nullarg,Nullarg));
126 newarg = make_op(type == O_MATCH ? O_SPLIT : O_SPLIT,
128 left,Nullarg,Nullarg);
131 if (pat->arg_len >= 2) {
132 newarg[2].arg_type = pat[2].arg_type;
133 newarg[2].arg_ptr = pat[2].arg_ptr;
134 newarg[2].arg_flags = pat[2].arg_flags;
135 if (pat->arg_len >= 3) {
136 newarg[3].arg_type = pat[3].arg_type;
137 newarg[3].arg_ptr = pat[3].arg_ptr;
138 newarg[3].arg_flags = pat[3].arg_flags;
144 Newz(202,spat,1,SPAT);
145 spat->spat_next = curstash->tbl_spatroot; /* link into spat list */
146 curstash->tbl_spatroot = spat;
148 spat->spat_runtime = pat;
149 newarg = make_op(type,2,left,Nullarg,Nullarg);
150 newarg[2].arg_type = A_SPAT | A_DONT;
151 newarg[2].arg_ptr.arg_spat = spat;
158 make_op(type,newlen,arg1,arg2,arg3)
167 register unsigned doarg;
169 extern ARG *arg4; /* should be normal arguments, really */
172 arg = op_new(newlen);
173 arg->arg_type = type;
175 if (chld->arg_type == O_ITEM &&
176 (hoistable[ i = (chld[1].arg_type&A_MASK)] || i == A_LVAL ||
178 (chld[1].arg_ptr.arg_arg->arg_type == O_LIST ||
179 chld[1].arg_ptr.arg_arg->arg_type == O_ARRAY ||
180 chld[1].arg_ptr.arg_arg->arg_type == O_HASH ))))
182 arg[1].arg_type = chld[1].arg_type;
183 arg[1].arg_ptr = chld[1].arg_ptr;
184 arg[1].arg_flags |= chld[1].arg_flags;
185 arg[1].arg_len = chld[1].arg_len;
189 arg[1].arg_type = A_EXPR;
190 arg[1].arg_ptr.arg_arg = chld;
194 if (chld->arg_type == O_ITEM &&
195 (hoistable[chld[1].arg_type&A_MASK] ||
197 ((chld[1].arg_type == A_READ && !(arg[1].arg_type & A_DONT))
199 (chld[1].arg_type == A_INDREAD && !(arg[1].arg_type & A_DONT))
201 (chld[1].arg_type == A_GLOB && !(arg[1].arg_type & A_DONT))
203 arg[2].arg_type = chld[1].arg_type;
204 arg[2].arg_ptr = chld[1].arg_ptr;
205 arg[2].arg_len = chld[1].arg_len;
209 arg[2].arg_type = A_EXPR;
210 arg[2].arg_ptr.arg_arg = chld;
214 if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
215 arg[3].arg_type = chld[1].arg_type;
216 arg[3].arg_ptr = chld[1].arg_ptr;
217 arg[3].arg_len = chld[1].arg_len;
221 arg[3].arg_type = A_EXPR;
222 arg[3].arg_ptr.arg_arg = chld;
225 if (newlen >= 4 && (chld = arg4)) {
226 if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
227 arg[4].arg_type = chld[1].arg_type;
228 arg[4].arg_ptr = chld[1].arg_ptr;
229 arg[4].arg_len = chld[1].arg_len;
233 arg[4].arg_type = A_EXPR;
234 arg[4].arg_ptr.arg_arg = chld;
237 if (newlen >= 5 && (chld = arg5)) {
238 if (chld->arg_type == O_ITEM && hoistable[chld[1].arg_type&A_MASK]) {
239 arg[5].arg_type = chld[1].arg_type;
240 arg[5].arg_ptr = chld[1].arg_ptr;
241 arg[5].arg_len = chld[1].arg_len;
245 arg[5].arg_type = A_EXPR;
246 arg[5].arg_ptr.arg_arg = chld;
249 doarg = opargs[type];
250 for (i = 1; i <= newlen; ++i) {
252 arg[i].arg_type |= A_DONT;
254 arg[i].arg_flags |= AF_ARYOK;
259 fprintf(stderr,"%lx <= make_op(%s",arg,opname[arg->arg_type]);
261 fprintf(stderr,",%s=%lx",
262 argname[arg[1].arg_type&A_MASK],arg[1].arg_ptr.arg_arg);
264 fprintf(stderr,",%s=%lx",
265 argname[arg[2].arg_type&A_MASK],arg[2].arg_ptr.arg_arg);
267 fprintf(stderr,",%s=%lx",
268 argname[arg[3].arg_type&A_MASK],arg[3].arg_ptr.arg_arg);
270 fprintf(stderr,",%s=%lx",
271 argname[arg[4].arg_type&A_MASK],arg[4].arg_ptr.arg_arg);
273 fprintf(stderr,",%s=%lx",
274 argname[arg[5].arg_type&A_MASK],arg[5].arg_ptr.arg_arg);
275 fprintf(stderr,")\n");
278 evalstatic(arg); /* see if we can consolidate anything */
289 double value; /* must not be register */
292 unsigned long tmplong;
294 double exp(), log(), sqrt(), modf();
296 double sin(), cos(), atan2(), pow();
298 if (!arg || !arg->arg_len)
301 if ((arg[1].arg_type == A_SINGLE || arg->arg_type == O_AELEM) &&
302 (arg->arg_len == 1 || arg[2].arg_type == A_SINGLE) ) {
304 s1 = arg[1].arg_ptr.arg_str;
305 if (arg->arg_len > 1)
306 s2 = arg[2].arg_ptr.arg_str;
309 switch (arg->arg_type) {
311 i = (int)str_gnum(s2);
312 if (i < 32767 && i >= 0) {
313 arg->arg_type = O_ITEM;
315 arg[1].arg_type = A_ARYSTAB; /* $abc[123] is hoistable now */
322 str = Nullstr; /* can't be evaluated yet */
329 i = (int)str_gnum(s2);
332 STR_GROW(str, i * s1->str_cur + 1);
333 repeatcpy(str->str_ptr, tmps, s1->str_cur, i);
334 str->str_cur = i * s1->str_cur;
335 str->str_ptr[str->str_cur] = '\0';
338 value = str_gnum(s1);
339 str_numset(str,value * str_gnum(s2));
342 value = str_gnum(s2);
344 yyerror("Illegal division by constant zero");
346 str_numset(str,str_gnum(s1) / value);
349 tmplong = (unsigned long)str_gnum(s2);
351 yyerror("Illegal modulus of constant zero");
354 tmp2 = (long)str_gnum(s1);
357 str_numset(str,(double)(tmp2 % tmplong));
359 str_numset(str,(double)((tmplong-((-tmp2 - 1) % tmplong)) - 1));
365 value = str_gnum(s1);
366 str_numset(str,value + str_gnum(s2));
369 value = str_gnum(s1);
370 str_numset(str,value - str_gnum(s2));
373 value = str_gnum(s1);
374 i = (int)str_gnum(s2);
376 str_numset(str,(double)(((long)value) << i));
380 value = str_gnum(s1);
381 i = (int)str_gnum(s2);
383 str_numset(str,(double)(((long)value) >> i));
387 value = str_gnum(s1);
388 str_numset(str,(value < str_gnum(s2)) ? 1.0 : 0.0);
391 value = str_gnum(s1);
392 str_numset(str,(value > str_gnum(s2)) ? 1.0 : 0.0);
395 value = str_gnum(s1);
396 str_numset(str,(value <= str_gnum(s2)) ? 1.0 : 0.0);
399 value = str_gnum(s1);
400 str_numset(str,(value >= str_gnum(s2)) ? 1.0 : 0.0);
404 if ((!s1->str_nok && !looks_like_number(s1)) ||
405 (!s2->str_nok && !looks_like_number(s2)) )
406 warn("Possible use of == on string value");
408 value = str_gnum(s1);
409 str_numset(str,(value == str_gnum(s2)) ? 1.0 : 0.0);
412 value = str_gnum(s1);
413 str_numset(str,(value != str_gnum(s2)) ? 1.0 : 0.0);
416 value = str_gnum(s1);
417 value -= str_gnum(s2);
420 else if (value < 0.0)
422 str_numset(str,value);
425 value = str_gnum(s1);
427 str_numset(str,(double)(U_L(value) & U_L(str_gnum(s2))));
431 value = str_gnum(s1);
433 str_numset(str,(double)(U_L(value) ^ U_L(str_gnum(s2))));
437 value = str_gnum(s1);
439 str_numset(str,(double)(U_L(value) | U_L(str_gnum(s2))));
455 if ((arg[3].arg_type & A_MASK) != A_SINGLE) {
463 str_sset(str,arg[3].arg_ptr.arg_str);
464 str_free(arg[3].arg_ptr.arg_str);
468 str_numset(str,(double)(-str_gnum(s1)));
471 str_numset(str,(double)(!str_true(s1)));
475 str_numset(str,(double)(~U_L(str_gnum(s1))));
479 str_numset(str,sin(str_gnum(s1)));
482 str_numset(str,cos(str_gnum(s1)));
485 value = str_gnum(s1);
486 str_numset(str,atan2(value, str_gnum(s2)));
489 value = str_gnum(s1);
490 str_numset(str,pow(value, str_gnum(s2)));
493 str_numset(str, (double)str_len(s1));
496 str_numset(str,(double)(str_cmp(s1,s2) < 0));
499 str_numset(str,(double)(str_cmp(s1,s2) > 0));
502 str_numset(str,(double)(str_cmp(s1,s2) <= 0));
505 str_numset(str,(double)(str_cmp(s1,s2) >= 0));
508 str_numset(str,(double)(str_eq(s1,s2)));
511 str_numset(str,(double)(!str_eq(s1,s2)));
514 str_numset(str,(double)(str_cmp(s1,s2)));
519 str_set(str,crypt(tmps,str_get(s2)));
522 "The crypt() function is unimplemented due to excessive paranoia.");
526 str_numset(str,exp(str_gnum(s1)));
529 str_numset(str,log(str_gnum(s1)));
532 str_numset(str,sqrt(str_gnum(s1)));
535 value = str_gnum(s1);
537 (void)modf(value,&value);
539 (void)modf(-value,&value);
542 str_numset(str,value);
546 str_numset(str,(double)(*str_get(s1)));
554 str_numset(str,(double)(zapc));
560 arg->arg_type = O_ITEM; /* note arg1 type is already SINGLE */
563 arg[1].arg_ptr.arg_str = str;
578 i = arg[1].arg_type & A_MASK;
580 arg->arg_flags |= AF_COMMON; /* assume something in common */
581 /* which forces us to copy things */
584 arg[1].arg_type = A_LARYLEN;
587 if (i == A_ARYSTAB) {
588 arg[1].arg_type = A_LARYSTAB;
592 /* see if it's an array reference */
594 if (i == A_EXPR || i == A_LEXPR) {
595 arg1 = arg[1].arg_ptr.arg_arg;
597 if (arg1->arg_type == O_LIST || arg1->arg_type == O_ITEM) {
599 if (arg->arg_len > 1) {
601 arg2 = arg[2].arg_ptr.arg_arg;
602 if (nothing_in_common(arg1,arg2))
603 arg->arg_flags &= ~AF_COMMON;
604 if (arg->arg_type == O_ASSIGN) {
605 if (arg1->arg_flags & AF_LOCAL)
606 arg->arg_flags |= AF_LOCAL;
607 arg[1].arg_flags |= AF_ARYOK;
608 arg[2].arg_flags |= AF_ARYOK;
611 else if (arg->arg_type != O_CHOP)
612 arg->arg_type = O_ASSIGN; /* possible local(); */
613 for (i = arg1->arg_len; i >= 1; i--) {
614 switch (arg1[i].arg_type) {
615 case A_STAR: case A_LSTAR:
616 arg1[i].arg_type = A_LSTAR;
618 case A_STAB: case A_LVAL:
619 arg1[i].arg_type = A_LVAL;
621 case A_ARYLEN: case A_LARYLEN:
622 arg1[i].arg_type = A_LARYLEN;
624 case A_ARYSTAB: case A_LARYSTAB:
625 arg1[i].arg_type = A_LARYSTAB;
627 case A_EXPR: case A_LEXPR:
628 arg1[i].arg_type = A_LEXPR;
629 switch(arg1[i].arg_ptr.arg_arg->arg_type) {
630 case O_ARRAY: case O_LARRAY:
631 arg1[i].arg_ptr.arg_arg->arg_type = O_LARRAY;
634 case O_AELEM: case O_LAELEM:
635 arg1[i].arg_ptr.arg_arg->arg_type = O_LAELEM;
637 case O_HASH: case O_LHASH:
638 arg1[i].arg_ptr.arg_arg->arg_type = O_LHASH;
641 case O_HELEM: case O_LHELEM:
642 arg1[i].arg_ptr.arg_arg->arg_type = O_LHELEM;
644 case O_ASLICE: case O_LASLICE:
645 arg1[i].arg_ptr.arg_arg->arg_type = O_LASLICE;
647 case O_HSLICE: case O_LHSLICE:
648 arg1[i].arg_ptr.arg_arg->arg_type = O_LHSLICE;
656 (void)sprintf(tokenbuf, "Illegal item (%s) as lvalue",
657 argname[arg1[i].arg_type&A_MASK]);
661 if (arg->arg_len > 1) {
662 if (arg2->arg_type == O_SPLIT && !arg2[3].arg_type && !arghog) {
663 arg2[3].arg_type = A_SINGLE;
664 arg2[3].arg_ptr.arg_str =
665 str_nmake((double)arg1->arg_len + 1); /* limit split len*/
669 else if (arg1->arg_type == O_AELEM || arg1->arg_type == O_LAELEM)
670 if (arg->arg_type == O_DEFINED)
671 arg1->arg_type = O_AELEM;
673 arg1->arg_type = O_LAELEM;
674 else if (arg1->arg_type == O_ARRAY || arg1->arg_type == O_LARRAY) {
675 arg1->arg_type = O_LARRAY;
676 if (arg->arg_len > 1) {
678 arg2 = arg[2].arg_ptr.arg_arg;
679 if (arg2->arg_type == O_SPLIT) { /* use split's builtin =?*/
680 spat = arg2[2].arg_ptr.arg_spat;
681 if (!(spat->spat_flags & SPAT_ONCE) &&
682 nothing_in_common(arg1,spat->spat_repl)) {
683 spat->spat_repl[1].arg_ptr.arg_stab =
684 arg1[1].arg_ptr.arg_stab;
685 spat->spat_flags |= SPAT_ONCE;
686 arg_free(arg1); /* recursive */
687 free_arg(arg); /* non-recursive */
688 return arg2; /* split has builtin assign */
691 else if (nothing_in_common(arg1,arg2))
692 arg->arg_flags &= ~AF_COMMON;
693 if (arg->arg_type == O_ASSIGN) {
694 arg[1].arg_flags |= AF_ARYOK;
695 arg[2].arg_flags |= AF_ARYOK;
698 else if (arg->arg_type == O_ASSIGN)
699 arg[1].arg_flags |= AF_ARYOK;
701 else if (arg1->arg_type == O_HELEM || arg1->arg_type == O_LHELEM)
702 if (arg->arg_type == O_DEFINED)
703 arg1->arg_type = O_HELEM; /* avoid creating one */
705 arg1->arg_type = O_LHELEM;
706 else if (arg1->arg_type == O_HASH || arg1->arg_type == O_LHASH) {
707 arg1->arg_type = O_LHASH;
708 if (arg->arg_len > 1) {
710 arg2 = arg[2].arg_ptr.arg_arg;
711 if (nothing_in_common(arg1,arg2))
712 arg->arg_flags &= ~AF_COMMON;
713 if (arg->arg_type == O_ASSIGN) {
714 arg[1].arg_flags |= AF_ARYOK;
715 arg[2].arg_flags |= AF_ARYOK;
718 else if (arg->arg_type == O_ASSIGN)
719 arg[1].arg_flags |= AF_ARYOK;
721 else if (arg1->arg_type == O_ASLICE) {
722 arg1->arg_type = O_LASLICE;
723 if (arg->arg_type == O_ASSIGN) {
724 arg[1].arg_flags |= AF_ARYOK;
725 arg[2].arg_flags |= AF_ARYOK;
728 else if (arg1->arg_type == O_HSLICE) {
729 arg1->arg_type = O_LHSLICE;
730 if (arg->arg_type == O_ASSIGN) {
731 arg[1].arg_flags |= AF_ARYOK;
732 arg[2].arg_flags |= AF_ARYOK;
735 else if ((arg->arg_type == O_DEFINED || arg->arg_type == O_UNDEF) &&
736 (arg1->arg_type == (perldb ? O_DBSUBR : O_SUBR)) ) {
737 arg[1].arg_type |= A_DONT;
739 else if (arg1->arg_type == O_SUBSTR || arg1->arg_type == O_VEC) {
741 Renewc(arg1->arg_ptr.arg_str, 1, struct lstring, STR);
742 /* grow string struct to hold an lstring struct */
744 else if (arg1->arg_type == O_ASSIGN) {
745 if (arg->arg_type == O_CHOP)
746 arg[1].arg_flags &= ~AF_ARYOK; /* grandfather chop idiom */
749 (void)sprintf(tokenbuf,
750 "Illegal expression (%s) as lvalue",opname[arg1->arg_type]);
753 arg[1].arg_type = A_LEXPR | (arg[1].arg_type & A_DONT);
754 if (arg->arg_type == O_ASSIGN && (arg1[1].arg_flags & AF_ARYOK)) {
755 arg[1].arg_flags |= AF_ARYOK;
756 if (arg->arg_len > 1)
757 arg[2].arg_flags |= AF_ARYOK;
761 fprintf(stderr,"lval LEXPR\n");
765 if (i == A_STAR || i == A_LSTAR) {
766 arg[1].arg_type = A_LSTAR | (arg[1].arg_type & A_DONT);
770 /* not an array reference, should be a register name */
772 if (i != A_STAB && i != A_LVAL) {
773 (void)sprintf(tokenbuf,
774 "Illegal item (%s) as lvalue",argname[arg[1].arg_type&A_MASK]);
777 arg[1].arg_type = A_LVAL | (arg[1].arg_type & A_DONT);
780 fprintf(stderr,"lval LVAL\n");
790 if (type == O_DEFINED || type == O_UNDEF) {
791 if (arg->arg_type != O_ITEM)
793 if (arg->arg_type == O_ITEM) {
794 type = arg[1].arg_type & A_MASK;
795 if (type == A_EXPR || type == A_LEXPR)
796 arg[1].arg_type = A_LEXPR|A_DONT;
807 if (arg[i].arg_type != A_EXPR) { /* dehoist */
808 tmparg = make_op(O_ITEM,1,Nullarg,Nullarg,Nullarg);
810 arg[i].arg_ptr.arg_arg = tmparg;
811 arg[i].arg_type = A_EXPR;
816 addflags(i,flags,arg)
819 arg[i].arg_flags |= flags;
827 if (arg->arg_type == O_ARRAY || arg->arg_type == O_HASH)
828 return make_op(O_ITEM,1,arg,Nullarg,Nullarg);
832 /* maybe do a join on multiple array dimensions */
838 if (arg && arg->arg_type == O_COMMA) {
840 arg = make_op(O_JOIN, 2,
841 stab2arg(A_STAB,stabent(";",TRUE)),
854 register ARG *nxtnode;
860 arg->arg_type = O_LIST;
862 if (arg->arg_type != O_COMMA) {
863 if (arg->arg_type != O_ARRAY)
864 arg->arg_flags |= AF_LISTISH; /* see listish() below */
867 for (i = 2, node = arg; ; i++) {
868 if (node->arg_len < 2)
870 if (node[1].arg_type != A_EXPR)
872 node = node[1].arg_ptr.arg_arg;
873 if (node->arg_type != O_COMMA)
879 tmpstr = arg->arg_ptr.arg_str;
881 *arg = *node; /* copy everything except the STR */
883 (void)bcopy((char *)node, (char *)arg, sizeof(ARG));
885 arg->arg_ptr.arg_str = tmpstr;
890 (void)bcopy((char *)(node+2), (char *)(arg+j), sizeof(ARG));
892 arg[j].arg_flags |= AF_ARYOK;
893 --j; /* Bug in Xenix compiler */
898 (void)bcopy((char *)(node+1), (char *)(arg+1), sizeof(ARG));
903 nxtnode = node[1].arg_ptr.arg_arg;
908 arg[1].arg_flags |= AF_ARYOK;
909 arg[2].arg_flags |= AF_ARYOK;
910 arg->arg_type = O_LIST;
915 /* turn a single item into a list */
921 if (arg->arg_flags & AF_LISTISH)
922 arg = make_op(O_LIST,1,arg,Nullarg,Nullarg);
927 maybelistish(optype, arg)
933 if (optype == O_RETURN && arg->arg_type == O_ITEM &&
934 arg[1].arg_type == A_EXPR && (tmparg = arg[1].arg_ptr.arg_arg) &&
935 ((tmparg->arg_flags & AF_LISTISH) || (tmparg->arg_type == O_ARRAY) )) {
936 tmparg = listish(tmparg);
940 else if (optype == O_PRTF ||
941 (arg->arg_type == O_ASLICE || arg->arg_type == O_HSLICE ||
942 arg->arg_type == O_F_OR_R) )
947 /* mark list of local variables */
953 arg->arg_flags |= AF_LOCAL;
961 if (arg->arg_type == O_CONCAT && arg[2].arg_type == A_READ) {
962 arg->arg_type = O_RCAT;
963 arg[2].arg_type = arg[2].arg_ptr.arg_arg[1].arg_type;
964 arg[2].arg_ptr = arg[2].arg_ptr.arg_arg[1].arg_ptr;
965 free_arg(arg[2].arg_ptr.arg_arg);
978 arg->arg_type = O_ITEM;
979 arg[1].arg_type = atype;
980 arg[1].arg_ptr.arg_stab = stab;
991 arg->arg_type = O_ITEM;
992 arg[1].arg_type = A_SINGLE;
993 arg[1].arg_ptr.arg_str = str_make(cval,0);
1004 Newz(203,arg, numargs + 1, ARG);
1005 arg->arg_ptr.arg_str = Str_new(21,0);
1006 arg->arg_len = numargs;
1014 str_free(arg->arg_ptr.arg_str);
1019 make_match(type,expr,spat)
1026 arg = make_op(type,2,expr,Nullarg,Nullarg);
1028 arg[2].arg_type = A_SPAT|A_DONT;
1029 arg[2].arg_ptr.arg_spat = spat;
1032 fprintf(stderr,"make_match SPAT=%lx\n",(long)spat);
1035 if (type == O_SUBST || type == O_NSUBST) {
1036 if (arg[1].arg_type != A_STAB) {
1037 yyerror("Illegal lvalue");
1039 arg[1].arg_type = A_LVAL;
1051 arg->arg_type = O_ITEM;
1052 arg[1].arg_type = A_CMD;
1053 arg[1].arg_ptr.arg_cmd = cmd;
1057 /* Check two expressions to see if there is any identifier in common */
1060 nothing_in_common(arg1,arg2)
1064 static int thisexpr = 0; /* I don't care if this wraps */
1067 if (arg_common(arg1,thisexpr,1))
1068 return 0; /* hit eval or do {} */
1069 if (arg_common(arg2,thisexpr,0))
1070 return 0; /* hit identifier again */
1074 /* Recursively descend an expression and mark any identifier or check
1075 * it to see if it was marked already.
1079 arg_common(arg,exprnum,marking)
1088 for (i = arg->arg_len; i >= 1; i--) {
1089 switch (arg[i].arg_type & A_MASK) {
1094 if (arg_common(arg[i].arg_ptr.arg_arg,exprnum,marking))
1098 return 1; /* assume hanky panky */
1106 stab_lastexpr(arg[i].arg_ptr.arg_stab) = exprnum;
1107 else if (stab_lastexpr(arg[i].arg_ptr.arg_stab) == exprnum)
1113 register char *s = arg[i].arg_ptr.arg_str->str_ptr;
1114 register char *send = s + arg[i].arg_ptr.arg_str->str_cur;
1115 register STAB *stab;
1118 if (*s == '$' && s[1]) {
1119 s = scanreg(s,send,tokenbuf);
1120 stab = stabent(tokenbuf,TRUE);
1122 stab_lastexpr(stab) = exprnum;
1123 else if (stab_lastexpr(stab) == exprnum)
1127 else if (*s == '\\' && s[1])
1134 if (spat_common(arg[i].arg_ptr.arg_spat,exprnum,marking))
1145 switch (arg->arg_type) {
1148 if ((arg[1].arg_type & A_MASK) == A_STAB)
1149 (void)aadd(arg[1].arg_ptr.arg_stab);
1153 if ((arg[1].arg_type & A_MASK) == A_STAB)
1154 (void)hadd(arg[1].arg_ptr.arg_stab);
1165 spat_common(spat,exprnum,marking)
1166 register SPAT *spat;
1170 if (spat->spat_runtime)
1171 if (arg_common(spat->spat_runtime,exprnum,marking))
1173 if (spat->spat_repl) {
1174 if (arg_common(spat->spat_repl,exprnum,marking))