![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to optcse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1|
Return to optcse.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1 |
1.1 root 1: #include "defs.h"
2: #include "optim.h"
3:
4: #define MSKREGTYPES M(TYLOGICAL) | M(TYADDR) | M(TYSHORT) | M(TYLONG)
5: #define ISREGTYPE(x) ONEOF(x, MSKREGTYPES)
6:
7: #define FALSE 0
8: #define TRUE 1
9:
10: LOCAL Bblockp current_BB;
11: LOCAL int cse1count; /* count of number of cse uses eliminated */
12: LOCAL int cse2count; /* count of number of cse def's eliminated */
13:
14:
15:
16:
17: LOCAL dumpstacks()
18: {
19: duplptr dl;
20: valuen p;
21: idlptr idl;
22: idptr idp;
23: nodelptr nl;
24: int i;
25:
26: fprintf(diagfile,"\n *** IDblocks ***\n");
27: for(idp=current_BB->headid;idp;idp=idp->next)
28: {
29: fprintf(diagfile,
30: "idp= %d idaddr= %d initval= %d assgnval= %d \n",
31: idp, idp->idaddr, idp->initval, idp->assgnval);
32: fprintf(diagfile,"nodes: ");
33: i=0;
34: for (nl=idp->headnodelist;nl;nl=nl->next) {
35: if(++i>20){
36: fprintf(diagfile,"\n");
37: i=0;
38: }
39: fprintf(diagfile," %d ",nl->nodep);
40: }
41: fprintf(diagfile,"\n");
42: }
43:
44: fprintf(diagfile,"\n *** VALUE NODES *** \n");
45: for(p=current_BB->headnode;p;p=p->next) {
46: fprintf(diagfile,
47: "\np= %d opp= %d lc= %d rc= %d rs= %d is_dead= %d n_dups %d",
48: p, p->opp,p->lc,p->rc, p->rs, p->is_dead, p->n_dups);
49: if (p->rs){
50: fprintf(diagfile,"tag= %d ",p->opp->tag);
51: if(p->opp->tag==TEXPR)
52: fprintf(diagfile,"opco= %d ",
53: p->opp->exprblock.opcode);
54: }
55: fprintf(diagfile,"\n");
56: fprintf(diagfile,"parent= %d dups: ",p->parent);
57: i=0;
58: for(dl=p->headduplist;dl;dl=dl->next) {
59: if(++i>20){
60: fprintf(diagfile,"\n");
61: i=0;
62: }
63: fprintf(diagfile," %d ",dl->parent);
64: }
65:
66: fprintf(diagfile,"\ndeps IDs");
67: i=0;
68: for(idl=p->headdeplist;idl;idl=idl->next) {
69: if(++i>20){
70: fprintf(diagfile,"\n");
71: i=0;
72: }
73: fprintf(diagfile," %d ",idl->idp);
74: }
75: }
76: }
77:
78:
79:
80: LOCAL idlptr mergedeps(lnode,rnode)
81: valuen lnode,rnode;
82: /* Given two value nodes, merge the lists of identifiers on which they
83: ** depend to produce a new list incorporating both dependencies. Lists
84: ** are assumed to be ordered by increasing idp address. No duplicate identifiers
85: ** are generated in the output list.
86: */
87: {
88: register idlptr lp,lp1,lp2;
89: idlptr head;
90:
91: lp = lp1 = lp2 = head = NULL;
92: if(lnode) lp1 = lnode->headdeplist;
93: if(rnode) lp2 = rnode->headdeplist;
94:
95: while (lp1 || lp2) {
96: if (lp) {
97: lp->next = ALLOC(IDlist);
98: lp = lp->next;
99: }
100: else lp = head = ALLOC(IDlist);
101: lp->next = 0;
102: if (lp1 == 0) {
103: lp->idp = lp2->idp;
104: lp2 = lp2->next;
105: }
106: else if (lp2 == 0) {
107: lp->idp = lp1->idp;
108: lp1 = lp1->next;
109: }
110: else if (lp1->idp < lp2->idp) {
111: lp->idp = lp1->idp;
112: lp1 = lp1->next;
113: }
114: else if (lp1->idp > lp2->idp) {
115: lp->idp = lp2->idp;
116: lp2 = lp2->next;
117: }
118: else {
119: lp->idp = lp1->idp;
120: lp1 = lp1->next;
121: lp2 = lp2->next;
122: }
123: }
124: return(head);
125: }
126:
127:
128:
129: LOCAL removenode(nodep)
130: valuen nodep;
131: /* Removes a value node from every IDblock on the node's list of identifiers.
132: */
133: {
134: register idlptr idl;
135: register nodelptr nl;
136: register nodelptr *addrnl;
137:
138: if(nodep == NULL) return ;
139:
140: /* loop through all identifiers */
141: for(idl=nodep->headdeplist;idl;idl=idl->next)
142: {
143: addrnl = &(idl->idp->headnodelist);
144: /* for each identifier loop through all nodes until match is found */
145: for(nl = *addrnl; nl; nl = *addrnl)
146: {
147: if(nl->nodep == nodep) {
148: *addrnl = nl->next;
149: free ( (charptr) nl );
150: break;
151: }
152: addrnl = &nl->next;
153: }
154: }
155: nodep->is_dead = TRUE;
156: }
157:
158:
159:
160: LOCAL killid(idp)
161: idptr idp;
162: /* Kill all nodes on one identifier's list of dependent nodes, i.e. remove
163: ** all calculations that depend on this identifier from the available
164: ** values stack. Free the list of records pointing at the dependent nodes.
165: */
166: {
167: nodelptr nl1,nl2;
168:
169: for (nl1 = idp->headnodelist; nl1; nl1=nl2)
170: {
171: nl2 = nl1->next;
172: removenode(nl1->nodep);
173: }
174: /* the above call frees the node list record pointed at by nl1 since it frees
175: ** all the node list records that reference the value node being killed
176: */
177: idp->headnodelist = NULL;
178:
179: }
180:
181:
182:
183: LOCAL killdepnodes(idp)
184: idptr idp;
185: /* Kill all value nodes that represent calculations which depend on
186: ** this identifier. If the identifier is in COMMON or EQUIVALENCE storage,
187: ** kill all values that depend on identifiers in COMMON or EQUIVALENCE
188: */
189: {
190: int thismemno;
191:
192: if(idp->idaddr->addrblock.vstg == STGCOMMON)
193: {
194: for(idp=current_BB->headid;idp;idp=idp->next)
195: if(idp->idaddr->addrblock.vstg == STGCOMMON)
196: killid(idp);
197: }
198: else if(idp->idaddr->addrblock.vstg == STGEQUIV)
199: {
200: thismemno=idp->idaddr->addrblock.memno;
201: for(idp=current_BB->headid;idp;idp=idp->next)
202: if(idp->idaddr->addrblock.vstg == STGEQUIV
203: && idp->idaddr->addrblock.memno == thismemno)
204: killid(idp);
205: }
206: else killid(idp);
207:
208: }
209:
210:
211:
212: LOCAL appendnode(nodep)
213: valuen nodep;
214: /* Append a value node to all the IDblocks on that node's list of
215: ** dependent identifiers i.e., since this computation depends on
216: ** all the identifiers on its list then each of those identifiers should
217: ** include this node in their list of dependent nodes.
218: */
219: {
220: register idlptr idl;
221: register nodelptr nl;
222:
223: for(idl=nodep->headdeplist;idl;idl=idl->next)
224: if(idl->idp->idaddr->tag == TADDR ||
225: idl->idp->idaddr->tag == TTEMP)
226: {
227: nl=ALLOC(NODElist);
228: nl->nodep = nodep;
229: nl->next = idl->idp->headnodelist;
230: idl->idp->headnodelist = nl;
231: }
232: }
233:
234:
235:
236: LOCAL idlptr addadep(idp,nodep)
237: idptr idp;
238: valuen nodep;
239: /* Add an identifier to the dependents list of a value node. Dependents
240: ** lists are ordered by increasing idp value
241: */
242: {
243: register idlptr lp1,lp2;
244:
245: lp2 = ALLOC(IDlist);
246: lp2->idp = idp;
247: if(nodep->headdeplist == 0) {
248: lp2->next = 0;
249: nodep->headdeplist = lp2;
250: }
251: else if(idp <= nodep->headdeplist->idp) {
252: lp2->next = nodep->headdeplist;
253: nodep->headdeplist = lp2;
254: }
255: else for(lp1 = nodep->headdeplist; lp1; lp1 = lp1->next)
256: if( (lp1->next == 0) || (idp <= lp1->next->idp) )
257: {
258: lp2->next = lp1->next;
259: lp1->next = lp2;
260: break;
261: }
262: return(lp2);
263: }
264:
265:
266:
267: LOCAL valuen newnode(expr,left,right,rslt)
268: expptr expr;
269: valuen left,right,rslt;
270: /* Build a new value node
271: */
272: {
273: register valuen p;
274:
275: p= ALLOC(VALUEnode);
276: p->opp = expr ;
277: p->parent = NULL ;
278: p->lc = left;
279: p->rc = right;
280: p->rs = rslt;
281: p->n_dups = 0;
282: p->is_dead = FALSE;
283: p->next=NULL;
284: p->headdeplist = mergedeps(left,right);
285: p->headduplist=NULL;
286: if(current_BB->headnode == 0) current_BB->headnode=p;
287: else if(current_BB->tailnode) current_BB->tailnode->next=p;
288: current_BB->tailnode=p;
289:
290: return(p);
291: }
292:
293:
294:
295: LOCAL newid(idaddr,addrof_idptr)
296: expptr idaddr;
297: idptr *addrof_idptr;
298: /* Build a new IDblock and hook it on the current BB's ID list
299: */
300: {
301: register idptr p;
302:
303: p= ALLOC(IDblock);
304:
305: /* build a leaf value node for the identifier and put the ID on the leaf node's
306: ** list of dependent identifiers
307: */
308: p->initval = newnode(idaddr,NULL,NULL,NULL);
309: p->initval->rs = p->initval;
310: addadep(p,p->initval);
311:
312: p->idaddr = idaddr;
313: *addrof_idptr = p;
314: p->headnodelist=NULL;
315: p->next=NULL;
316:
317: }
318:
319:
320:
321: LOCAL addadup(parent,nodep)
322: expptr *parent;
323: valuen nodep;
324:
325: /* A subtree has been found that duplicates the calculation represented
326: ** by the value node referenced by nodep : add the root of the reduntant
327: ** tree to the value node's list of duplicates.
328: */
329:
330: {
331: register duplptr dp;
332: valuen child;
333:
334: dp = ALLOC(DUPlist);
335: dp->parent = parent;
336: dp->next = nodep->headduplist;
337: nodep->headduplist = dp;
338: ++nodep->n_dups;
339:
340: /* Check whether either of nodep's children is also a duplicate calculation
341: ** and if so peel off it's most recent dup record
342: */
343:
344: if ( (child = nodep->lc) && (child->n_dups) )
345: {
346: dp = child->headduplist;
347: child->headduplist = dp->next;
348: free ( (charptr) dp );
349: --child->n_dups;
350: }
351: if ( (child = nodep->rc) && (child->n_dups) )
352: {
353: dp = child->headduplist;
354: child->headduplist = dp->next;
355: free ( (charptr) dp );
356: --child->n_dups;
357: }
358:
359: }
360:
361:
362:
363: LOCAL samebase(ep1,ep2)
364: expptr ep1,ep2;
365: {
366: if ( ep1->tag == ep2->tag )
367: switch (ep2->tag) {
368: case TTEMP :
369: if (ep1->tempblock.memalloc == ep2->tempblock.memalloc)
370: return (TRUE);
371: break;
372: case TADDR :
373: if (ep1->addrblock.vstg == ep2->addrblock.vstg &&
374: ep1->addrblock.memno == ep2->addrblock.memno )
375: return(TRUE);
376: break;
377: case TCONST :
378: if( (ep1->constblock.vtype) ==
379: (ep2->constblock.vtype) )
380: {
381: union Constant *ap,*bp;
382: ap= &ep1->constblock.const;
383: bp= &ep2->constblock.const;
384: switch(ep1->constblock.vtype)
385:
386: {
387: case TYSHORT:
388: case TYLONG:
389: if(ap->ci == bp->ci) return(TRUE);
390: break;
391: case TYREAL:
392: case TYDREAL:
393: if(ap->cd[0] == bp->cd[0]) return(TRUE);
394: break;
395: case TYCOMPLEX:
396: case TYDCOMPLEX:
397: if(ap->cd[0] == bp->cd[0] &&
398: ap->cd[1] == bp->cd[1] )
399: return(TRUE);
400: break;
401: }
402: }
403: break;
404:
405: default :
406: badtag ("samebase",ep2->tag);
407: }
408: return(FALSE);
409: }
410:
411:
412:
413: LOCAL idptr findid(idaddr)
414: expptr idaddr;
415:
416: /* Find an identifier's IDblock given its idaddr. If the identifier has no
417: ** IBblock build one
418: */
419:
420: {
421: register idptr idp;
422: if(current_BB->headid == 0) newid(idaddr,¤t_BB->headid);
423: idp=current_BB->headid;
424:
425: do {
426: if (samebase(idp->idaddr,idaddr) ) break;
427: if (idp->next == 0) {
428: newid(idaddr,&idp->next);
429: idp = idp->next;
430: break;
431: }
432: idp = idp->next;
433: }
434: while(TRUE);
435:
436: return(idp);
437: }
438:
439:
440:
441: LOCAL valuen findnode(ep,leftc,rightc)
442: expptr ep;
443: valuen leftc,rightc;
444: {
445: /* Look for a matching value node in the available computations stack
446: */
447: register valuen p;
448:
449: for ( p=current_BB->headnode; p ; p=p->next) {
450: if( ( ! p->is_dead) &&
451: (p->lc == leftc) &&
452: (p->rc == rightc) &&
453: ( (ep->tag == TEXPR && p->opp->tag == TEXPR
454: && p->opp->exprblock.opcode == ep->exprblock.opcode
455: )
456: || (ep->tag == TADDR) || (ep->tag == TTEMP)
457: )
458: )
459: return(p);
460: }
461: return(NULL);
462: }
463:
464:
465:
466: LOCAL valuen scanchain(listp,p_parent)
467: expptr listp;
468: chainp *p_parent;
469:
470: /* Make value nodes from the chain hanging off a LISTBLOCK
471: */
472:
473: {
474: valuen lnode,rnode,new,scantree();
475: chainp p;
476:
477: p= *p_parent;
478: if (p == NULL) return(NULL);
479: lnode = scantree( &p->datap);
480: rnode = scanchain(listp, &p->nextp);
481: new = newnode(listp,lnode,rnode,0);
482: new->rs = new;
483: return(new->rs);
484: }
485:
486:
487:
488: LOCAL valuen scantree(p_parent)
489: expptr *p_parent;
490:
491: /* build a value node and return its address. p must point to an
492: ** exprblock an addrblock a listblock or a constblock.
493: */
494:
495: {
496: valuen lnode, rnode,rsltnode,new;
497: expptr opp,p;
498: Exprp ep1,ep2;
499: idptr idp;
500:
501: p = *p_parent;
502: if(p == NULL) return(NULL);
503:
504: switch (p->tag) {
505: case TCONST :
506: return( findid(p)->initval );
507:
508: case TTEMP :
509: idp = findid(p);
510: if(idp->assgnval) return(idp->assgnval);
511:
512: lnode = idp->initval;
513: rnode = scantree( &p->tempblock.memalloc);
514:
515: rsltnode = findnode(p,lnode,rnode);
516: if(rsltnode)
517: return(rsltnode);
518: else {
519: new = newnode(p,lnode,rnode,0);
520: new->rs = new;
521: new->parent = p_parent;
522: return(new->rs);
523: }
524:
525: case TADDR :
526: idp = findid(p);
527: if(idp->assgnval) return(idp->assgnval);
528:
529: lnode = idp->initval;
530: rnode = scantree( &p->addrblock.memoffset);
531:
532: rsltnode = findnode(p,lnode,rnode);
533: if(rsltnode) {
534: if(p->addrblock.memoffset &&
535: p->addrblock.memoffset->tag == TEXPR
536: && NULL)
537: addadup(p_parent,rsltnode);
538: return(rsltnode);
539: }
540: else {
541: new = newnode(p,lnode,rnode,0);
542: new->rs = new;
543: new->parent = p_parent;
544: return(new->rs);
545: }
546:
547: case TLIST :
548: return(scanchain(p->listblock.listp,&p->listblock.listp));
549:
550: default :
551: badtag ("scantree",p->tag);
552:
553: case TEXPR :
554: lnode = scantree(&p->exprblock.leftp);
555: rnode = scantree(&p->exprblock.rightp);
556:
557: switch (p->exprblock.opcode) {
558: case OPASSIGN :
559: case OPPLUSEQ :
560: case OPSTAREQ :
561: {
562: Addrp ap;
563:
564: ap = (Addrp) p->exprblock.leftp;
565: idp = findid(ap);
566: killdepnodes(idp);
567: if( ! ap->isarray ) {
568: if(rnode->is_dead)idp->assgnval=idp->initval;
569: else idp->assgnval = rnode;
570: }
571: new = newnode(p,idp->initval,NULL,NULL);
572: appendnode(new);
573: new->rs = new;
574: return(new->rs);
575: }
576:
577: case OPCALL :
578: {
579: chainp cp;
580:
581: if(p->exprblock.rightp)
582:
583: /* pretend that all variables on the arglist have just
584: ** been assigned to i.e. kill of calculations that
585: ** depend on them. Not necessary for CCALL(by value)
586: */
587:
588: for(cp=p->exprblock.rightp->listblock.listp;
589: cp;cp=cp->nextp)
590: if (cp->datap->tag == TADDR ||
591: cp->datap->tag == TTEMP){
592: idp = findid(cp->datap);
593: killdepnodes(idp);
594: idp->assgnval = NULL;
595: }
596:
597: new = newnode(p,lnode,rnode,NULL);
598: new->rs = new;
599: return(new->rs);
600: }
601:
602: case OPCONCAT:
603: case OPADDR:
604: case OPCOLON:
605: case OPINDIRECT:
606: /*
607: * For now, do not optimize LSHIFT until OPINDIRECT
608: * implemented.
609: */
610: case OPLSHIFT:
611: new = newnode(p,lnode,rnode,NULL);
612: new->rs = new;
613: return(new->rs);
614:
615: case OPCOMMA:
616: badop ("scantree",OPCOMMA);
617: break;
618:
619: default :
620: rsltnode = findnode(p,lnode,rnode);
621: if (rsltnode) {
622: addadup(p_parent,rsltnode);
623: return(rsltnode);
624: }
625: else {
626: new = newnode(p,lnode,rnode,NULL);
627: new->rs = new;
628: new->parent = p_parent;
629: appendnode(new);
630: return(new->rs);
631: }
632: }
633: }
634: }
635:
636:
637:
638: LOCAL prunetrees()
639:
640: /* The only optcse.c routine that does any real work: go through the available
641: ** computations stack and eliminate redundant subtrees.
642: */
643:
644: {
645: Addrp tempv;
646: register duplptr dl;
647: register valuen p;
648: expptr t;
649: int is_addrnode;
650: expptr *addr_tree1 = NULL ;
651: expptr tree2 = NULL ;
652:
653: for(p=current_BB->headnode;p;p=p->next)
654: {
655: if(p->rs == NULL) {
656: if( addr_tree1 && tree2 )
657: *addr_tree1 = fixtype(mkexpr(OPCOMMA,tree2,*addr_tree1));
658: addr_tree1 = (expptr*) p->opp;
659: tree2 = NULL;
660: }
661: if (p->n_dups ) {
662:
663: if (p->opp->tag == TTEMP)
664: fprintf(diagfile,"TTEMP in prunetrees - cbb\n");
665: if(p->opp->tag == TADDR) is_addrnode = TRUE;
666: else is_addrnode = FALSE;
667:
668: if (is_addrnode)
669: tempv = mktemp(TYADDR,NULL);
670: else
671: tempv = mktemp(p->opp->exprblock.vtype,
672: p->opp->exprblock.vleng);
673: cse2count++;
674:
675: if(tree2)
676: tree2 = fixtype(mkexpr(OPCOMMA,tree2,
677: fixtype(mkexpr(OPASSIGN,cpexpr(tempv),
678: (is_addrnode ? addrof(p->opp) : p->opp)
679: ))));
680: else
681: tree2 = fixtype(mkexpr(OPASSIGN,cpexpr(tempv),
682: (is_addrnode ? addrof(p->opp) : p->opp)
683: ));
684:
685: if(is_addrnode)
686: *(p->parent) = fixtype(mkexpr(OPINDIRECT,cpexpr(tempv), NULL));
687: else
688: *(p->parent) = (expptr) cpexpr(tempv);
689:
690: /* then replaces all future instances of the calculation by references to
691: the temporary */
692:
693: for(dl=p->headduplist;dl->next;dl=dl->next) {
694: cse1count++;
695: frexpr(*dl->parent);
696: if(is_addrnode)
697: *(dl->parent) = fixtype(
698: mkexpr(OPINDIRECT,cpexpr(tempv), NULL));
699: else
700: *(dl->parent) = (expptr) cpexpr(tempv);
701: }
702:
703: /* the last reference does not use a copy since the temporary can
704: now be freed */
705:
706: cse1count++;
707: frexpr(*dl->parent);
708: if(is_addrnode)
709: *(dl->parent) = fixtype(mkexpr(OPINDIRECT,tempv, NULL));
710: else
711: *(dl->parent) = (expptr) tempv;
712:
713: frtemp (tempv);
714: }
715: }
716: if(addr_tree1 && tree2)
717: *addr_tree1 = fixtype(mkexpr(OPCOMMA,tree2,*addr_tree1));
718: }
719:
720:
721:
722: LOCAL rewritebb (bb)
723: Bblockp bb;
724: {
725: Slotp sp;
726: expptr p;
727:
728: if (bb == NULL)
729: return;
730: else
731: current_BB = bb;
732: sp = current_BB->first;
733:
734: /* loop trough all BB slots and scan candidate expr trees when found */
735:
736: for (sp = current_BB->first; ; sp = sp->next)
737: {
738: switch (sp->type)
739: {
740: case SKEQ :
741: case SKIFN :
742: case SKCMGOTO :
743: case SKCALL :
744: newnode((expptr) &sp->expr,NULL,NULL,NULL);
745: scantree(&sp->expr);
746: break;
747:
748: default :
749: break;
750: }
751: if (sp == current_BB->last) break;
752: }
753:
754: /* use the information built up by scantree to prune reduntant subtrees */
755: prunetrees();
756:
757: current_BB = NULL;
758: }
759:
760:
761:
762: /*
763: * removes all instances of OPCOMMA from the given subexpression of
764: * the given buffer slot
765: */
766:
767: expptr rmcommaop (p,sl)
768: expptr p;
769: Slotp sl;
770:
771: {
772: expptr leftp,rightp;
773: chainp cp;
774:
775: if (!p)
776: return (ENULL);
777: switch (p->tag)
778: {
779: case TEXPR:
780: leftp = p->exprblock.leftp;
781: rightp = p->exprblock.rightp;
782: leftp = rmcommaop (leftp,sl);
783: if (p->exprblock.opcode == OPCOMMA)
784: {
785: optinsert (SKEQ,leftp,0,0,sl);
786: if (p->exprblock.vleng)
787: free ((charptr) p->exprblock.vleng);
788: free ((charptr) p);
789: p = rmcommaop (rightp,sl);
790: return (p);
791: }
792: p->exprblock.leftp = leftp;
793: p->exprblock.rightp = rmcommaop (rightp,sl);
794: return (p);
795:
796: case TLIST:
797: for (cp = p->listblock.listp; cp; cp = cp->nextp)
798: cp->datap = (tagptr) rmcommaop (cp->datap,sl);
799: return (p);
800:
801: default:
802: return (p);
803: }
804: }
805:
806:
807:
808: /*
809: * scans the code buffer, performing common subexpression elimination
810: */
811:
812: optcse ()
813:
814: {
815: Slotp sl;
816: Bblockp bb;
817:
818: if (debugflag[13])
819: return;
820:
821: cse1count = 0;
822: cse2count = 0;
823: for (sl = firstslot; sl; sl = sl->next)
824: sl->expr = rmcommaop (sl->expr,sl);
825: for (bb = firstblock; bb; bb = bb->next)
826: rewritebb (bb);
827:
828: if (debugflag[0])
829: fprintf (diagfile,
830: "%d common subexpression use%s eliminated (%d definition%s)\n",
831: cse1count, (cse1count==1 ? "" : "s"),
832: cse2count, (cse2count==1 ? "" : "s"));
833: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.