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