![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pas.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / pxp|
Return to pas.y CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / pxp |
1.1 root 1: /*
2: * pi - Pascal interpreter code translator
3: *
4: * Charles Haley, Bill Joy UCB
5: * Version 1.0 August 1977
6: *
7: * pxp - Pascal execution profiler
8: *
9: * Bill Joy UCB
10: * Version 1.0 August 1977
11: */
12:
13: /*
14: * Yacc grammar for UNIX Pascal
15: *
16: * This grammar is processed by the commands in the shell script
17: * "gram" to yield parse tables and semantic routines in the file
18: * "y.tab.c" and a header defining the lexical tokens in "yy.h".
19: *
20: * In order for the syntactic error recovery possible with this
21: * grammar to work, the grammar must be processed by a yacc which
22: * has been modified to fully enumerate possibilities in states
23: * which involve the symbol "error".
24: * The parser used for Pascal also uses a different encoding of
25: * the test entries in the action table which speeds the parse.
26: * A version of yacc which will work for Pascal is included on
27: * the distribution table as "eyacc".
28: *
29: * The "gram" script also makes the following changes to the "y.tab.c"
30: * file:
31: *
32: * 1) Causes yyval to be declared int *.
33: *
34: * 2) Loads the variable yypv into a register as yyYpv so that
35: * the arguments $1, ... are available as yyYpv[1] etc.
36: * This produces much smaller code in the semantic actions.
37: *
38: * 3) Deletes the unused array yysterm.
39: *
40: * 4) Moves the declarations up to the flag line containing
41: * '##' to the file yy.h so that the routines which use
42: * these "magic numbers" don't have to all be compiled at
43: * the same time.
44: *
45: * 5) Creates the semantic restriction checking routine yyEactr
46: * by processing action lines containing `@'.
47: *
48: * This compiler uses a different version of the yacc parser, a
49: * different yyerror which is called yerror, and requires more
50: * lookahead sets than normally provided by yacc.
51: *
52: * Source for the yacc used with this grammar is included on
53: * distribution tapes.
54: */
55:
56: /*
57: * TERMINAL DECLARATIONS
58: *
59: * Some of the terminal declarations are out of the most natural
60: * alphabetic order because the error recovery
61: * will guess the first of equal cost non-terminals.
62: * This makes, e.g. YTO preferable to YDOWNTO.
63: */
64:
65: %term
66: YAND YARRAY YBEGIN YCASE
67: YCONST YDIV YDO YDOTDOT
68: YTO YELSE YEND YFILE
69: YFOR YFORWARD YFUNCTION YGOTO
70: YID YIF YIN YINT
71: YLABEL YMOD YNOT YNUMB
72: YOF YOR YPACKED YNIL
73: YPROCEDURE YPROG YRECORD YREPEAT
74: YSET YSTRING YTHEN YDOWNTO
75: YTYPE YUNTIL YVAR YWHILE
76: YWITH YBINT YOCT YHEX
77: YASSERT YCASELAB YILLCH YLAST
78:
79: /*
80: * PRECEDENCE DECLARATIONS
81: *
82: * Highest precedence is the unary logical NOT.
83: * Next are the multiplying operators, signified by '*'.
84: * Lower still are the binary adding operators, signified by '+'.
85: * Finally, at lowest precedence and non-associative are the relationals.
86: */
87:
88: %binary '<' '=' '>' YIN
89: %left '+' '-' YOR '|'
90: %left UNARYSIGN
91: %left '*' '/' YDIV YMOD YAND '&'
92: %left YNOT
93:
94: %{
95:
96: /*
97: * GLOBALS FOR ACTIONS
98: */
99:
100: /*
101: * The following line marks the end of the yacc
102: * Constant definitions which are removed from
103: * y.tab.c and placed in the file y.tab.h.
104: */
105: ##
106:
107: #include "0.h"
108: #include "yy.h"
109: #include "tree.h"
110:
111: #ifdef PI
112: #define lineof(l) l
113: #define line2of(l) l
114: #endif
115:
116: %}
117:
118: %%
119:
120: /*
121: * PRODUCTIONS
122: */
123:
124: goal:
125: prog_hedr decls procs block '.'
126: = funcend($1, $4, lineof($5));
127: ;
128:
129: prog_hedr:
130: YPROG YID '(' id_list ')' ';'
131: = $$ = funcbody(funchdr(tree5(T_PROG, lineof($1), $2, fixlist($4), NIL)));
132: |
133: YPROG error
134: = {
135: yyPerror("Malformed program statement", PPROG);
136: /*
137: * Should make a program statement
138: * with "input" and "output" here.
139: */
140: $$ = funcbody(funchdr(tree5(T_PROG, lineof($1), NIL, NIL, NIL)));
141: }
142: ;
143: block:
144: YBEGIN stat_list YEND
145: = {
146: $$ = tree3(T_BSTL, lineof($1), fixlist($2));
147: if ($3.pint < 0)
148: brerror($1, "begin");
149: }
150: ;
151:
152:
153: /*
154: * DECLARATION PART
155: */
156: decls:
157: decls decl
158: = trfree();
159: |
160: decls error
161: = {
162: Derror:
163: constend(), typeend(), varend(), trfree();
164: yyPerror("Malformed declaration", PDECL);
165: }
166: |
167: /* lambda */
168: = trfree();
169: ;
170:
171: decl:
172: labels
173: |
174: const_decl
175: = constend();
176: |
177: type_decl
178: = typeend();
179: |
180: var_decl
181: = varend();
182: ;
183:
184: /*
185: * LABEL PART
186: */
187:
188: labels:
189: YLABEL label_decl ';'
190: = label(fixlist($2), lineof($1));
191: ;
192: label_decl:
193: YINT
194: = $$ = newlist($1 == NIL ? NIL : *hash($1, 1));
195: |
196: label_decl ',' YINT
197: = $$ = addlist($1, $3 == NIL ? NIL : *hash($3, 1));
198: ;
199:
200: /*
201: * CONST PART
202: */
203:
204: const_decl:
205: YCONST YID '=' const ';'
206: = constbeg($1, line2of($2)), const(lineof($3), $2, $4);
207: |
208: const_decl YID '=' const ';'
209: = const(lineof($3), $2, $4);
210: |
211: YCONST error
212: = {
213: constbeg($1, line2of($1));
214: Cerror:
215: yyPerror("Malformed const declaration", PDECL);
216: }
217: |
218: const_decl error
219: = goto Cerror;
220: ;
221:
222: /*
223: * TYPE PART
224: */
225:
226: type_decl:
227: YTYPE YID '=' type ';'
228: = typebeg($1, line2of($2)), type(lineof($3), $2, $4);
229: |
230: type_decl YID '=' type ';'
231: = type(lineof($3), $2, $4);
232: |
233: YTYPE error
234: = {
235: typebeg($1, line2of($1));
236: Terror:
237: yyPerror("Malformed type declaration", PDECL);
238: }
239: |
240: type_decl error
241: = goto Terror;
242: ;
243:
244: /*
245: * VAR PART
246: */
247:
248: var_decl:
249: YVAR id_list ':' type ';'
250: = varbeg($1, line2of($3)), var(lineof($3), fixlist($2), $4);
251: |
252: var_decl id_list ':' type ';'
253: = var(lineof($3), fixlist($2), $4);
254: |
255: YVAR error
256: = {
257: varbeg($1, line2of($1));
258: Verror:
259: yyPerror("Malformed var declaration", PDECL);
260: }
261: |
262: var_decl error
263: = goto Verror;
264: ;
265:
266: /*
267: * PROCEDURE AND FUNCTION DECLARATION PART
268: */
269:
270: procs:
271: /* lambda */
272: |
273: procs proc
274: = trfree();
275: ;
276: proc:
277: phead YFORWARD ';'
278: = funcfwd($1);
279: |
280: pheadres decls procs block ';'
281: = funcend($1, $4, lineof($5));
282: ;
283: pheadres:
284: phead
285: = funcbody($1);
286: ;
287: phead:
288: porf YID params ftype ';'
289: = $$ = funchdr(tree5($1, lineof($5), $2, $3, $4));
290: ;
291: porf:
292: YPROCEDURE
293: = $$ = T_PDEC;
294: |
295: YFUNCTION
296: = $$ = T_FDEC;
297: ;
298: params:
299: '(' param_list ')'
300: = $$ = fixlist($2);
301: |
302: /* lambda */
303: = $$ = NIL;
304: ;
305:
306: /*
307: * PARAMETERS
308: */
309:
310: param:
311: id_list ':' type
312: = $$ = tree3(T_PVAL, fixlist($1), $3);
313: |
314: YVAR id_list ':' type
315: = $$ = tree3(T_PVAR, fixlist($2), $4);
316: |
317: YFUNCTION id_list ':' type
318: = $$ = tree3(T_PFUNC, fixlist($2), $4);
319: |
320: YPROCEDURE id_list
321: = $$ = tree2(T_PPROC, fixlist($2));
322: ;
323: ftype:
324: ':' type
325: = $$ = $2;
326: |
327: /* lambda */
328: = $$ = NIL;
329: ;
330: param_list:
331: param
332: = $$ = newlist($1);
333: |
334: param_list ';' param
335: = $$ = addlist($1, $3);
336: ;
337:
338: /*
339: * CONSTANTS
340: */
341:
342: const:
343: YSTRING
344: = $$ = tree2(T_CSTRNG, $1);
345: |
346: number
347: |
348: '+' number
349: = $$ = tree2(T_PLUSC, $2);
350: |
351: '-' number
352: = $$ = tree2(T_MINUSC, $2);
353: ;
354: number:
355: const_id
356: = $$ = tree2(T_ID, $1);
357: |
358: YINT
359: = $$ = tree2(T_CINT, $1);
360: |
361: YBINT
362: = $$ = tree2(T_CBINT, $1);
363: |
364: YNUMB
365: = $$ = tree2(T_CFINT, $1);
366: ;
367: const_list:
368: const
369: = $$ = newlist($1);
370: |
371: const_list ',' const
372: = $$ = addlist($1, $3);
373: ;
374:
375: /*
376: * TYPES
377: */
378:
379: type:
380: simple_type
381: |
382: '^' YID
383: = $$ = tree3(T_TYPTR, lineof($1), tree2(T_ID, $2));
384: |
385: struct_type
386: |
387: YPACKED struct_type
388: = $$ = tree3(T_TYPACK, lineof($1), $2);
389: ;
390: simple_type:
391: type_id
392: |
393: '(' id_list ')'
394: = $$ = tree3(T_TYSCAL, lineof($1), fixlist($2));
395: |
396: const YDOTDOT const
397: = $$ = tree4(T_TYRANG, lineof($2), $1, $3);
398: ;
399: struct_type:
400: YARRAY '[' simple_type_list ']' YOF type
401: = $$ = tree4(T_TYARY, lineof($1), fixlist($3), $6);
402: |
403: YFILE YOF type
404: = $$ = tree3(T_TYFILE, lineof($1), $3);
405: |
406: YSET YOF simple_type
407: = $$ = tree3(T_TYSET, lineof($1), $3);
408: |
409: YRECORD field_list YEND
410: = {
411: $$ = tree3(T_TYREC, lineof($1), $2);
412: if ($3.pint < 0)
413: brerror($1, "record");
414: }
415: ;
416: simple_type_list:
417: simple_type
418: = $$ = newlist($1);
419: |
420: simple_type_list ',' simple_type
421: = $$ = addlist($1, $3);
422: ;
423:
424: /*
425: * RECORD TYPE
426: */
427: field_list:
428: fixed_part variant_part
429: = $$ = tree4(T_FLDLST, lineof(NIL), fixlist($1), $2);
430: ;
431: fixed_part:
432: field
433: = $$ = newlist($1);
434: |
435: fixed_part ';' field
436: = $$ = addlist($1, $3);
437: |
438: fixed_part error
439: = yyPerror("Malformed record declaration", PDECL);
440: ;
441: field:
442: /* lambda */
443: = $$ = NIL;
444: |
445: id_list ':' type
446: = $$ = tree4(T_RFIELD, lineof($2), fixlist($1), $3);
447: ;
448:
449: variant_part:
450: /* lambda */
451: = $$ = NIL;
452: |
453: YCASE type_id YOF variant_list
454: = $$ = tree5(T_TYVARPT, lineof($1), NIL, $2, fixlist($4));
455: |
456: YCASE YID ':' type_id YOF variant_list
457: = $$ = tree5(T_TYVARPT, lineof($1), $2, $4, fixlist($6));
458: ;
459: variant_list:
460: variant
461: = $$ = newlist($1);
462: |
463: variant_list ';' variant
464: = $$ = addlist($1, $3);
465: |
466: variant_list error
467: = yyPerror("Malformed record declaration", PDECL);
468: ;
469: variant:
470: /* lambda */
471: = $$ = NIL;
472: |
473: const_list ':' '(' field_list ')'
474: = $$ = tree4(T_TYVARNT, lineof($2), fixlist($1), $4);
475: |
476: const_list ':' '(' ')'
477: = $$ = tree4(T_TYVARNT, lineof($2), fixlist($1), NIL);
478: ;
479:
480: /*
481: * STATEMENT LIST
482: */
483:
484: stat_list:
485: stat
486: = $$ = newlist($1);
487: |
488: stat_lsth stat
489: = {
490: if ((p = $1) != NIL && (q = p[1])[0] == T_IFX) {
491: q[0] = T_IFEL;
492: q[4] = $2;
493: } else
494: $$ = addlist($1, $2);
495: }
496: ;
497:
498: stat_lsth:
499: stat_list ';'
500: = if ((q = $1) != NIL && (p = q[1]) != NIL && p[0] == T_IF) {
501: if (yychar < 0)
502: yychar = yylex();
503: if (yyshifts >= 2 && yychar == YELSE) {
504: recovered();
505: copy(&Y, &OY, sizeof Y);
506: yerror("Deleted ';' before keyword else");
507: yychar = yylex();
508: p[0] = T_IFX;
509: }
510: }
511: ;
512:
513: /*
514: * CASE STATEMENT LIST
515: */
516:
517: cstat_list:
518: cstat
519: = $$ = newlist($1);
520: |
521: cstat_list ';' cstat
522: = $$ = addlist($1, $3);
523: |
524: error
525: = {
526: $$ = NIL;
527: Kerror:
528: yyPerror("Malformed statement in case", PSTAT);
529: }
530: |
531: cstat_list error
532: = goto Kerror;
533: ;
534:
535: cstat:
536: const_list ':' stat
537: = $$ = tree4(T_CSTAT, lineof($2), fixlist($1), $3);
538: |
539: YCASELAB stat
540: = $$ = tree4(T_CSTAT, lineof($1), NIL, $2);
541: |
542: /* lambda */
543: = $$ = NIL;
544: ;
545:
546: /*
547: * STATEMENT
548: */
549:
550: stat:
551: /* lambda */
552: = $$ = NIL;
553: |
554: YINT ':' stat
555: = $$ = tree4(T_LABEL, lineof($2), $1 == NIL ? NIL : *hash($1, 1), $3);
556: |
557: proc_id
558: = $$ = tree4(T_PCALL, lineof(yyline), $1, NIL);
559: |
560: proc_id '(' wexpr_list ')'
561: = $$ = tree4(T_PCALL, lineof($2), $1, fixlist($3));
562: |
563: YID error
564: = goto NSerror;
565: |
566: assign
567: |
568: YBEGIN stat_list YEND
569: = {
570: $$ = tree3(T_BLOCK, lineof($1), fixlist($2));
571: if ($3.pint < 0)
572: brerror($1, "begin");
573: }
574: |
575: YCASE expr YOF cstat_list YEND
576: = {
577: $$ = tree4(T_CASE, lineof($1), $2, fixlist($4));
578: if ($5.pint < 0)
579: brerror($1, "case");
580: }
581: |
582: YWITH var_list YDO stat
583: = $$ = tree4(T_WITH, lineof($1), fixlist($2), $4);
584: |
585: YWHILE expr YDO stat
586: = $$ = tree4(T_WHILE, lineof($1), $2, $4);
587: |
588: YREPEAT stat_list YUNTIL expr
589: = $$ = tree4(T_REPEAT, lineof($3), fixlist($2), $4);
590: |
591: YFOR assign YTO expr YDO stat
592: = $$ = tree5(T_FORU, lineof($1), $2, $4, $6);
593: |
594: YFOR assign YDOWNTO expr YDO stat
595: = $$ = tree5(T_FORD, lineof($1), $2, $4, $6);
596: |
597: YGOTO YINT
598: = $$ = tree3(T_GOTO, lineof($1), *hash($2, 1));
599: |
600: YIF expr YTHEN stat
601: = $$ = tree5(T_IF, lineof($1), $2, $4, NIL);
602: |
603: YIF expr YTHEN stat YELSE stat
604: = $$ = tree5(T_IFEL, lineof($1), $2, $4, $6);
605: |
606: YIF expr YTHEN stat YELSE
607: = $$ = tree5(T_IFEL, lineof($1), $2, $4, NIL);
608: |
609: YASSERT '(' expr ')'
610: = $$ = tree3(T_ASRT, lineof($1), $3);
611: |
612: error
613: = {
614: NSerror:
615: $$ = NIL;
616: Serror:
617: yyPerror("Malformed statement", PSTAT);
618: }
619: ;
620: assign:
621: variable ':' '=' expr
622: = $$ = tree4(T_ASGN, lineof($2), $1, $4);
623: ;
624:
625: /*
626: * EXPRESSION
627: */
628:
629: expr:
630: error
631: = {
632: NEerror:
633: $$ = NIL;
634: Eerror:
635: yyPerror("Missing/malformed expression", PEXPR);
636: }
637: |
638: expr relop expr %prec '<'
639: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3);
640: |
641: '+' expr %prec UNARYSIGN
642: = $$ = tree3(T_PLUS, $2[1], $2);
643: |
644: '-' expr %prec UNARYSIGN
645: = $$ = tree3(T_MINUS, $2[1], $2);
646: |
647: expr addop expr %prec '+'
648: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3);
649: |
650: expr divop expr %prec '*'
651: = $$ = tree4($2, $1[1] == SAWCON ? $3[1] : $1[1], $1, $3);
652: |
653: YNIL
654: = $$ = tree2(T_NIL, NOCON);
655: |
656: YSTRING
657: = $$ = tree3(T_STRNG, SAWCON, $1);
658: |
659: YINT
660: = $$ = tree3(T_INT, NOCON, $1);
661: |
662: YBINT
663: = $$ = tree3(T_BINT, NOCON, $1);
664: |
665: YNUMB
666: = $$ = tree3(T_FINT, NOCON, $1);
667: |
668: variable
669: |
670: YID error
671: = goto NEerror;
672: |
673: func_id '(' wexpr_list ')'
674: = $$ = tree4(T_FCALL, NOCON, $1, fixlist($3));
675: |
676: '(' expr ')'
677: = $$ = $2;
678: |
679: negop expr %prec YNOT
680: = $$ = tree3(T_NOT, NOCON, $2);
681: |
682: '[' element_list ']'
683: = $$ = tree3(T_CSET, SAWCON, fixlist($2));
684: |
685: '[' ']'
686: = $$ = tree3(T_CSET, SAWCON, NIL);
687: ;
688:
689: element_list:
690: element
691: = $$ = newlist($1);
692: |
693: element_list ',' element
694: = $$ = addlist($1, $3);
695: ;
696: element:
697: expr
698: |
699: expr YDOTDOT expr
700: = $$ = tree3(T_RANG, $1, $3);
701: ;
702:
703: /*
704: * QUALIFIED VARIABLES
705: */
706:
707: variable:
708: YID
709: = {
710: @ return (identis(var, VAR));
711: $$ = setupvar($1, NIL);
712: }
713: |
714: qual_var
715: = $1[3] = fixlist($1[3]);
716: ;
717: qual_var:
718: array_id '[' expr_list ']'
719: = $$ = setupvar($1, tree2(T_ARY, fixlist($3)));
720: |
721: qual_var '[' expr_list ']'
722: = $1[3] = addlist($1[3], tree2(T_ARY, fixlist($3)));
723: |
724: record_id '.' field_id
725: = $$ = setupvar($1, tree3(T_FIELD, $3, NIL));
726: |
727: qual_var '.' field_id
728: = $1[3] = addlist($1[3], tree3(T_FIELD, $3, NIL));
729: |
730: ptr_id '^'
731: = $$ = setupvar($1, tree1(T_PTR));
732: |
733: qual_var '^'
734: = $1[3] = addlist($1[3], tree1(T_PTR));
735: ;
736:
737: /*
738: * Expression with write widths
739: */
740: wexpr:
741: expr
742: |
743: expr ':' expr
744: = $$ = tree4(T_WEXP, $1, $3, NIL);
745: |
746: expr ':' expr ':' expr
747: = $$ = tree4(T_WEXP, $1, $3, $5);
748: |
749: expr octhex
750: = $$ = tree4(T_WEXP, $1, NIL, $2);
751: |
752: expr ':' expr octhex
753: = $$ = tree4(T_WEXP, $1, $3, $4);
754: ;
755: octhex:
756: YOCT
757: = $$ = OCT;
758: |
759: YHEX
760: = $$ = HEX;
761: ;
762:
763: expr_list:
764: expr
765: = $$ = newlist($1);
766: |
767: expr_list ',' expr
768: = $$ = addlist($1, $3);
769: ;
770:
771: wexpr_list:
772: wexpr
773: = $$ = newlist($1);
774: |
775: wexpr_list ',' wexpr
776: = $$ = addlist($1, $3);
777: ;
778:
779: /*
780: * OPERATORS
781: */
782:
783: relop:
784: '=' = $$ = T_EQ;
785: |
786: '<' = $$ = T_LT;
787: |
788: '>' = $$ = T_GT;
789: |
790: '<' '>' = $$ = T_NE;
791: |
792: '<' '=' = $$ = T_LE;
793: |
794: '>' '=' = $$ = T_GE;
795: |
796: YIN = $$ = T_IN;
797: ;
798: addop:
799: '+' = $$ = T_ADD;
800: |
801: '-' = $$ = T_SUB;
802: |
803: YOR = $$ = T_OR;
804: |
805: '|' = $$ = T_OR;
806: ;
807: divop:
808: '*' = $$ = T_MULT;
809: |
810: '/' = $$ = T_DIVD;
811: |
812: YDIV = $$ = T_DIV;
813: |
814: YMOD = $$ = T_MOD;
815: |
816: YAND = $$ = T_AND;
817: |
818: '&' = $$ = T_AND;
819: ;
820:
821: negop:
822: YNOT
823: |
824: '~'
825: ;
826:
827: /*
828: * LISTS
829: */
830:
831: var_list:
832: variable
833: = $$ = newlist($1);
834: |
835: var_list ',' variable
836: = $$ = addlist($1, $3);
837: ;
838:
839: id_list:
840: YID
841: = $$ = newlist($1);
842: |
843: id_list ',' YID
844: = $$ = addlist($1, $3);
845: ;
846:
847: /*
848: * Identifier productions with semantic restrictions
849: *
850: * For these productions, the character @ signifies
851: * that the associated C statement is to provide
852: * the semantic restriction for this reduction.
853: * These lines are made into a procedure yyEactr, similar to
854: * yyactr, which determines whether the corresponding reduction
855: * is permitted, or whether an error is to be signaled.
856: * A zero return from yyEactr is considered an error.
857: * YyEactr is called with an argument "var" giving the string
858: * name of the variable in question, essentially $1, although
859: * $1 will not work because yyEactr is called from loccor in
860: * the recovery routines.
861: */
862:
863: const_id:
864: YID
865: = @ return (identis(var, CONST));
866: ;
867: type_id:
868: YID
869: = {
870: @ return (identis(var, TYPE));
871: $$ = tree3(T_TYID, lineof(yyline), $1);
872: }
873: ;
874: var_id:
875: YID
876: = @ return (identis(var, VAR));
877: ;
878: array_id:
879: YID
880: = @ return (identis(var, ARRAY));
881: ;
882: ptr_id:
883: YID
884: = @ return (identis(var, PTRFILE));
885: ;
886: record_id:
887: YID
888: = @ return (identis(var, RECORD));
889: ;
890: field_id:
891: YID
892: = @ return (identis(var, FIELD));
893: ;
894: proc_id:
895: YID
896: = @ return (identis(var, PROC));
897: ;
898: func_id:
899: YID
900: = @ return (identis(var, FUNC));
901: ;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.