56 WORD MatchE(
PHEAD WORD *pattern, WORD *fun, WORD *inter, WORD par)
59 WORD *m, *t, *r, i, retval;
60 WORD *mstop, *tstop, j, newvalue, newfun;
61 WORD fixvec[MAXMATCH],wcvec[MAXMATCH],fixind[MAXMATCH],wcind[MAXMATCH];
62 WORD tfixvec[MAXMATCH],tfixind[MAXMATCH];
63 WORD vwc,vfix,ifix,iwc,tvfix,tifix,nv,ni;
64 WORD sign = 0, *rstop, first1, first2, first3, funwild;
65 WORD *OldWork, nwstore, oRepFunNum;
70 offset = WORDDIF(fun,AN.terstart);
71 if ( pattern[1] != fun[1] )
return(0);
72 if ( *pattern >= FUNCTION+WILDOFFSET ) {
73 if ( CheckWild(BHEAD *pattern-WILDOFFSET,FUNTOFUN,*fun,&newfun) )
return(0);
77 mstop = pattern + pattern[1];
79 m = pattern + FUNHEAD;
82 if ( *m != *t )
break;
86 AN.RepFunList[AN.RepFunNum++] = offset;
87 AN.RepFunList[AN.RepFunNum++] = 0;
88 newpat = pattern + pattern[1];
91 t = OldWork = AT.WorkPointer;
92 nwstore = i = (m[-SUBEXPSIZE+1]-SUBEXPSIZE)/4;
96 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
99 if ( t >= AT.WorkTop ) {
100 MLOCK(ErrorMessageLock);
102 MUNLOCK(ErrorMessageLock);
106 AddWild(BHEAD *pattern-WILDOFFSET,FUNTOFUN,newfun);
107 if ( newpat >= AN.patstop ) {
108 if ( AN.UseFindOnly == 0 ) {
109 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
110 AN.UsedOtherFind = 1;
119 retval = ScanFunctions(BHEAD newpat,inter,par);
123 t = OldWork; r = AT.WildMask; i = nwstore;
126 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
130 AT.WorkPointer = OldWork;
134 if ( newpat >= AN.patstop ) {
135 if ( AN.UseFindOnly == 0 ) {
136 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
137 AN.UsedOtherFind = 1;
145 i = ScanFunctions(BHEAD newpat,inter,par);
163 while ( r < mstop ) {
164 if ( *r < (AM.OffsetVector+WILDOFFSET) ) {
166 sign += vwc + ifix + iwc;
168 else if ( *r < MINSPEC ) {
172 else if ( *r < (AM.OffsetIndex+WILDOFFSET) ) {
176 else if ( *r < (AM.OffsetIndex+(WILDOFFSET<<1)) ) {
185 if ( iwc == 0 && vwc == 0 )
return(0);
193 while ( t < tstop ) {
196 if ( m < mstop && *t == *m ) {
200 sign += WORDDIF(mstop,m);
201 tfixvec[tvfix++] = *t;
206 if ( r < rstop && *r == *t ) {
210 sign += WORDDIF(rstop,r);
211 tfixind[tifix++] = *t;
216 if ( m < mstop || r < rstop )
return(0);
217 if ( tvfix < vwc || (tvfix+tifix) < (vwc+iwc) )
return(0);
218 sign += ( nv - vfix - vwc ) & ni;
230 if ( *wv == VECTOVEC ) {
231 for ( ni = 0; ni < vwc; ni++ ) {
232 if ( wcvec[ni]-WILDOFFSET == wv[2] ) {
236 wcvec[ni] = wcvec[ni+1];
240 for ( ni = 0; ni < tvfix; ni++ ) {
241 if ( tfixvec[ni] == wv[3] ) {
244 while ( ni < tvfix ) {
245 tfixvec[ni] = tfixvec[ni+1];
255 else if ( *wv == INDTOIND ) {
256 for ( ni = 0; ni < iwc; ni++ ) {
257 if ( wcind[ni]-WILDOFFSET == wv[2] ) {
261 wcind[ni] = wcind[ni+1];
264 for ( ni = 0; ni < tifix; ni++ ) {
265 if ( tfixind[ni] == wv[3] ) {
268 while ( ni < tifix ) {
269 tfixind[ni] = tfixind[ni+1];
281 else if ( *wv == VECTOSUB ) {
282 for ( ni = 0; ni < vwc; ni++ ) {
283 if ( wcvec[ni]-WILDOFFSET == wv[2] )
return(0);
286 else if ( *wv == INDTOSUB ) {
287 for ( ni = 0; ni < iwc; ni++ ) {
288 if ( wcind[ni]-WILDOFFSET == wv[2] )
return(0);
297 while ( n > 0 && ( *wv == FROMSET || *wv == SETTONUM
298 || *wv == LOADDOLLAR ) ) { wv += wv[1]; wm++; n--; }
331 if ( tvfix < vwc ) {
return(0); }
334 perm1.objects = tfixvec;
337 perm2.objects = tfixind;
338 distr.n1 = tvfix - vwc;
340 distr.obj1 = tfixvec + vwc;
341 distr.obj2 = tfixind;
348 t = OldWork = AT.WorkPointer;
349 nwstore = i = (m[-SUBEXPSIZE+1]-SUBEXPSIZE)/4;
353 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
356 if ( t >= AT.WorkTop ) {
357 MLOCK(ErrorMessageLock);
359 MUNLOCK(ErrorMessageLock);
363 while ( (first1 = Permute(&perm1,first1) ) == 0 ) {
365 while ( (first2 = Permute(&perm2,first2) ) == 0 ) {
367 while ( (first3 = Distribute(&distr,first3) ) == 0 ) {
371 for ( i = 0; i < vwc; i++ ) {
372 j = wcvec[i] - WILDOFFSET;
373 if ( CheckWild(BHEAD j,VECTOVEC,tfixvec[i],&newvalue) )
375 AddWild(BHEAD j,VECTOVEC,newvalue);
377 for ( i = 0; i < iwc; i++ ) {
378 j = wcind[i] - WILDOFFSET;
379 if ( CheckWild(BHEAD j,INDTOIND,fixvec[i],&newvalue) )
381 AddWild(BHEAD j,INDTOIND,newvalue);
386 oRepFunNum = AN.RepFunNum;
387 AN.RepFunList[AN.RepFunNum++] = offset;
388 AN.RepFunList[AN.RepFunNum++] =
389 ( perm1.sign + perm2.sign + distr.sign + sign ) & 1;
390 newpat = pattern + pattern[1];
391 if ( funwild ) AddWild(BHEAD *pattern-WILDOFFSET,FUNTOFUN,newfun);
392 if ( newpat >= AN.patstop ) {
393 if ( AN.UseFindOnly == 0 ) {
394 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
395 AN.UsedOtherFind = 1;
403 if ( ScanFunctions(BHEAD newpat,inter,par) ) {
return(1); }
408 AN.RepFunNum = oRepFunNum;
409 NoCaseB: m = AN.WildValue;
410 t = OldWork; r = AT.WildMask; i = nwstore;
413 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
420 AT.WorkPointer = OldWork;
443 WORD Permute(
PERM *perm, WORD first)
447 perm->sign = ( perm->sign <= 1 ) ? 0: 1;
448 for ( i = 0; i < perm->n; i++ ) perm->cycle[i] = 0;
456 while ( --j >= 0 ) { *s = s[1]; s++; }
458 if ( ( i & 1 ) != 0 ) perm->sign ^= 1;
459 if ( perm->cycle[i] < i ) {
477 WORD *to, *from, *inc, *from2, i, j;
479 d->n = d->n1 + d->n2;
482 for ( i = 0; i < d->n2; i++ ) {
494 if ( d->n1 == 0 || d->n2 == 0 )
return(1);
499 while ( *inc ) { j++; inc++; }
500 while ( !*inc && inc < from ) { i++; inc++; }
501 if ( inc >= from )
return(1);
502 d->sign ^= ((i&j)-j+1) & 1;
505 while ( --j >= 0 ) *--inc = 1;
506 while ( --i > 0 ) *--inc = 0;
510 for ( i = 0; i < d->n; i++ ) {
536 int MatchCy(
PHEAD WORD *pattern, WORD *fun, WORD *inter, WORD par)
539 WORD *t, *tstop, *p, *pstop, *m, *r, *oldworkpointer = AT.WorkPointer;
540 WORD *thewildcards, *multiplicity, *renum, wc, newvalue, oldwilval = 0;
541 WORD *params, *lowlevel = 0;
542 int argcount = 0, funnycount = 0, tcount = fun[1] - FUNHEAD;
543 int type = 0, pnum, i, j, k, nwstore, iraise, itop, sumeat;
544 CBUF *C = cbuf+AT.ebufnum;
545 int ntwa = 3*AN.NumTotWildArgs+1;
547 WORD offset = fun-AN.terstart, *newpat;
549 if ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
551 nwstore = (AN.WildValue[-SUBEXPSIZE+1]-SUBEXPSIZE)/4;
552 if ( pnum > FUNCTION + WILDOFFSET ) {
554 if ( CheckWild(BHEAD pnum,FUNTOFUN,fun[0],&newvalue) )
return(0);
556 t = lowlevel = AT.WorkPointer;
562 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
566 if ( t >= AT.WorkTop ) {
567 MLOCK(ErrorMessageLock);
569 MUNLOCK(ErrorMessageLock);
573 AddWild(BHEAD pnum,FUNTOFUN,newvalue);
575 if ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
579 p = pattern + FUNHEAD;
580 pstop = pattern + pattern[1];
581 while ( p < pstop ) {
582 if ( *p == FUNNYWILD ) { p += 2; funnycount++; }
583 else { p++; argcount++; }
585 if ( argcount > tcount )
goto NoSuccess;
586 if ( argcount < tcount && funnycount == 0 )
goto NoSuccess;
587 if ( argcount == 0 && tcount == 0 && funnycount == 0 ) {
588 AN.RepFunList[AN.RepFunNum++] = offset;
589 AN.RepFunList[AN.RepFunNum++] = 0;
590 newpat = pattern + pattern[1];
591 if ( newpat >= AN.patstop ) {
592 if ( AN.UseFindOnly == 0 ) {
593 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
594 AT.WorkPointer = oldworkpointer;
595 AN.UsedOtherFind = 1;
601 AT.WorkPointer = oldworkpointer;
605 else j = ScanFunctions(BHEAD newpat,inter,par);
609 tstop = fun + fun[1];
613 params = AT.WorkPointer;
614 thewildcards = t = params + tcount;
616 if ( oldwilval ) lowlevel = oldworkpointer;
623 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
627 if ( t >= AT.WorkTop ) {
628 MLOCK(ErrorMessageLock);
630 MUNLOCK(ErrorMessageLock);
637 if ( argcount == tcount ) {
638 if ( funnycount > 0 ) {
639 p = pattern + FUNHEAD;
641 while ( p < pstop ) {
642 if ( *p != FUNNYWILD ) { p++;
continue; }
644 if ( CheckWild(BHEAD p[1],ARGTOARG,0,t) )
goto nomatch;
645 AddWild(BHEAD p[1],ARGTOARG,0);
650 for ( k = 0; k <= type; k++ ) {
652 p = params; t = fun + FUNHEAD;
653 while ( t < tstop ) *p++ = *t++;
656 p = params+tcount; t = fun + FUNHEAD;
657 while ( t < tstop ) *--p = *t++;
659 for ( i = 0; i < tcount; i++ ) {
660 p = pattern + FUNHEAD;
662 for ( j = 0; j < tcount; j++, p++ ) {
663 while ( *p == FUNNYWILD ) p += 2;
664 t = params + (i+j)%tcount;
665 if ( *t == *p )
continue;
666 if ( *p >= AM.OffsetIndex + WILDOFFSET
667 && *p < AM.OffsetIndex + 2*WILDOFFSET ) {
671 wc = *p - WILDOFFSET;
672 if ( CheckWild(BHEAD wc,INDTOIND,*t,&newvalue) )
break;
673 AddWild(BHEAD wc,INDTOIND,newvalue);
675 else if ( *t < MINSPEC && p[j] < MINSPEC
676 && *p >= AM.OffsetVector + WILDOFFSET ) {
680 wc = *p - WILDOFFSET;
681 if ( CheckWild(BHEAD wc,VECTOVEC,*t,&newvalue) )
break;
682 AddWild(BHEAD wc,VECTOVEC,newvalue);
690 AN.RepFunList[AN.RepFunNum++] = offset;
691 AN.RepFunList[AN.RepFunNum++] = 0;
693 if ( funnycount > 0 ) {
694 p = pattern + FUNHEAD;
696 while ( p < pstop ) {
697 if ( *p != FUNNYWILD ) { p++;
continue; }
699 AddWild(BHEAD p[1],ARGTOARG,0);
703 newpat = pattern + pattern[1];
704 if ( newpat >= AN.patstop ) {
705 if ( AN.UseFindOnly == 0 ) {
706 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
707 AT.WorkPointer = oldworkpointer;
708 AN.UsedOtherFind = 1;
714 AT.WorkPointer = oldworkpointer;
718 else j = ScanFunctions(BHEAD newpat,inter,par);
720 AT.WorkPointer = oldworkpointer;
728 if ( wc && nwstore > 0 ) {
731 t = thewildcards + ntwa; r = AT.WildMask;
734 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
748 if ( funnycount == 1 ) {
749 funnycount = tcount - argcount;
750 for ( k = 0; k <= type; k++ ) {
752 p = params; t = fun + FUNHEAD;
753 while ( t < tstop ) *p++ = *t++;
756 p = params+tcount; t = fun + FUNHEAD;
757 while ( t < tstop ) *--p = *t++;
759 for ( i = 0; i < tcount; i++ ) {
760 p = pattern + FUNHEAD;
763 for ( j = 0; j < tcount; j++, p++, t++ ) {
764 if ( *t == *p )
continue;
765 if ( *p == FUNNYWILD ) {
768 if ( CheckWild(BHEAD *p,ARGTOARG,funnycount|EATTENSOR,t) )
break;
769 AddWild(BHEAD *p,ARGTOARG,funnycount|EATTENSOR);
770 j += funnycount-1; t += funnycount-1;
772 else if ( *p >= AM.OffsetIndex + WILDOFFSET
773 && *p < AM.OffsetIndex + 2*WILDOFFSET ) {
777 wc = *p - WILDOFFSET;
778 if ( CheckWild(BHEAD wc,INDTOIND,*t,&newvalue) )
break;
779 AddWild(BHEAD wc,INDTOIND,newvalue);
781 else if ( *t < MINSPEC && *p < MINSPEC
782 && *p >= AM.OffsetVector + WILDOFFSET ) {
786 wc = *p - WILDOFFSET;
787 if ( CheckWild(BHEAD wc,VECTOVEC,*t,&newvalue) )
break;
788 AddWild(BHEAD wc,VECTOVEC,newvalue);
796 AN.RepFunList[AN.RepFunNum++] = offset;
797 AN.RepFunList[AN.RepFunNum++] = 0;
798 newpat = pattern + pattern[1];
799 if ( newpat >= AN.patstop ) {
800 if ( AN.UseFindOnly == 0 ) {
801 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
802 AT.WorkPointer = oldworkpointer;
803 AN.UsedOtherFind = 1;
809 AT.WorkPointer = oldworkpointer;
813 else j = ScanFunctions(BHEAD newpat,inter,par);
815 AT.WorkPointer = oldworkpointer;
826 t = thewildcards + ntwa; r = AT.WildMask;
829 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
837 for ( j = 1; j < tcount; j++ ) { *t = t[1]; t++; }
848 sumeat = tcount - argcount;
857 for ( i = funnycount; i < ntwa; i++ ) thewildcards[i] = -1;
858 multiplicity = thewildcards + funnycount;
859 renum = multiplicity + funnycount;
861 while ( p < pstop ) {
862 if ( *p != FUNNYWILD ) { p++;
continue; }
864 if ( renum[*p] < 0 ) {
869 else multiplicity[renum[*p]]++;
875 for ( i = 1; i < AN.NumTotWildArgs; i++ ) {
876 if ( renum[i] < 0 )
continue;
877 for ( j = i+1; j <= AN.NumTotWildArgs; j++ ) {
878 if ( renum[j] < 0 )
continue;
879 if ( renum[i] < renum[j] )
continue;
880 k = multiplicity[renum[i]];
881 multiplicity[renum[i]] = multiplicity[renum[j]];
882 multiplicity[renum[j]] = k;
883 k = renum[i]; renum[i] = renum[j]; renum[j] = k;
886 for ( i = 0; i < funnycount; i++ ) thewildcards[i] = 0;
887 iraise = funnycount-1;
889 for ( i = 0, j = sumeat; i < iraise; i++ )
890 j -= thewildcards[i]*multiplicity[i];
891 if ( j < 0 || j % multiplicity[iraise] != 0 ) {
893 thewildcards[iraise-1]++;
897 while ( itop > 0 && j < 0 ) {
898 j += thewildcards[itop]*multiplicity[itop];
899 thewildcards[itop] = 0;
902 if ( itop <= 0 && j <= 0 )
break;
903 thewildcards[itop]++;
906 thewildcards[iraise] = j / multiplicity[iraise];
908 for ( k = 0; k <= type; k++ ) {
910 p = params; t = fun + FUNHEAD;
911 while ( t < tstop ) *p++ = *t++;
914 p = params+tcount; t = fun + FUNHEAD;
915 while ( t < tstop ) *--p = *t++;
917 for ( i = 0; i < tcount; i++ ) {
918 p = pattern + FUNHEAD;
921 for ( j = 0; j < tcount; j++, p++, t++ ) {
922 if ( *t == *p )
continue;
923 if ( *p == FUNNYWILD ) {
924 p++; wc = thewildcards[renum[*p]];
926 if ( CheckWild(BHEAD *p,ARGTOARG,wc|EATTENSOR,t) )
break;
927 AddWild(BHEAD *p,ARGTOARG,wc|EATTENSOR);
928 j += wc-1; t += wc-1; wc = 1;
930 else if ( *p >= AM.OffsetIndex + WILDOFFSET
931 && *p < AM.OffsetIndex + 2*WILDOFFSET ) {
935 wc = *p - WILDOFFSET;
936 if ( CheckWild(BHEAD wc,INDTOIND,*t,&newvalue) )
break;
937 AddWild(BHEAD wc,INDTOIND,newvalue);
939 else if ( *t < MINSPEC && *p < MINSPEC
940 && *p >= AM.OffsetVector + WILDOFFSET ) {
944 wc = *p - WILDOFFSET;
945 if ( CheckWild(BHEAD wc,VECTOVEC,*t,&newvalue) )
break;
946 AddWild(BHEAD wc,VECTOVEC,newvalue);
954 AN.RepFunList[AN.RepFunNum++] = offset;
955 AN.RepFunList[AN.RepFunNum++] = 0;
956 newpat = pattern + pattern[1];
957 if ( newpat >= AN.patstop ) {
958 if ( AN.UseFindOnly == 0 ) {
959 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
960 AT.WorkPointer = oldworkpointer;
961 AN.UsedOtherFind = 1;
967 AT.WorkPointer = oldworkpointer;
971 else j = ScanFunctions(BHEAD newpat,inter,par);
973 AT.WorkPointer = oldworkpointer;
984 t = thewildcards + ntwa; r = AT.WildMask;
987 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
995 for ( j = 1; j < tcount; j++ ) { *t = t[1]; t++; }
999 (thewildcards[iraise-1])++;
1005 if ( oldwilval > 0 ) {
1010 t = lowlevel; r = AT.WildMask;
1013 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1014 }
while ( --j > 0 );
1020 AT.WorkPointer = oldworkpointer;
1032 int FunMatchCy(
PHEAD WORD *pattern, WORD *fun, WORD *inter, WORD par)
1035 WORD *t, *tstop, *p, *pstop, *m, *r, *oldworkpointer = AT.WorkPointer;
1036 WORD **a, *thewildcards, *multiplicity, *renum, wc, wcc, oldwilval = 0;
1037 LONG oww = AT.pWorkPointer;
1038 WORD newvalue, *lowlevel = 0;
1039 int argcount = 0, funnycount = 0, tcount = 0;
1040 int type = 0, pnum, i, j, k, nwstore, iraise, itop, sumeat;
1041 CBUF *C = cbuf+AT.ebufnum;
1042 int ntwa = 3*AN.NumTotWildArgs+1;
1044 WORD offset = fun-AN.terstart, *newpat;
1046 if ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
1048 nwstore = (AN.WildValue[-SUBEXPSIZE+1]-SUBEXPSIZE)/4;
1049 if ( pnum > FUNCTION + WILDOFFSET ) {
1051 if ( CheckWild(BHEAD pnum,FUNTOFUN,fun[0],&newvalue) )
return(0);
1053 t = lowlevel = oldworkpointer;
1059 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
1060 }
while ( --i > 0 );
1063 if ( t >= AT.WorkTop ) {
1064 MLOCK(ErrorMessageLock);
1066 MUNLOCK(ErrorMessageLock);
1070 AddWild(BHEAD pnum,FUNTOFUN,newvalue);
1072 if ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
1076 p = pattern + FUNHEAD;
1077 pstop = pattern + pattern[1];
1078 while ( p < pstop ) {
1079 if ( *p == -ARGWILD ) { p += 2; funnycount++; }
1080 else { NEXTARG(p); argcount++; }
1083 tstop = fun + fun[1];
1084 while ( t < tstop ) { NEXTARG(t); tcount++; }
1086 if ( argcount > tcount )
return(0);
1087 if ( argcount < tcount && funnycount == 0 )
return(0);
1088 if ( argcount == 0 && tcount == 0 && funnycount == 0 ) {
1089 AN.RepFunList[AN.RepFunNum++] = offset;
1090 AN.RepFunList[AN.RepFunNum++] = 0;
1091 newpat = pattern + pattern[1];
1092 if ( newpat >= AN.patstop ) {
1093 if ( AN.UseFindOnly == 0 ) {
1094 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1095 AT.WorkPointer = oldworkpointer;
1096 AN.UsedOtherFind = 1;
1102 AT.WorkPointer = oldworkpointer;
1106 else j = ScanFunctions(BHEAD newpat,inter,par);
1113 WantAddPointers(tcount);
1114 AT.pWorkPointer += tcount;
1115 thewildcards = t = AT.WorkPointer;
1117 if ( oldwilval ) lowlevel = oldworkpointer;
1124 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
1125 }
while ( --i > 0 );
1128 if ( t >= AT.WorkTop ) {
1129 MLOCK(ErrorMessageLock);
1131 MUNLOCK(ErrorMessageLock);
1138 if ( argcount == tcount ) {
1139 if ( funnycount > 0 ) {
1140 p = pattern + FUNHEAD;
1142 while ( p < pstop ) {
1143 if ( *p != -ARGWILD ) { p++;
continue; }
1145 if ( CheckWild(BHEAD p[1],ARGTOARG,0,t) )
goto nomatch;
1146 AddWild(BHEAD p[1],ARGTOARG,0);
1151 for ( k = 0; k <= type; k++ ) {
1153 a = AT.pWorkSpace+oww; t = fun + FUNHEAD;
1154 while ( t < tstop ) { *a++ = t; NEXTARG(t); }
1157 a = AT.pWorkSpace+oww+tcount; t = fun + FUNHEAD;
1158 while ( t < tstop ) { *--a = t; NEXTARG(t); }
1160 for ( i = 0; i < tcount; i++ ) {
1161 p = pattern + FUNHEAD;
1163 for ( j = 0; j < tcount; j++ ) {
1164 while ( *p == -ARGWILD ) p += 2;
1165 t = AT.pWorkSpace[oww+((i+j)%tcount)];
1166 if ( ( wcc = MatchArgument(BHEAD t,p) ) == 0 )
break;
1167 if ( wcc > 1 ) wc = 1;
1170 if ( j >= tcount ) {
1174 AN.RepFunList[AN.RepFunNum++] = offset;
1175 AN.RepFunList[AN.RepFunNum++] = 0;
1177 if ( funnycount > 0 ) {
1178 p = pattern + FUNHEAD;
1180 while ( p < pstop ) {
1181 if ( *p != -ARGWILD ) { p++;
continue; }
1183 AddWild(BHEAD p[1],ARGTOARG,0);
1187 newpat = pattern + pattern[1];
1188 if ( newpat >= AN.patstop ) {
1189 if ( AN.UseFindOnly == 0 ) {
1190 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1191 AT.WorkPointer = oldworkpointer;
1192 AT.pWorkPointer = oww;
1193 AN.UsedOtherFind = 1;
1199 AT.WorkPointer = oldworkpointer;
1200 AT.pWorkPointer = oww;
1204 else j = ScanFunctions(BHEAD newpat,inter,par);
1206 AT.WorkPointer = oldworkpointer;
1207 AT.pWorkPointer = oww;
1215 if ( wc && nwstore > 0 ) {
1218 t = thewildcards + ntwa; r = AT.WildMask;
1221 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1222 }
while ( --j > 0 );
1235 if ( funnycount == 1 ) {
1236 funnycount = tcount - argcount;
1237 for ( k = 0; k <= type; k++ ) {
1239 a = AT.pWorkSpace+oww; t = fun + FUNHEAD;
1240 while ( t < tstop ) { *a++ = t; NEXTARG(t); }
1243 a = AT.pWorkSpace+oww+tcount; t = fun + FUNHEAD;
1244 while ( t < tstop ) { *--a = t; NEXTARG(t); }
1246 for ( i = 0; i < tcount; i++ ) {
1247 p = pattern + FUNHEAD;
1248 a = AT.pWorkSpace+oww;
1250 for ( j = 0; j < tcount; j++, a++ ) {
1252 if ( *p == -ARGWILD ) {
1254 AN.argaddress = (WORD *)a;
1255 if ( CheckWild(BHEAD p[1],ARLTOARL,funnycount,(WORD *)a) )
break;
1256 AddWild(BHEAD p[1],ARLTOARL,funnycount);
1257 j += funnycount-1; a += funnycount-1;
1259 else if ( MatchArgument(BHEAD t,p) == 0 )
break;
1262 if ( j >= tcount ) {
1266 AN.RepFunList[AN.RepFunNum++] = offset;
1267 AN.RepFunList[AN.RepFunNum++] = 0;
1268 newpat = pattern + pattern[1];
1269 if ( newpat >= AN.patstop ) {
1270 if ( AN.UseFindOnly == 0 ) {
1271 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1272 AT.WorkPointer = oldworkpointer;
1273 AT.pWorkPointer = oww;
1274 AN.UsedOtherFind = 1;
1280 AT.WorkPointer = oldworkpointer;
1281 AT.pWorkPointer = oww;
1285 else j = ScanFunctions(BHEAD newpat,inter,par);
1287 AT.WorkPointer = oldworkpointer;
1288 AT.pWorkPointer = oww;
1299 t = thewildcards + ntwa; r = AT.WildMask;
1302 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1303 }
while ( --j > 0 );
1308 a = AT.pWorkSpace+oww;
1310 for ( j = 1; j < tcount; j++ ) { *a = a[1]; a++; }
1321 sumeat = tcount - argcount;
1329 p = pattern+FUNHEAD;
1330 for ( i = funnycount; i < ntwa; i++ ) thewildcards[i] = -1;
1331 multiplicity = thewildcards + funnycount;
1332 renum = multiplicity + funnycount;
1334 while ( p < pstop ) {
1335 if ( *p != -ARGWILD ) { p++;
continue; }
1337 if ( renum[*p] < 0 ) {
1339 multiplicity[j] = 1;
1342 else multiplicity[renum[*p]]++;
1348 for ( i = 1; i < AN.NumTotWildArgs; i++ ) {
1349 if ( renum[i] < 0 )
continue;
1350 for ( j = i+1; j <= AN.NumTotWildArgs; j++ ) {
1351 if ( renum[j] < 0 )
continue;
1352 if ( renum[i] < renum[j] )
continue;
1353 k = multiplicity[renum[i]];
1354 multiplicity[renum[i]] = multiplicity[renum[j]];
1355 multiplicity[renum[j]] = k;
1356 k = renum[i]; renum[i] = renum[j]; renum[j] = k;
1359 for ( i = 0; i < funnycount; i++ ) thewildcards[i] = 0;
1360 iraise = funnycount-1;
1362 for ( i = 0, j = sumeat; i < iraise; i++ )
1363 j -= thewildcards[i]*multiplicity[i];
1364 if ( j < 0 || j % multiplicity[iraise] != 0 ) {
1366 thewildcards[iraise-1]++;
1370 while ( itop > 0 && j < 0 ) {
1371 j += thewildcards[itop]*multiplicity[itop];
1372 thewildcards[itop] = 0;
1375 if ( itop <= 0 && j <= 0 )
break;
1376 thewildcards[itop]++;
1379 thewildcards[iraise] = j / multiplicity[iraise];
1381 for ( k = 0; k <= type; k++ ) {
1383 a = AT.pWorkSpace+oww; t = fun + FUNHEAD;
1384 while ( t < tstop ) { *a++ = t; NEXTARG(t); }
1387 a = AT.pWorkSpace+oww+tcount; t = fun + FUNHEAD;
1388 while ( t < tstop ) { *--a = t; NEXTARG(t); }
1390 for ( i = 0; i < tcount; i++ ) {
1391 p = pattern + FUNHEAD;
1392 a = AT.pWorkSpace+oww;
1394 for ( j = 0; j < tcount; j++, a++ ) {
1396 if ( *p == -ARGWILD ) {
1397 wc = thewildcards[renum[p[1]]];
1398 AN.argaddress = (WORD *)a;
1399 if ( CheckWild(BHEAD p[1],ARLTOARL,wc,(WORD *)a) )
break;
1400 AddWild(BHEAD p[1],ARLTOARL,wc);
1401 j += wc-1; a += wc-1; wc = 1;
1403 else if ( MatchArgument(BHEAD t,p) == 0 )
break;
1406 if ( j >= tcount ) {
1410 AN.RepFunList[AN.RepFunNum++] = offset;
1411 AN.RepFunList[AN.RepFunNum++] = 0;
1412 newpat = pattern + pattern[1];
1413 if ( newpat >= AN.patstop ) {
1414 if ( AN.UseFindOnly == 0 ) {
1415 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1416 AT.WorkPointer = oldworkpointer;
1417 AT.pWorkPointer = oww;
1418 AN.UsedOtherFind = 1;
1424 AT.WorkPointer = oldworkpointer;
1425 AT.pWorkPointer = oww;
1429 else j = ScanFunctions(BHEAD newpat,inter,par);
1431 AT.WorkPointer = oldworkpointer;
1432 AT.pWorkPointer = oww;
1443 t = thewildcards + ntwa; r = AT.WildMask;
1446 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1447 }
while ( --j > 0 );
1452 a = AT.pWorkSpace+oww;
1454 for ( j = 1; j < tcount; j++ ) { *a = a[1]; a++; }
1458 (thewildcards[iraise-1])++;
1464 if ( oldwilval > 0 ) {
1468 t = lowlevel; r = AT.WildMask;
1471 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1472 }
while ( --j > 0 );
1477 AT.WorkPointer = oldworkpointer;
1478 AT.pWorkPointer = oww;
1490 int FunMatchSy(
PHEAD WORD *pattern, WORD *fun, WORD *inter, WORD par)
1493 WORD *t, *tstop, *p, *pstop, *m, *r, *oldworkpointer = AT.WorkPointer;
1494 WORD **a, *thewildcards, oldwilval = 0;
1495 WORD newvalue, *lowlevel = 0, num, assig;
1497 LONG oww = AT.pWorkPointer, lhpars, lhfunnies;
1498 int argcount = 0, funnycount = 0, tcount = 0, signs = 0, signfun = 0, signo;
1499 int type = 0, pnum, i, j, k, nwstore, iraise, cou2;
1500 CBUF *C = cbuf+AT.ebufnum;
1501 int ntwa = 3*AN.NumTotWildArgs+1;
1503 WORD offset = fun-AN.terstart, *newpat;
1505 if ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
1507 nwstore = (AN.WildValue[-SUBEXPSIZE+1]-SUBEXPSIZE)/4;
1508 if ( pnum > FUNCTION + WILDOFFSET ) {
1510 if ( CheckWild(BHEAD pnum,FUNTOFUN,fun[0],&newvalue) )
return(0);
1512 t = lowlevel = oldworkpointer;
1518 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
1519 }
while ( --i > 0 );
1522 if ( t >= AT.WorkTop ) {
1523 MLOCK(ErrorMessageLock);
1525 MUNLOCK(ErrorMessageLock);
1529 AddWild(BHEAD pnum,FUNTOFUN,newvalue);
1531 if ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == RCYCLESYMMETRIC ) type = 1;
1535 if ( fun[1] == pattern[1] ) {
1536 i = fun[1]-FUNHEAD; p = pattern+FUNHEAD; t = fun + FUNHEAD;
1537 while ( --i >= 0 ) {
if ( *p++ != *t++ )
break; }
1538 if ( i < 0 )
goto quicky;
1543 p = pattern + FUNHEAD;
1544 pstop = pattern + pattern[1];
1545 while ( p < pstop ) {
1546 if ( *p == -ARGWILD ) { p += 2; funnycount++; }
1547 else { NEXTARG(p); argcount++; }
1550 tstop = fun + fun[1];
1551 while ( t < tstop ) { NEXTARG(t); tcount++; }
1553 if ( argcount > tcount )
return(0);
1554 if ( argcount < tcount && funnycount == 0 )
return(0);
1555 if ( argcount == 0 && tcount == 0 && funnycount == 0 ) {
1557 if ( AN.SignCheck && signs != AN.ExpectedSign )
goto NoSuccess;
1558 AN.RepFunList[AN.RepFunNum++] = offset;
1559 AN.RepFunList[AN.RepFunNum++] = signs;
1560 newpat = pattern + pattern[1];
1561 if ( newpat >= AN.patstop ) {
1562 if ( AN.UseFindOnly == 0 ) {
1563 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1564 AT.WorkPointer = oldworkpointer;
1565 AN.UsedOtherFind = 1;
1571 AT.WorkPointer = oldworkpointer;
1575 else j = ScanFunctions(BHEAD newpat,inter,par);
1577 AT.WorkPointer = oldworkpointer;
1585 WantAddPointers(tcount+argcount+funnycount);
1586 AT.pWorkPointer += tcount+argcount+funnycount;
1587 thewildcards = t = AT.WorkPointer;
1589 if ( oldwilval ) lowlevel = oldworkpointer;
1592 i = nwstore; assig = 0;
1597 *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *m++; *t++ = *r++;
1598 }
while ( --i > 0 );
1601 if ( t >= AT.WorkTop ) {
1602 MLOCK(ErrorMessageLock);
1604 MUNLOCK(ErrorMessageLock);
1611 t = fun + FUNHEAD; a = AT.pWorkSpace+oww;
1612 while ( t < tstop ) { *a++ = t; NEXTARG(t) }
1613 lhpars = a-AT.pWorkSpace;
1614 t = pattern + FUNHEAD;
1615 while ( t < pstop ) {
1616 if ( *t != -ARGWILD ) *a++ = t;
1619 lhfunnies = a-AT.pWorkSpace;
1620 t = pattern + FUNHEAD; cou2 = 0;
1621 while ( t < pstop ) {
1623 if ( *t == -ARGWILD ) {
1630 signfun = ((argcount+funnycount-cou2)*(tcount-argcount)) & 1;
1635 if ( funnycount > 0 ) {
1636 if ( ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == SYMMETRIC )
1637 || ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == ANTISYMMETRIC )
1638 || ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == SYMMETRIC )
1639 || ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == ANTISYMMETRIC ) ) {
1640 AT.WorkPointer = oldworkpointer;
1641 AT.pWorkPointer = oww;
1642 MLOCK(ErrorMessageLock);
1643 MesPrint(
"Sorry: no argument field wildcards yet in (anti)symmetric functions");
1644 MUNLOCK(ErrorMessageLock);
1656 for ( i = 0; i < iraise; i++ ) {
1657 t = AT.pWorkSpace[i+lhpars];
1661 else if ( *t <= -FUNCTION ) {
1662 if ( *t > -FUNCTION - WILDOFFSET )
goto cat1;
1663 type = FUNTOFUN; num = -*t - WILDOFFSET;
1665 else if ( *t == -SYMBOL ) {
1666 if ( t[1] < 2*MAXPOWER )
goto cat1;
1667 type = SYMTOSYM; num = t[1] - 2*MAXPOWER;
1669 else if ( *t == -INDEX ) {
1670 if ( t[1] < AM.OffsetIndex + WILDOFFSET )
goto cat1;
1671 type = INDTOIND; num = t[1] - WILDOFFSET;
1673 else if ( *t == -VECTOR || *t == -MINVECTOR ) {
1674 if ( t[1] < AM.OffsetVector + WILDOFFSET )
goto cat1;
1675 type = VECTOVEC; num = t[1] - WILDOFFSET;
1684 while ( --j >= 0 ) {
1685 if ( m[2] == num && *r ) {
1686 if ( type == *m )
break;
1687 if ( type == SYMTOSYM ) {
1688 if ( *m == SYMTONUM || *m == SYMTOSUB )
break;
1690 else if ( type == INDTOIND ) {
1691 if ( *m == INDTOSUB )
break;
1693 else if ( type == VECTOVEC ) {
1694 if ( *m == VECTOMIN || *m == VECTOSUB )
break;
1700 a = AT.pWorkSpace+lhpars;
1702 if ( iraise != i ) signs++;
1708 for ( j = 0; j < tcount; j++ ) {
1709 if ( MatchArgument(BHEAD AT.pWorkSpace[oww+j],t) ) {
1713 while ( --k >= 0 ) num += *r++;
1714 if ( num == assig ) {
1720 if ( j >= tcount )
goto NoSuccess;
1723 t = thewildcards + ntwa; r = AT.WildMask;
1726 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1727 }
while ( --j > 0 );
1733 for ( j = 0; j < tcount; j++ ) {
1734 m = AT.pWorkSpace[j+oww];
1735 if ( *t != *m )
continue;
1737 if ( *t <= -FUNCTION )
break;
1738 if ( t[1] == m[1] )
break;
1742 while ( --k >= 0 && *m++ == *r++ ) {}
1746 if ( j >= tcount )
goto NoSuccess;
1753 while ( j < tcount ) {
1754 AT.pWorkSpace[oww+j] = AT.pWorkSpace[oww+j+1]; j++;
1760 while ( j < argcount ) {
1761 AT.pWorkSpace[lhpars+j] = AT.pWorkSpace[lhpars+j+1]; j++;
1771 for ( i = 0; i < funnycount; i++ ) {
1772 k = AT.pWorkSpace[lhfunnies+i][1];
1776 while ( --j >= 0 ) {
1777 if ( *m == ARGTOARG && m[2] == k )
break;
1780 if ( *r == 0 )
continue;
1781 m = cbuf[AT.ebufnum].rhs[m[3]];
1784 if ( j > tcount - argcount )
goto NoSuccess;
1785 while ( --j >= 0 ) {
1787 if ( *m < 0 ) type = -VECTOR;
1788 else if ( *m < AM.OffsetIndex ) type = -SNUMBER;
1790 a = AT.pWorkSpace+oww;
1791 for ( k = 0; k < tcount; k++ ) {
1792 if ( a[k][0] != type || a[k][1] != *m )
continue;
1803 for ( k = 0; k < tcount; k++ ) {
1804 t = AT.pWorkSpace[oww+k];
1805 if ( *t != *m )
continue;
1808 if ( *r < -FUNCTION )
goto nextargw;
1809 else if ( r[1] == t[1] )
goto nextargw;
1813 while ( --j >= 0 && *r++ == *t++ ) {}
1814 if ( j < 0 )
goto nextargw;
1819 AT.pWorkSpace[oww+k] = AT.pWorkSpace[oww+(--tcount)];
1823 AT.pWorkSpace[lhfunnies+i] = AT.pWorkSpace[lhfunnies+(--funnycount)];
1825 if ( tcount == 0 ) {
1826 if ( argcount > 0 )
goto NoSuccess;
1827 for ( i = 0; i < funnycount; i++ ) {
1828 AddWild(BHEAD AT.pWorkSpace[lhfunnies+i][1],ARGTOARG,0);
1840 for ( i = 0; i < iraise; i++ ) {
1841 for ( j = 0; j < tcount; j++ ) {
1842 if ( MatchArgument(BHEAD AT.pWorkSpace[oww+j],AT.pWorkSpace[lhpars+i]) ) {
1846 while ( --k >= 0 ) num += *r++;
1847 if ( num == assig ) {
1849 AT.pWorkSpace[oww+j] = AT.pWorkSpace[oww+(--tcount)];
1850 if ( tcount > j ) signs += tcount-j-1;
1852 a = AT.pWorkSpace + lhpars;
1853 for ( j = i; j < argcount; j++ ) a[j] = a[j+1];
1860 t = thewildcards + ntwa; r = AT.WildMask;
1863 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1864 }
while ( --j > 0 );
1886 cycles = AT.WorkPointer;
1887 for ( i = 0; i < tcount; i++ ) cycles[i] = tcount-i;
1888 AT.WorkPointer += tcount;
1892 WORD oRepFunNum = AN.RepFunNum;
1893 for ( j = 0; j < argcount; j++ ) {
1894 if ( MatchArgument(BHEAD AT.pWorkSpace[oww+j],AT.pWorkSpace[lhpars+j]) == 0 ) {
1898 if ( j >= argcount ) {
1903 AT.WorkPointer = oldworkpointer;
1904 AT.pWorkPointer = oww;
1905 MLOCK(ErrorMessageLock);
1906 MesPrint(
"Sorry: no argument field wildcards yet in (anti)symmetric functions");
1907 MUNLOCK(ErrorMessageLock);
1918 AN.RepFunList[AN.RepFunNum++] = offset;
1919 if ( ( (functions[fun[0]-FUNCTION].symmetric & ~REVERSEORDER) == ANTISYMMETRIC )
1920 || ( (functions[pnum-FUNCTION].symmetric & ~REVERSEORDER) == ANTISYMMETRIC ) ) {
1921 AN.RepFunList[AN.RepFunNum++] = ( signs + signo ) & 1;
1924 AN.RepFunList[AN.RepFunNum++] = 0;
1926 newpat = pattern + pattern[1];
1927 if ( newpat >= AN.patstop ) {
1928 WORD countsgn, sgn = 0;
1929 for ( countsgn = oRepFunNum+1; countsgn < AN.RepFunNum; countsgn += 2 ) {
1930 if ( AN.RepFunList[countsgn] ) sgn ^= 1;
1932 if ( AN.SignCheck == 0 || sgn == AN.ExpectedSign ) {
1933 AT.WorkPointer = oldworkpointer;
1934 AT.pWorkPointer = oww;
1937 if ( AN.UseFindOnly == 0 ) {
1938 if ( FindOnce(BHEAD AN.findTerm,AN.findPattern) ) {
1939 AT.WorkPointer = oldworkpointer;
1940 AT.pWorkPointer = oww;
1941 AN.UsedOtherFind = 1;
1947 else j = ScanFunctions(BHEAD newpat,inter,par);
1949 WORD countsgn, sgn = 0;
1950 for ( countsgn = oRepFunNum+1; countsgn < AN.RepFunNum; countsgn += 2 ) {
1951 if ( AN.RepFunList[countsgn] ) sgn ^= 1;
1953 if ( AN.SignCheck == 0 || sgn == AN.ExpectedSign ) {
1954 AT.WorkPointer = oldworkpointer;
1955 AT.pWorkPointer = oww;
1959 AN.RepFunNum = oRepFunNum;
1965 t = thewildcards + ntwa; r = AT.WildMask;
1968 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
1969 }
while ( --j > 0 );
1976 a = AT.pWorkSpace + oww;
1977 for ( j = i+1, t = a[i]; j < tcount; j++ ) a[j-1] = a[j];
1978 a[tcount-1] = t; cycles[i]--;
1979 signo += tcount - i - 1;
1980 while ( cycles[i] <= 0 ) {
1981 cycles[i] = tcount - i;
1983 if ( i < 0 )
goto NoSuccess;
1989 for ( j = i+1, t = a[i]; j < tcount; j++ ) a[j-1] = a[j];
1990 a[tcount-1] = t; cycles[i]--;
1991 signo += tcount - i - 1;
1995 if ( oldwilval > 0 ) {
1998 t = lowlevel; r = AT.WildMask;
2001 *m++ = *t++; *m++ = *t++; *m++ = *t++; *m++ = *t++; *r++ = *t++;
2002 }
while ( --j > 0 );
2007 AT.WorkPointer = oldworkpointer;
2008 AT.pWorkPointer = oww;
2017 int MatchArgument(
PHEAD WORD *arg, WORD *pat)
2020 WORD *m = pat, *t = arg, i, j, newvalue;
2021 WORD *argmstop = pat, *argtstop = arg;
2022 WORD *cto, *cfrom, *csav, ci;
2023 WORD oRepFunNum, *oRepFunList;
2024 WORD *oterstart,*oterstop,*opatstop;
2025 WORD wildargs, wildeat;
2026 WORD *mtrmstop, *ttrmstop, *msubstop, msizcoef;
2035 if ( *m < 0 && *t < 0 ) {
2036 if ( *t <= -FUNCTION ) {
2038 else if ( *m <= -FUNCTION-WILDOFFSET
2039 && functions[-*t-FUNCTION].spec
2040 == functions[-*m-FUNCTION-WILDOFFSET].spec ) {
2041 i = -*m - WILDOFFSET; wc = 2;
2042 if ( CheckWild(BHEAD i,FUNTOFUN,-*t,&newvalue) ) {
2045 AddWild(BHEAD i,FUNTOFUN,newvalue);
2047 else if ( *m == -SYMBOL && m[1] >= 2*MAXPOWER ) {
2048 i = m[1] - 2*MAXPOWER;
2049 AN.argaddress = AT.FunArg;
2050 AT.FunArg[ARGHEAD+1] = -*t;
2051 if ( CheckWild(BHEAD i,SYMTOSUB,1,AN.argaddress) )
return(0);
2052 AddWild(BHEAD i,SYMTOSUB,0);
2056 else if ( *t == *m ) {
2057 if ( t[1] == m[1] ) {}
2058 else if ( *t == -SYMBOL ) {
2060 SymAll:
if ( ( i = m[1] - 2*MAXPOWER ) < 0 )
return(0);
2062 if ( CheckWild(BHEAD i,j,t[1],&newvalue) )
return(0);
2063 AddWild(BHEAD i,j,newvalue);
2065 else if ( *t == -INDEX ) {
2066 IndAll: i = m[1] - WILDOFFSET;
2067 if ( i < AM.OffsetIndex || i >= WILDOFFSET+AM.OffsetIndex )
2071 if ( CheckWild(BHEAD i,INDTOIND,t[1],&newvalue) )
return(0);
2072 AddWild(BHEAD i,INDTOIND,newvalue);
2074 else if ( *t == -VECTOR || *t == -MINVECTOR ) {
2075 i = m[1] - WILDOFFSET;
2076 if ( i < AM.OffsetVector )
return(0);
2078 if ( CheckWild(BHEAD i,VECTOVEC,t[1],&newvalue) )
return(0);
2079 AddWild(BHEAD i,VECTOVEC,newvalue);
2083 else if ( *m == -INDEX && m[1] >= AM.OffsetIndex+WILDOFFSET
2084 && m[1] < AM.OffsetIndex+(WILDOFFSET<<1) ) {
2085 if ( *t == -VECTOR || *t == -SNUMBER )
goto IndAll;
2086 if ( *t == -MINVECTOR ) {
2087 i = m[1] - WILDOFFSET;
2088 AN.argaddress = AT.MinVecArg;
2089 AT.MinVecArg[ARGHEAD+3] = t[1];
2091 if ( CheckWild(BHEAD i,INDTOSUB,1,AN.argaddress) )
return(0);
2092 AddWild(BHEAD i,INDTOSUB,(WORD)0);
2096 else if ( *m == -SYMBOL && m[1] >= 2*MAXPOWER && *t == -SNUMBER ) {
2100 else if ( *m == -VECTOR && *t == -MINVECTOR &&
2101 ( i = m[1] - WILDOFFSET ) >= AM.OffsetVector ) {
2102 AN.argaddress = AT.MinVecArg;
2103 AT.MinVecArg[ARGHEAD+3] = t[1];
2105 if ( CheckWild(BHEAD i,VECTOSUB,1,AN.argaddress) )
return(0);
2106 AddWild(BHEAD i,VECTOSUB,(WORD)0);
2114 else if ( *m > 0 && *t <= -FUNCTION ) {
2115 if ( ( m[ARGHEAD]+ARGHEAD == *m ) && m[*m-1] == 3
2116 && m[*m-2] == 1 && m[*m-3] == 1 && m[ARGHEAD+1] >= FUNCTION
2117 && m[ARGHEAD+2] == *m-ARGHEAD-4 ) {
2118 WORD *mmmst, *mmm, mmmi;
2119 if ( m[ARGHEAD+1] >= FUNCTION+WILDOFFSET ) {
2120 mmmi = *m - WILDOFFSET;
2122 if ( CheckWild(BHEAD mmmi,FUNTOFUN,-*t,&newvalue) )
return(0);
2123 AddWild(BHEAD mmmi,FUNTOFUN,newvalue);
2125 else if ( m[ARGHEAD+1] != -*t )
return(0);
2130 mmm = m + ARGHEAD + FUNHEAD + 1;
2131 while ( mmm < mmmst ) {
2132 if ( *mmm != -ARGWILD )
return(0);
2134 AN.argaddress = t; wc = 2;
2135 if ( CheckWild(BHEAD mmm[1],ARGTOARG,mmmi,t) )
return(0);
2136 AddWild(BHEAD mmm[1],ARGTOARG,mmmi);
2146 else if ( *m < 0 && *t > 0 ) {
2147 if ( *m == -SYMBOL ) {
2148 if ( m[1] < 2*MAXPOWER )
return(0);
2149 i = m[1] - 2*MAXPOWER;
2150 AN.argaddress = t; wc = 2;
2151 if ( CheckWild(BHEAD i,SYMTOSUB,1,AN.argaddress) )
return(0);
2152 AddWild(BHEAD i,SYMTOSUB,0);
2154 else if ( *m == -VECTOR ) {
2155 if ( ( i = m[1] - WILDOFFSET ) < AM.OffsetVector )
return(0);
2156 AN.argaddress = t; wc = 2;
2157 if ( CheckWild(BHEAD i,VECTOSUB,1,t) )
return(0);
2158 AddWild(BHEAD i,VECTOSUB,(WORD)0);
2160 else if ( *m == -INDEX ) {
2161 if ( ( i = m[1] - WILDOFFSET ) < AM.OffsetIndex )
return(0);
2162 if ( i >= AM.OffsetIndex + WILDOFFSET )
return(0);
2163 AN.argaddress = t; wc = 2;
2164 if ( CheckWild(BHEAD i,INDTOSUB,1,AN.argaddress) )
return(0);
2165 AddWild(BHEAD i,INDTOSUB,(WORD)0);
2173 else if ( *m > 0 && *t > 0 ) {
2175 do {
if ( *m++ != *t++ )
break; }
while ( --i > 0 );
2182 m += ARGHEAD; t += ARGHEAD;
2185 if ( mtrmstop < argmstop )
return(0);
2186 msizcoef = mtrmstop[-1];
2187 if ( msizcoef < 0 ) msizcoef = -msizcoef;
2188 msubstop = mtrmstop - msizcoef;
2190 if ( m >= msubstop )
return(0);
2203 if ( argtstop > ttrmstop )
return(0);
2206 oterstart = AN.terstart;
2207 oterstop = AN.terstop;
2208 opatstop = AN.patstop;
2209 oRepFunList = AN.RepFunList;
2210 oRepFunNum = AN.RepFunNum;
2212 wildargtaken = AT.WorkPointer;
2213 AN.RepFunList = wildargtaken + AN.NumTotWildArgs;
2214 AT.WorkPointer = (WORD *)(((UBYTE *)(AN.RepFunList)) + AM.MaxTer/2);
2215 csav = cto = AT.WorkPointer;
2218 while ( --ci >= 0 ) *cto++ = *cfrom++;
2219 AT.WorkPointer = cto;
2222 while ( --ci >= 0 ) {
2223 if ( *--cfrom != *--cto ) {
2224 AT.WorkPointer = wildargtaken;
2225 AN.RepFunList = oRepFunList;
2226 AN.RepFunNum = oRepFunNum;
2227 AN.terstart = oterstart;
2228 AN.terstop = oterstop;
2229 AN.patstop = opatstop;
2234 wildargs = AN.WildArgs;
2235 wildeat = AN.WildEat;
2236 for ( i = 0; i < wildargs; i++ ) wildargtaken[i] = AT.WildArgTaken[i];
2237 AN.ForFindOnly = 0; AN.UseFindOnly = 1;
2239 if ( FindRest(BHEAD csav,m) && ( AN.UsedOtherFind || FindOnly(BHEAD csav,m) ) ) { }
2242 AT.WorkPointer = wildargtaken;
2243 AN.RepFunList = oRepFunList;
2244 AN.RepFunNum = oRepFunNum;
2245 AN.terstart = oterstart;
2246 AN.terstop = oterstop;
2247 AN.patstop = opatstop;
2248 AN.WildArgs = wildargs;
2249 AN.WildEat = wildeat;
2251 for ( i = 0; i < wildargs; i++ ) AT.WildArgTaken[i] = wildargtaken[i];
2255 AN.WildArgs = wildargs;
2256 AN.WildEat = wildeat;
2257 for ( i = 0; i < wildargs; i++ ) AT.WildArgTaken[i] = wildargtaken[i];
2258 Substitute(BHEAD csav,m,1);
2260 cfrom = cto + *cto - msizcoef;
2263 AT.WorkPointer = wildargtaken;
2264 AN.RepFunList = oRepFunList;
2265 AN.RepFunNum = oRepFunNum;
2266 AN.terstart = oterstart;
2267 AN.terstop = oterstop;
2268 AN.patstop = opatstop;
2269 if ( *cto != SUBEXPRESSION )
return(0);
2271 if ( cto < cfrom )
return(0);