![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pret.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / pret|
Return to pret.y CVS log | Up to [Research Unix] / researchv10no / cmd / pret |
1.1 root 1: %{
2: #include <stdio.h>
3: #include "pret.h"
4: #include "pret.d"
5:
6: #define YYDEBUG 1
7:
8: struct Node {
9: int ntyp; /* OP ~ nval&left&right, NM ~ val */
10: int nval;
11: struct Node *left, *right;
12: };
13:
14: extern struct Node *newnode();
15:
16: struct PARS {
17: int home;
18: int dest;
19: int bpnt;
20: } ties[MAXDEPTH];
21:
22: FILE *tb; /* temp file to store tables */
23:
24: char procname[MAXNAME], refname[MAXNAME], qsetname[MAXNAME];
25: char str[256], filename[256];
26: char strings[MANY][MAXNAME];
27: extern char yytext[];
28: extern struct QTABLE qtable[NQUEUES];
29: extern int varwidths;
30: int nnames = 0;
31: int linenumber = 1;
32: int linecode = 0; /* include source code references */
33: int nest = 0; /* nesting level of comments (lex) */
34: int anyerror = 0;
35:
36: int pid = NONE; /* process number */
37: int qid = NONE; /* queue number */
38: int rid = NONE; /* template number when defined */
39: int sid = NONE; /* qset number */
40: int nid = NONE; /* template number when refered */
41: int cid = NONE; /* index in call table */
42: int qind, qisz; /* queue's initial string size */
43: int parnum; /* counts actual parameters */
44: int assertion = -1; /* id of assertion table, if any */
45: int inertion = -1; /* id of error table, if any */
46: int vartype, inside;
47: int n, m, from, xx, zz;
48: int soo = 0; /* start of optionlist */
49: int curstate = 0;
50: int curdepth = 0;
51: int lastloop = -1;
52:
53: int verbose = 0;
54: int nopurge = 0;
55:
56: checknames()
57: {
58: checkrefs();
59: checkglobvars();
60: checkqs();
61: }
62:
63: putglobals(fd)
64: FILE *fd;
65: {
66: numrefs(fd);
67: numprocs(fd);
68: numsorts(fd);
69: numinits(fd);
70: numglobvars(fd);
71: }
72:
73: puttables(fd1)
74: FILE *fd1;
75: { FILE *fd2;
76: char buffer[MANY];
77: int howmuch;
78:
79: if ((fd2 = fopen("pret.tmp", "r")) == NULL)
80: whoops("cannot find pret.tmp");
81:
82: while ((howmuch = fread(buffer, sizeof(*buffer), MANY, fd2)) > 0)
83: fwrite(buffer, sizeof(*buffer), howmuch, fd1);
84:
85: fclose(fd2);
86: unlink("pret.tmp");
87: }
88:
89: makebin()
90: { FILE *fd;
91:
92: if ((fd = fopen((anyerror)?"pret.err":"pret.out", "w")) == NULL)
93: whoops("cannot create output file");
94:
95: putglobals(fd);
96: puttables(fd);
97: numexps(fd);
98: fclose(fd);
99: if (anyerror)
100: fprintf(stderr, "output written to `pret.err'\n");
101: }
102:
103: transfer(cl, tg)
104: { int i = curstate;
105: curstate = enterowname(NEW, "", DAR);
106: setrans(i, cl, curstate, tg);
107: }
108:
109: #include "pret.expr.c"
110:
111: %}
112: %union{
113: int resu;
114: struct Node *node;
115: }
116:
117: %type <resu> PREIO INDEX QINDEX IMPORT ASGN ASGN
118: %type <node> expr VARNAME
119: %token <resu> NAME VALUE ARNAME QSNAME
120:
121: %start PROT_SPEC
122: %token ASSERT ERROR
123: %token PROCESS PBEGIN END IF FI DO OD
124: %token timeout skip BREAK DEFAULT GOTO
125: %token FLAG ARROW SEMICOLON COLON
126: %token QUEUES QSET PVAR MESG
127: %right '=' ADDEQ SUBEQ MULEQ DIVEQ MODEQ
128: %left OR
129: %left AND
130: %left GT GE LT LE EQ NE
131: %left '+' '-'
132: %left '*' '/' '%'
133: %left UNARYMINUS NOT INC DEC
134: %right '^'
135:
136: %%
137:
138: PROT_SPEC : ONEMODULE
139: | PROT_SPEC ONEMODULE
140: ;
141:
142: ONEMODULE : PROC_SPEC
143: | TASK_SPEC
144: | ONEDECL
145: | REQUIREMENT
146: ;
147:
148: PROC_SPEC : PROCESS NAME QINDEX
149: { strcpy(procname, strings[$2]);
150: pid = newprocname(strings[$2], $3);
151: }
152: PBEGIN ANYDECLS
153: { extern int extras;
154: int ival;
155: curstate = enterowname(NEW, "", DAR);
156: newcalltable();
157: ival = 3*MANY+pid+extras;
158: addvarname("_PROCID", (DCL|RFR), ival, NONE, 0);
159: }
160: SEQUENCE END
161: { wrapup(NONE, pid, tb, nopurge, verbose);
162: pid = NONE;
163: strcpy(procname, "_");
164: }
165: ;
166:
167: ANYDECLS : /* empty */
168: | DECLS
169: ;
170: DECLS : ONEDECL
171: | DECLS ONEDECL
172: ;
173:
174: ONEDECL : QDECLS
175: | VARDECLS
176: ;
177: /*
178: * QUEUES
179: * ======
180: */
181:
182: QDECLS : QUEUES QDECL SEPARATOR
183: ;
184: QDECL : ONEQ
185: | QNAMELIST
186: ;
187:
188: ONEQ : NAME QINDEX '='
189: { if ($2 == NONE || (qisz=$2) <= 0)
190: yyerror("illegal queue size, %s", strings[$1]);
191: qid = newqname(strings[$1], DCL, qisz, NONE);
192: }
193: PBEGIN MNAMELIST END
194: ;
195:
196: /*
197: * VARIABLES and QUEUESETS
198: * =======================
199: */
200:
201: VARDECLS : PVAR VNAMELIST SEPARATOR
202: | QSET QSETDECL SEPARATOR
203: ;
204:
205: QINDEX : /* empty */ { $$ = NONE; }
206: | '[' VALUE ']' { $$ = $2; }
207: ;
208:
209: QSETDECL : NAME PBEGIN NAME QINDEX COLON
210: { xx = newqname(strings[$3], RFR, NONE, $4);
211: sid = newqset(strings[$1], strings[$3], DCL, $4);
212: }
213: SNAMELIST END
214: { closeqset(sid);
215: }
216: ;
217: /*
218: * PROCEDURES
219: * ==========
220: */
221:
222: TASK_SPEC : NAME
223: { rid = newreftask(strings[$1], DCL);
224: curstate = enterowname(NEW, "", DAR);
225: strcpy(refname, strings[$1]);
226: newcalltable();
227: vartype = ISV;
228: inside = 1;
229: }
230: '(' ANYPARAMS ')'
231: { inside = 0;
232: }
233: ANYPARTYPES
234: { reorder(); /* renumber formal parameters */
235: }
236: PBEGIN
237: ANYDECLS
238: SEQUENCE
239: END
240: { wrapup(rid, NONE, tb, nopurge, verbose);
241: strcpy(refname, "_");
242: rid = NONE;
243: }
244: ;
245:
246: ANYPARAMS : /* empty */
247: | PNAMELIST
248: | error
249: { yyerror("bad namelist", "");
250: }
251:
252: ;
253:
254: ANYPARTYPES : /* empty */
255: | PARTYPES
256: | error
257: { yyerror("bad parameterlist", "");
258: }
259: ;
260:
261: PARTYPES : ONEPARTYPE SEMICOLON
262: | PARTYPES ONEPARTYPE SEMICOLON
263: ;
264: ONEPARTYPE : PVAR
265: { vartype = ISV;
266: }
267: PNAMELIST
268: | QSET NAME PBEGIN NAME COLON
269: { strcpy(qsetname, strings[$2]);
270: sid = newqset(strings[$2], strings[$4], DCL, NONE);
271: qid = addFpar(rid, strings[$2], sid, ISQ, inside);
272: vartype = ISM;
273: }
274: PNAMELIST END
275: { qid = NONE;
276: closeqset(sid);
277: }
278: ;
279: /*
280: * REQUIREMENTS
281: * ============
282: */
283: REQUIREMENT : ASSERT
284: PBEGIN
285: { rid = newreftask(" assert", DCL);
286: assertion = rid;
287: curstate = enterowname(NEW, "", DAR);
288: strcpy(refname, " assert");
289: newcalltable();
290: }
291: _SEQUENCE
292: END
293: { wrapup(rid, NONE, tb, nopurge, verbose);
294: strcpy(refname, "_");
295: rid = NONE;
296: lastloop = -1;
297: }
298: | ERROR
299: PBEGIN
300: { rid = newreftask(" error", DCL);
301: inertion = rid;
302: curstate = enterowname(NEW, "", DAR);
303: strcpy(refname, " error");
304: newcalltable();
305: }
306: _SEQUENCE
307: END
308: { wrapup(rid, NONE, tb, nopurge, verbose);
309: strcpy(refname, "_");
310: rid = NONE;
311: lastloop = -1;
312: }
313: ;
314: _SEQUENCE : _STMNT
315: | _SEQUENCE SEPARATOR _STMNT
316: ;
317:
318: _STMNT : skip { lastloop = -1; }
319: | _SELECT { lastloop = -1; }
320: | _CYCLE
321: | SEND { lastloop = -1; }
322: | GUARD { lastloop = -1; }
323: | STRUCTGOTO { lastloop = -1; }
324: | error
325: { yyerror("illegal assertion statement, %s", yytext);
326: }
327: ;
328: _SELECT : IF
329: { if (++curdepth == MAXDEPTH)
330: whoops("nesting too deep");
331:
332: ties[curdepth].home = curstate;
333: ties[curdepth].dest = enterowname(NEW, "", DAR);
334: ties[curdepth].bpnt =
335: (curdepth > 1) ? ties[curdepth-1].bpnt : -1;
336: }
337: _OPTIONLIST FI
338: { setrowname(ties[curdepth].dest);
339: curstate = ties[curdepth--].dest;
340: }
341: ;
342:
343: _CYCLE : DO
344: { if (curdepth++ == MAXDEPTH)
345: whoops("nesting too deep");
346:
347: labelrow(curstate);
348: ties[curdepth].home = curstate;
349: ties[curdepth].dest = curstate;
350: ties[curdepth].bpnt = enterowname(NEW, "", DAR);
351: }
352: _OPTIONLIST OD
353: { lastloop = ties[curdepth].home;
354: setrowname(ties[curdepth].bpnt);
355: curstate = ties[curdepth--].bpnt;
356: }
357: ;
358: _OPTIONLIST : _ONEOPTION
359: | _ONEOPTION _OPTIONLIST
360: ;
361:
362: _ONEOPTION : FLAG _SEQUENCE
363: { getrowname(str, ties[curdepth].dest);
364: from = curstate;
365: curstate = enterowname(OLD, str, DAR);
366: setrans(from, 0, curstate, NONE);
367: curstate = ties[curdepth].home;
368: }
369: ;
370: /*
371: * NAMELISTS
372: * =========
373: */
374:
375: ANAMELIST : ANAME
376: | ANAMELIST ',' ANAME
377: ;
378: MNAMELIST : MNAME
379: | MNAMELIST ',' MNAME
380: ;
381: PNAMELIST : PNAME
382: | PNAMELIST ',' PNAME
383: ;
384: QNAMELIST : QNAME
385: | QNAMELIST ',' QNAME
386: ;
387: SNAMELIST : SNAME
388: | SNAMELIST ',' SNAME
389: ;
390: VNAMELIST : VNAME
391: | VNAMELIST ',' VNAME
392: ;
393: /*
394: * NAMES
395: * =====
396: */
397:
398: ANAME : QSNAME { addApars(strings[$1], nid, parnum++, NONE); }
399: | expr { addAspecial(makeexpr($1), nid, parnum++); }
400: ;
401: MNAME : NAME
402: { qtable[qid].status |= ADR;
403: addmsg(strings[$1], qid, SND, INITM, NONE);
404: if (--qisz < 0)
405: yyerror("queue overfilled, %s", strings[$1]);
406: }
407: ;
408: PNAME : NAME
409: { if (vartype == ISM)
410: addsetname(strings[$1], sid, 1);
411: else
412: addFpar(rid, strings[$1], qid, vartype, inside);
413: }
414: ;
415: QNAME : NAME '[' VALUE ']'
416: { if ((qisz = $3) <= 0)
417: yyerror("illegal queue size, %s", strings[$1]);
418: newqname(strings[$1], DCL, $3, NONE);
419: }
420: | NAME '[' VALUE ']' '[' VALUE ']'
421: { if ((qisz = $6) <= 0)
422: yyerror("illegal queue size, %s", strings[$1]);
423: newqname(strings[$1], DCL, qisz, $3);
424: }
425: ;
426: SNAME : NAME { addsetname(strings[$1], sid, 0); }
427: ;
428: VNAME : NAME QINDEX
429: { addvarname(strings[$1], DCL, NONE, $2, 0);
430: }
431: | NAME QINDEX '=' expr
432: { addvarname(strings[$1], DCL, makeexpr($4), $2, 0);
433: }
434: | NAME QINDEX COLON VALUE
435: { addvarname(strings[$1], DCL, NONE, $2, $4);
436: }
437: ;
438: /*
439: * CODE
440: * ====
441: */
442:
443: SEQUENCE : STMNT
444: { soo = 0;
445: }
446: | SEQUENCE SEPARATOR STMNT
447: { soo = 0;
448: }
449: ;
450:
451: STMNT : skip
452: { if (soo) /* only if used as a guard */
453: transfer(0, NONE);
454: }
455: | SELECT
456: | CYCLE
457: | SEND
458: | GUARD
459: | JUMP
460: | LABEL STMNT
461: | TEMPLATE
462: | BUILTIN
463: | CONDITIONAL
464: | END
465: { yyerror("expecting a statement", "");
466: whoops("exit");
467: }
468: ;
469:
470: SELECT : IF
471: { if (++curdepth == MAXDEPTH)
472: whoops("nesting too deep");
473:
474: ties[curdepth].home = curstate;
475: ties[curdepth].dest = enterowname(NEW, "", DAR);
476: ties[curdepth].bpnt =
477: (curdepth>1) ? ties[curdepth-1].bpnt : -1;
478: }
479: OPTIONLIST FI
480: { setrowname(ties[curdepth].dest);
481: curstate = ties[curdepth--].dest;
482: }
483: ;
484:
485: CYCLE : DO
486: { if (curdepth++ == MAXDEPTH)
487: whoops("nesting too deep");
488:
489: labelrow(curstate);
490: ties[curdepth].home = curstate;
491: ties[curdepth].dest = curstate;
492: ties[curdepth].bpnt = enterowname(NEW, "", DAR);
493: }
494: OPTIONLIST OD
495: { setrowname(ties[curdepth].bpnt);
496: curstate = ties[curdepth--].bpnt;
497: }
498: ;
499:
500: OPTIONLIST : ONEOPTION
501: | ONEOPTION OPTIONLIST
502: ;
503:
504: ONEOPTION : FLAG
505: { soo = 1; /* start of an option string */
506: }
507: SEQUENCE
508: { getrowname(str, ties[curdepth].dest);
509: from = curstate;
510: curstate = enterowname(OLD, str, DAR);
511: setrans(from, 0, curstate, NONE);
512: curstate = ties[curdepth].home;
513: }
514: ;
515:
516: INDEX : /* empty */ { $$ = NONE; }
517: | '[' expr ']' { $$ = makeexpr($2); }
518: ;
519:
520: PREIO : NAME INDEX
521: { strcpy(str, strings[$1]); /* swivel away name */
522: $$ = $2;
523: }
524: ;
525:
526: SEND : PREIO NOT NAME EXPORT
527: { xx = newqname(str, ADR, NONE, $1);
528: zz = addmsg(strings[$3], xx, SND, NORM, $1);
529: n = entercolname(zz, OUTP);
530: transfer(n, m);
531: }
532: ;
533:
534: EXPORT : /* empty */ { m = NONE; }
535: | '(' expr ')' { m = makeexpr($2); }
536: ;
537:
538: GUARD : PREIO '?' timeout
539: { int x;
540: xx = newqname(str, RFR, NONE, $1);
541: x = addmsg(" tau", xx, SAR, NORM, $1);
542: /*
543: ** the leading space is to avoid
544: ** clashes with a user name `tau',
545: ** e.g. in a formal parameter list
546: */
547: n = entercolname(x, TMO);
548: transfer(n, NONE);
549: }
550: | PREIO '?' NAME IMPORT
551: { xx = newqname(str, RFR, NONE, $1);
552: zz = addmsg(strings[$3], xx, RCV, NORM, $1);
553: n = entercolname(zz, INP);
554: transfer(n, $4);
555: }
556: | PREIO '?' DEFAULT IMPORT
557: { xx = newqname(str, RFR, NONE, $1);
558: zz = addmsg(" any", xx, SAR, NORM, $1);
559: n = entercolname(zz, DFL);
560: transfer(n, $4);
561: }
562: ;
563:
564: IMPORT : /* empty */
565: { $$ = NONE;
566: }
567: | '(' ARNAME INDEX ')'
568: { $$ = addvarname(strings[$2], RFR, NONE, $3, 0);
569: }
570: | '(' NAME ')'
571: { $$ = addvarname(strings[$2], RFR, NONE, NONE, 0);
572: }
573: | '(' VALUE ')'
574: { yyerror("importing into constant", "");
575: }
576: ;
577:
578: SEPARATOR : ARROW
579: | SEMICOLON
580: | error
581: { yyerror("expecting a stmnt separator", "");
582: }
583: ;
584:
585: JUMP : GOTO NAME
586: { from = curstate;
587: curstate = enterowname(LAB, strings[$2], ADR);
588: setrans(from, 0, curstate, NONE);
589: curstate = enterowname(NEW, "", DAR);
590: }
591: | STRUCTGOTO
592: ;
593:
594: STRUCTGOTO : BREAK
595: { int i;
596: from = curstate;
597: i = ties[curdepth].bpnt;
598:
599: if (curdepth == 0 || i == -1)
600: whoops("illegal break statement");
601:
602: getrowname(str, i);
603: curstate = enterowname(OLD, str, DAR);
604: setrans(from, 0, curstate, NONE);
605: curstate = enterowname(NEW, "", DAR);
606: }
607: ;
608:
609: TEMPLATE : NAME
610: { nid = newreftask(strings[$1], RFR);
611: parnum = 0; qid = sid = NONE;
612: cid = newcall(nid);
613: }
614: '(' ANYACTUALS ')'
615: { int x;
616: parrefs(parnum, nid);
617: x = entercolname(cid, FCT);
618: transfer(x, NONE);
619: }
620: ;
621:
622: ANYACTUALS : /* empty */
623: | ANAMELIST
624: ;
625:
626: CONDITIONAL : '(' expr ')'
627: { transfer(entercolname(makeexpr($2), CND), NONE);
628: }
629: ;
630:
631: VARNAME : ARNAME INDEX
632: { m = addvarname(strings[$1], RFR, NONE, $2, 0);
633: $$ = newnode(NM, m, NULL, NULL);
634: }
635: | NAME
636: { m = addvarname(strings[$1], RFR, NONE, NONE, 0);
637: $$ = newnode(NM, m, NULL, NULL);
638: }
639: ;
640:
641: BUILTIN : VARNAME ASGN expr
642: { m = makeexpr(newnode(OP, $2, $1, $3));
643: transfer(0, m);
644: }
645: | VARNAME INC
646: { m = makeexpr(newnode(OP, poinc, $1, NULL));
647: transfer(0, m);
648: }
649: | VARNAME DEC
650: { m = makeexpr(newnode(OP, podec, $1, NULL));
651: transfer(0, m);
652: }
653: ;
654:
655: ASGN : '=' { $$ = setv; }
656: | ADDEQ { $$ = addeq; }
657: | SUBEQ { $$ = subeq; }
658: | MULEQ { $$ = muleq; }
659: | DIVEQ { $$ = diveq; }
660: | MODEQ { $$ = modeq; }
661: ;
662:
663: expr : expr '+' expr { $$ = newnode(OP, plus, $1, $3); }
664: | expr '-' expr { $$ = newnode(OP, minus, $1, $3); }
665: | expr '*' expr { $$ = newnode(OP, times, $1, $3); }
666: | expr '/' expr { $$ = newnode(OP, div, $1, $3); }
667: | expr '%' expr { $$ = newnode(OP, mod, $1, $3); }
668: | expr '^' expr { $$ = newnode(OP, power, $1, $3); }
669: | expr GT expr { $$ = newnode(OP, gt, $1, $3); }
670: | expr GE expr { $$ = newnode(OP, ge, $1, $3); }
671: | expr LT expr { $$ = newnode(OP, lt, $1, $3); }
672: | expr LE expr { $$ = newnode(OP, le, $1, $3); }
673: | expr EQ expr { $$ = newnode(OP, eq, $1, $3); }
674: | expr NE expr { $$ = newnode(OP, ne, $1, $3); }
675: | expr AND expr { $$ = newnode(OP, land, $1, $3); }
676: | expr OR expr { $$ = newnode(OP, lor, $1, $3); }
677: | '-' expr %prec UNARYMINUS
678: { $$ = newnode(OP, uminus, $2, NULL); }
679: | NOT expr
680: { $$ = newnode(OP, lnot, $2, NULL); }
681: | VALUE
682: { $$ = newnode(NM, $1+3*MANY, NULL, NULL); }
683: | ARNAME INDEX
684: { m = addvarname(strings[$1], RFR, NONE, $2, 0);
685: $$ = newnode(NM, m, NULL, NULL);
686: }
687: | NAME
688: { m = addvarname(strings[$1], RFR, NONE, NONE, 0);
689: $$ = newnode(NM, m, NULL, NULL);
690: }
691: | '(' expr ')' { $$ = $2; }
692: ;
693:
694: LABEL : NAME COLON
695: { from = curstate;
696: curstate = enterowname(LAB, strings[$1], DCL);
697: labelrow(curstate);
698: setrans(from, 0, curstate, NONE);
699: }
700: ;
701: %%
702:
703: extern FILE *yyin;
704:
705: main(argc, argv)
706: char **argv;
707: {
708: int base = 1, i = 1;
709: char c, buff[256];
710: char outfile[32];
711:
712: if (argc > base && argv[1][0] == '-')
713: { while ((c = argv[1][i++]) != '\0')
714: switch (c) {
715: case 's': varwidths = 1; break;
716: case 'v': verbose = 1; break;
717: case 'n': nopurge = 1; break;
718: case 'l': linecode = 1; break;
719: default : fprintf(stderr, "usage: pret [-vsnl] file\n");
720: fprintf(stderr, "\tv - verbose\n");
721: fprintf(stderr, "\ts - supertrace format\n");
722: fprintf(stderr, "\tn - no minimization\n");
723: fprintf(stderr, "\tl - enables linecode\n");
724: exit(1);
725: }
726: base++;
727: }
728: if (argc <= base)
729: { fprintf(stderr, "usage: pret [-vnl] file\n");
730: exit(1);
731:
732: }
733: if ((tb = fopen("pret.tmp", "w")) == NULL)
734: whoops("cannot create pret.tmp\n");
735:
736: strcpy(procname, "_");
737: strcpy(refname, "_");
738: unlink("pret.out");
739: unlink("pret.err");
740:
741: if (argc > base)
742: { strcpy(filename, argv[base]);
743:
744: mktemp(strcpy(outfile, "/tmp/trans.XXXXXX"));
745: sprintf(buff, "/lib/cpp %s > %s", filename, outfile);
746:
747: if (system(buff))
748: { unlink(outfile);
749: exit(1);
750: } else
751: if ((yyin = fopen(outfile, "r")) == NULL)
752: { printf("cannot open %s\n", outfile);
753: whoops("aborting");
754: }
755: unlink(outfile);
756: }
757: parsed = (struct REVPOL *)
758: Emalloc(EXPRMAX * sizeof(struct REVPOL));
759: prs = 0;
760:
761: yyparse();
762: prepsorts();
763: checknames();
764: fclose(tb);
765: chatter();
766: makebin();
767: exit(0);
768: }
769:
770: newstring(str)
771: char *str;
772: { register int i;
773:
774: for (i = 0; i < nnames; i++)
775: if (strcmp(str, strings[i]) == 0)
776: return i;
777: if (++nnames >= MANY)
778: yyerror("symbol table overflow, %s", str);
779: strncpy(strings[i], str, MAXNAME-1);
780: return i;
781: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.