![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tabl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed|
Return to tabl.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2:
3: /*
4: * $Header: tabl.c,v 2.4 85/08/22 16:08:42 timo Exp $
5: */
6:
7: /*
8: * B editor -- Grammar table.
9: */
10:
11: #include "b.h"
12: #include "node.h"
13: #include "gram.h"
14: #include "tabl.h"
15:
16:
17: /*
18: * ***** DISCLAIMER *****
19: *
20: * This file is a mess. There should really be a separate program (like Yacc)
21: * to compile a grammar into tables. But for the time being . . .
22: */
23:
24:
25: /*
26: * Values returned by function symbol(n).
27: * They are used directly as index in the grammar table.
28: * The NAMES of the #defined constants are of no importance outside this file.
29: */
30:
31: #define Put 1
32: #define Insert 2
33: #define Remove 3
34: #define Choose 4
35: #define Draw 5
36: #define Set_random 6
37: #define Delete 7
38: #define Check 8
39: #define Share 9
40:
41: #define Write 10
42: #define Read 11
43: #define Read_raw 12
44:
45: #define If 13
46: #define While 14
47: #define For 15
48:
49: #define Select 16
50:
51: #define Quit 18
52: #define Return 19
53: #define Report 20
54: #define Succeed 21
55: #define Fail 22
56:
57: #define How_to 23
58: #define Yield 24
59: #define Test 25
60: #define Suite 26
61: #define Refinement 27
62:
63: #define Compound 28
64: #define Collateral 29
65: #define Tag 30
66: #define Number 31
67: #define Selection 32
68: #define Behead 33
69: #define Curtail 34
70:
71: #define And 35
72: #define Or 36
73: #define Not 37
74: #define Some_in 38
75: #define Each_in 39
76: #define No_in 40
77: #define Some_parsing 41
78: #define Each_parsing 42
79: #define No_parsing 43
80:
81: #define Comment 44
82: #define Keyword 45
83:
84: #define L_t_dis 46
85: #define List_body 47
86: #define Tab_body 48
87: #define Tab_entry 49
88:
89: #define E_number 50
90: #define Com_target 51
91: #define Col_target 52
92: #define Sel_expr 53
93: #define Text1 54
94: #define Text2 55
95: #define Grouped 56
96: #define Blocked 57
97: #define Operators 58
98:
99: #define Else_kw 59
100: #define Kw_plus 60
101: #define E_plus 61
102: #define Conversion 62
103: #define T1 63
104: #define T1_plus 64
105: #define T2 65
106: #define T2_plus 66
107: #define Cmt_cmd 67
108:
109: #define F_kw_plus 69
110: #define F_e_plus 70
111: #define Plus_sign 71
112: #define Minus_sign 72
113:
114: #define Long_comp 73
115: #define Short_comp 74
116: #define Cmt_comp 75
117:
118: #define Long_unit 76
119: #define Short_unit 77
120: #define Cmt_head 78
121:
122: #define Ref_join 79
123:
124: #define And_kw 80
125: #define Or_kw 81
126:
127: #define E_part 82
128:
129: #define Unit_edit 83
130: #define Target_edit 84
131: #define Imm_cmd 85
132: #define Raw 86
133: #define Raw_input 87
134: #define Edit_unit 88
135: #define Edit_target 89
136: #define Colon 90
137: #define Equals 91
138: #define Test_suite 92
139: #define Expression 93
140:
141: /*
142: * The last three, `Suggestion', `Optional' and `Hole',
143: * with values 97, 98 and 99, are defined in "gram.h".
144: */
145:
146:
147: /*
148: * Symbol values used for lexical elements.
149: * Cross-reference: "lexi.c", table `chclass'.
150: */
151:
152: #define LEXICAL 100
153:
154: #define IDENT (LEXICAL+0)
155: #define KEYWORD (LEXICAL+1)
156: #define NUMBER (LEXICAL+2)
157: #define COMMENT (LEXICAL+3)
158: #define TEXT1 (LEXICAL+4)
159: #define TEXT2 (LEXICAL+5)
160: #define OPERATORS (LEXICAL+6)
161: #define RAWINPUT (LEXICAL+7)
162: #define SUGGESTION (LEXICAL+8)
163:
164:
165: /*
166: * Classes used in table initialization.
167: */
168:
169: Hidden classelem Asugg_body[] = {SUGGESTION, 0};
170: Hidden struct classinfo sugg_body[] = {Asugg_body};
171:
172: #define TARGET Tag, Com_target, Selection, Behead, Curtail
173: #define PRIMARY \
174: Sel_expr, Tag, E_number, Number, Compound, L_t_dis, Text1, Text2
175: #define EXPR Blocked, Grouped, Operators, PRIMARY
176:
177: Hidden classelem Atag_body[] = {IDENT, 0};
178: Hidden struct classinfo tag_body[] = {Atag_body};
179: Hidden classelem Anum_body[] = {NUMBER, 0};
180: Hidden struct classinfo num_body[] = {Anum_body};
181: Hidden classelem Acom_body[] = {COMMENT, 0};
182: Hidden struct classinfo com_body[] = {Acom_body};
183: Hidden classelem Akw_body[] = {KEYWORD, 0};
184: Hidden struct classinfo kw_body[] = {Akw_body};
185: Hidden classelem At1_body[] = {TEXT1, 0};
186: Hidden struct classinfo t1_body[] = {At1_body};
187: Hidden classelem At2_body[] = {TEXT2, 0};
188: Hidden struct classinfo t2_body[] = {At2_body};
189: Hidden classelem Aops_body[] = {OPERATORS, 0};
190: Hidden struct classinfo ops_body[] = {Aops_body};
191: Hidden classelem Araw_body[] = {RAWINPUT, 0};
192: Hidden struct classinfo raw_body[] = {Araw_body};
193: Hidden classelem Araw_input[] = {Optional, Raw, 0};
194: Hidden struct classinfo raw_input[] = {Araw_input};
195:
196: Hidden classelem Aid_or_kw[] = {Tag, Keyword, 0};
197: Hidden struct classinfo id_or_kw[] = {Aid_or_kw};
198: Hidden classelem Anumber[] = {Number, 0};
199: Hidden struct classinfo number[] = {Anumber};
200: Hidden classelem Asign[] = {Optional, Plus_sign, Minus_sign, 0};
201: Hidden struct classinfo sign[] = {Asign};
202:
203: Hidden classelem Ao_c_expr[] = {Optional, Collateral, EXPR, 0};
204: Hidden struct classinfo o_c_expr[] = {Ao_c_expr};
205:
206: #define Ac_expr (Ao_c_expr+1)
207: Hidden struct classinfo c_expr[] = {Ac_expr};
208: #define Aexpr (Ao_c_expr+2)
209: Hidden struct classinfo expr[] = {Aexpr};
210: #define Aprimary (Ao_c_expr+5)
211: Hidden struct classinfo primary[] = {Aprimary};
212:
213: Hidden classelem Ablock[] = {Operators, PRIMARY, 0};
214: Hidden struct classinfo block[] = {Ablock};
215: Hidden classelem Agroup[] = {Blocked, Operators, PRIMARY, 0};
216: Hidden struct classinfo group[] = {Agroup};
217:
218: #define Ar_expr Agroup
219: Hidden struct classinfo r_expr[] = {Ar_expr};
220:
221: Hidden classelem Al_t_body[] = {Optional, List_body, PRIMARY, Blocked,
222: Grouped, Operators, Tab_body, Tab_entry, 0};
223: Hidden struct classinfo l_t_body[] = {Al_t_body};
224: Hidden classelem Alist_body[] = {List_body, EXPR, 0};
225: Hidden struct classinfo list_body[] = {Alist_body};
226: Hidden classelem Atab_body[] = {Tab_body, Tab_entry, 0};
227: Hidden struct classinfo tab_body[] = {Atab_body};
228: Hidden classelem Atab_entry[] = {Tab_entry, 0};
229: Hidden struct classinfo tab_entry[] = {Atab_entry};
230:
231: Hidden classelem Ac_target[] = {Col_target, TARGET, 0};
232: Hidden struct classinfo c_target[] = {Ac_target};
233:
234: #define Atarget (Ac_target+1)
235: Hidden struct classinfo target[] = {Atarget};
236:
237: #define SOME_ETC \
238: Not, Some_in, Each_in, No_in, Some_parsing, Each_parsing, No_parsing
239:
240: Hidden classelem Ae_test[] = {Else_kw, SOME_ETC, And, Or, EXPR, 0};
241: Hidden struct classinfo e_test[] = {Ae_test};
242:
243: #define Atest (Ae_test+1)
244: Hidden struct classinfo test[] = {Atest};
245: #define At_test Aexpr
246: Hidden struct classinfo t_test[] = {At_test};
247: Hidden classelem Ar_test[] = {SOME_ETC, EXPR, 0};
248: Hidden struct classinfo r_test[] = {Ar_test};
249: Hidden classelem Aand_test[] = {SOME_ETC, And, EXPR, 0};
250: Hidden struct classinfo and_test[] = {Aand_test};
251: Hidden classelem Aor_test[] = {SOME_ETC, Or, EXPR, 0};
252: Hidden struct classinfo or_test[] = {Aor_test};
253: Hidden classelem Ac_test[] = {Collateral, SOME_ETC, And, Or, EXPR, 0};
254: Hidden struct classinfo c_test[] = {Ac_test};
255: /*
256: * This means that a compound expression may in fact
257: * contain a `collateral test', e.g. (a AND b, c AND d).
258: * Of course, this is illegal in B, but I couldn't
259: * solve the ambiguity of `(' where a test is expected
260: * otherwise (this may start a parenthesized test, or
261: * a compound expression; the latter may be followed
262: * by more expression fragments, the first may not).
263: */
264:
265: Hidden classelem Acomment[] = {Comment, 0};
266: Hidden struct classinfo comment[] = {Acomment};
267: Hidden classelem Ao_comment[] = {Optional, Comment, 0};
268: Hidden struct classinfo o_comment[] = {Ao_comment};
269:
270: #define HEAD How_to, Yield, Test
271: #define BODY HEAD, Cmt_head, Long_unit, Short_unit
272:
273: /* The order here determines which are suggested first and is subject
274: to constant change! */
275: #define SIMPLE_CMD SC1, SC2, SC3
276: #define SC1 Share, Quit, Return, Write, Read, Read_raw, Put, Delete
277: #define SC2 Report, Fail, Succeed, Insert, Remove, Check
278: #define SC3 Choose, Draw, Set_random, Suggestion, Keyword, Kw_plus
279:
280: #define CONTROL_CMD If, While, For
281: #define COMP_CMD Short_comp, Long_comp, Cmt_comp, Select
282: #define CMD If, For, COMP_CMD, SIMPLE_CMD, While
283: /* #define SHORTCMD SIMPLE_CMD, Cmt_cmd */
284: #define SHORTCMD If, For, SIMPLE_CMD, While, Short_comp, Cmt_comp, Cmt_cmd
285:
286: Hidden classelem Ac_head[] = {Cmt_head, HEAD, 0};
287: Hidden struct classinfo c_head[] = {Ac_head};
288: #define Ahead (Ac_head+1)
289: Hidden struct classinfo head[] = {Ahead};
290:
291: Hidden classelem Aunit[] = {Optional, EXPR, BODY, Ref_join, 0};
292: Hidden struct classinfo unit[] = {Aunit};
293: Hidden classelem Ao_refinements[] = {Optional, Refinement, 0};
294: Hidden struct classinfo o_refinements[] = {Ao_refinements};
295: #define Arefinements (Ao_refinements+1)
296: Hidden struct classinfo refinements[] = {Arefinements};
297: Hidden classelem Arefpred[] = {BODY, 0};
298: Hidden struct classinfo refpred[] = {Arefpred};
299:
300: Hidden classelem Af_cmd[] = {Keyword, F_kw_plus, 0};
301: Hidden struct classinfo f_cmd[] = {Af_cmd};
302: #define Af_formula Aexpr /*****/
303: Hidden struct classinfo f_formula[] = {Af_formula};
304:
305: Hidden classelem Ao_suite[] = {Optional, Suite, 0};
306: Hidden struct classinfo o_suite[] = {Ao_suite};
307: Hidden classelem At_suite[] = {Test_suite, 0};
308: Hidden struct classinfo t_suite[] = {At_suite};
309: Hidden classelem Ao_t_suite[] = {Optional, Test_suite, 0};
310: Hidden struct classinfo o_t_suite[] = {Ao_t_suite};
311:
312: Hidden classelem Acmd[] = {Comment, CMD, Cmt_cmd, 0};
313: Hidden struct classinfo cmd[] = {Acmd};
314: Hidden classelem Ashortcmd[] = {SHORTCMD, 0};
315: Hidden struct classinfo shortcmd[] = {Ashortcmd};
316: Hidden classelem Ao_cmdsuite[] = {Optional, SHORTCMD, Suite, 0};
317: Hidden struct classinfo o_cmdsuite[] = {Ao_cmdsuite};
318: Hidden classelem Asuite[] = {Suite, 0};
319: Hidden struct classinfo suite[] = {Asuite};
320: Hidden classelem Asimple_cmd[] = {SIMPLE_CMD, 0};
321: Hidden struct classinfo simple_cmd[] = {Asimple_cmd};
322:
323: Hidden classelem Ac_ifforwhile[] = {CONTROL_CMD, Cmt_comp, 0};
324: Hidden struct classinfo c_ifforwhile[] = {Ac_ifforwhile};
325: Hidden classelem Aifforwhile[] = {CONTROL_CMD, 0};
326: Hidden struct classinfo ifforwhile[] = {Aifforwhile};
327:
328: Hidden classelem Akeyword[] = {Keyword, 0};
329: Hidden struct classinfo keyword[] = {Akeyword};
330: Hidden classelem Akw_next[] = {Collateral, EXPR, Keyword, E_plus, Kw_plus, 0};
331: Hidden struct classinfo kw_next[] = {Akw_next};
332: Hidden classelem Ae_next[] = {Keyword, Kw_plus, 0};
333: Hidden struct classinfo e_next[] = {Ae_next};
334:
335: Hidden classelem Af_kw_next[] = {Tag, Keyword, F_kw_plus, F_e_plus, 0};
336: Hidden struct classinfo f_kw_next[] = {Af_kw_next};
337: Hidden classelem Af_e_next[] = {Keyword, F_kw_plus, 0};
338: Hidden struct classinfo f_e_next[] = {Af_e_next};
339: Hidden classelem Atag[] = {Tag, 0};
340: Hidden struct classinfo tag[] = {Atag};
341:
342: Hidden classelem Atext1[] = {Optional, T1, Conversion, T1_plus, 0};
343: Hidden struct classinfo text1[] = {Atext1};
344: Hidden classelem At1_conv[] = {T1, Conversion, 0};
345: Hidden struct classinfo t1_conv[] = {At1_conv};
346: Hidden classelem At1_next[] = {T1, Conversion, T1_plus, 0};
347: Hidden struct classinfo t1_next[] = {At1_next};
348:
349: Hidden classelem Atext2[] = {Optional, T2, Conversion, T2_plus, 0};
350: Hidden struct classinfo text2[] = {Atext2};
351: Hidden classelem At2_conv[] = {T2, Conversion, 0};
352: Hidden struct classinfo t2_conv[] = {At2_conv};
353: Hidden classelem At2_next[] = {T2, Conversion, T2_plus, 0};
354: Hidden struct classinfo t2_next[] = {At2_next};
355:
356: Hidden classelem Aand[] = {And_kw, 0};
357: Hidden struct classinfo and[] = {Aand};
358: Hidden classelem Aor[] = {Or_kw, 0};
359: Hidden struct classinfo or[] = {Aor};
360:
361: Hidden classelem Ae_part[] = {E_part, 0};
362: Hidden struct classinfo e_part[] = {Ae_part};
363:
364: Hidden classelem Aunit_edit[] = {Optional, BODY, Ref_join, 0};
365: Hidden struct classinfo unit_edit[] = {Aunit_edit};
366: Hidden classelem Atarget_edit[] = {Optional, EXPR, 0};
367: Hidden struct classinfo target_edit[] = {Atarget_edit};
368: Hidden classelem Aimm_cmd[] = {Optional, Comment, HEAD, CMD, Cmt_cmd, Cmt_head,
369: Edit_unit, Edit_target, 0};
370: Hidden struct classinfo imm_cmd[] = {Aimm_cmd};
371:
372: Hidden classelem Aed_unit[] = {Optional, Tag, Keyword, Colon, 0};
373: Hidden struct classinfo ed_unit[] = {Aed_unit};
374: Hidden classelem Aed_target[] = {Optional, Tag, Equals, 0};
375: Hidden struct classinfo ed_target[] = {Aed_target};
376:
377:
378: /*
379: * WARNING: The entries in this table must correspond one by one
380: * to the symbols defined earlier. This is checked dynamically
381: * by the initialization procedure (syserr "table order").
382: */
383:
384: #define XX(name) name, "name"
385:
386: Hidden struct table b_grammar[] = {
387: {XX(Rootsymbol), {0}, {unit}}, /* Start symbol of the grammar,
388: may be overridden by setroot("Blabla") call. */
389: {XX(Put), {"PUT ", " IN "}, {c_expr, c_target}},
390: {XX(Insert), {"INSERT ", " IN "}, {c_expr, target}},
391: {XX(Remove), {"REMOVE ", " FROM "}, {c_expr, target}},
392: {XX(Choose), {"CHOOSE ", " FROM "}, {c_expr, expr}},
393: {XX(Draw), {"DRAW "}, {target}},
394: {XX(Set_random), {"SET'RANDOM "}, {c_expr}},
395: {XX(Delete), {"DELETE "}, {c_target}},
396: {XX(Check), {"CHECK "}, {test}},
397: {XX(Share), {"SHARE "}, {c_target}},
398:
399: {XX(Write), {"WRITE "}, {c_expr}},
400: {XX(Read), {"READ ", " EG "}, {c_target, c_expr}},
401: {XX(Read_raw), {"READ ", " RAW"}, {target}},
402:
403: {XX(If), {"IF ", ": "}, {test}},
404: {XX(While), {"WHILE ", ": "}, {test}},
405: {XX(For), {"FOR ", " IN ", ": "}, {c_target, expr}},
406:
407: {XX(Select), {"SELECT: ", "\t", "\b"}, {o_comment, t_suite}},
408: {0}, /* Test_suite moved to 92 */
409:
410: {XX(Quit), {"QUIT"}, {0}},
411: {XX(Return), {"RETURN "}, {c_expr}},
412: {XX(Report), {"REPORT "}, {test}},
413: {XX(Succeed), {"SUCCEED"}, {0}},
414: {XX(Fail), {"FAIL"}, {0}},
415:
416: {XX(How_to), {"HOW'TO ", ": "}, {f_cmd}},
417: {XX(Yield), {"YIELD ", ": "}, {f_formula}},
418: {XX(Test), {"TEST ", ": "}, {f_formula}},
419:
420: {XX(Suite), {"\n"}, {cmd, o_suite}},
421: {XX(Refinement), {"\n", ": ", "\t", "\b"},
422: {id_or_kw, o_comment, o_cmdsuite, o_refinements}},
423:
424: {XX(Compound), {"(", ")"}, {c_test}},
425: {XX(Collateral), {0, ", "}, {expr, c_expr}},
426: {XX(Tag), {0}, {tag_body}},
427: {XX(Number), {0}, {num_body}},
428: {XX(Selection), {0, "[", "]"}, {target, c_expr}},
429: {XX(Behead), {0, "@"}, {target, r_expr}},
430: {XX(Curtail), {0, "|"}, {target, r_expr}},
431:
432: {XX(And), {0, " "}, {t_test, and}},
433: {XX(Or), {0, " "}, {t_test, or}},
434: {XX(Not), {"NOT "}, {r_test}},
435: {XX(Some_in), {"SOME ", " IN ", " HAS "}, {c_target, expr, r_test}},
436: {XX(Each_in), {"EACH ", " IN ", " HAS "}, {c_target, expr, r_test}},
437: {XX(No_in), {"NO ", " IN ", " HAS "}, {c_target, expr, r_test}},
438: {XX(Some_parsing), {"SOME ", " PARSING ", " HAS "},
439: {c_target, expr, r_test}},
440: {XX(Each_parsing), {"EACH ", " PARSING ", " HAS "},
441: {c_target, expr, r_test}},
442: {XX(No_parsing), {"NO ", " PARSING ", " HAS "}, {c_target, expr, r_test}},
443:
444: {XX(Comment), {0}, {com_body}},
445: {XX(Keyword), {0}, {kw_body}},
446:
447: {XX(L_t_dis), {"{", "}"}, {l_t_body}},
448: {XX(List_body), {0, "; "}, {expr, list_body}},
449: {XX(Tab_body), {0, "; "}, {tab_entry, tab_body}},
450: {XX(Tab_entry), {"[", "]: "}, {c_expr, expr}},
451: {XX(E_number), {0}, {number, e_part}},
452:
453: {XX(Com_target), {"(", ")"}, {c_target}},
454: {XX(Col_target), {0, ", "}, {target, c_target}},
455: {XX(Sel_expr), {0, "[", "]"}, {primary, c_expr}},
456:
457: {XX(Text1), {"'", "'"}, {text1}},
458: {XX(Text2), {"\"", "\""}, {text2}},
459: {XX(Grouped), {0, " "}, {group, expr}},
460: {XX(Blocked), {0}, {block, group}},
461: {XX(Operators), {0}, {ops_body}},
462: {XX(Else_kw), {"ELSE"}, {0}},
463: {XX(Kw_plus), {0, " "}, {keyword, kw_next}},
464: {XX(E_plus), {0, " "}, {c_expr, e_next}},
465: {XX(Conversion), {"`", "`"}, {o_c_expr}},
466: {XX(T1), {0}, {t1_body}},
467: {XX(T1_plus), {0}, {t1_conv, t1_next}},
468: {XX(T2), {0}, {t2_body}},
469: {XX(T2_plus), {0}, {t2_conv, t2_next}},
470: {XX(Cmt_cmd), {0, " "}, {simple_cmd, comment}},
471: {0},
472: {XX(F_kw_plus), {0, " "}, {keyword, f_kw_next}},
473: {XX(F_e_plus), {0, " "}, {tag, f_e_next}},
474: {XX(Plus_sign), {"+"}, {0}},
475: {XX(Minus_sign), {"-"}, {0}},
476:
477: {XX(Long_comp), {0, "\t", "\b"}, {c_ifforwhile, suite}},
478: {XX(Short_comp), {0, "\t", "\b"}, {ifforwhile, shortcmd}},
479: {XX(Cmt_comp), {0}, {ifforwhile, comment}},
480:
481: {XX(Long_unit), {0, "\t", "\b"}, {c_head, suite}},
482: {XX(Short_unit), {0, "\t", "\b"}, {head, shortcmd}},
483: {XX(Cmt_head), {0}, {head, comment}},
484:
485: {XX(Ref_join), {0}, {refpred, refinements}},
486:
487: {XX(And_kw), {"AND "}, {and_test}},
488: {XX(Or_kw), {"OR "}, {or_test}},
489:
490: {XX(E_part), {"E"}, {sign, number}},
491:
492: /* Alternate root symbols */
493:
494: {XX(Unit_edit), {0}, {unit_edit}},
495: {XX(Target_edit), {0}, {target_edit}},
496: {XX(Imm_cmd), {0}, {imm_cmd}},
497: {XX(Raw), {0}, {raw_body}},
498: {XX(Raw_input), {0}, {raw_input}},
499: {XX(Edit_unit), {":"}, {ed_unit}},
500: {XX(Edit_target), {"="}, {ed_target}},
501: {XX(Colon), {":"}, {0}},
502: {XX(Equals), {"="}, {0}},
503: {XX(Test_suite), {"\n", ": ", "\t", "\b"},
504: {e_test, o_comment, o_cmdsuite, o_t_suite}},
505: {XX(Expression), {0}, {c_expr}},
506:
507: /* Spare(s); change Optional and Hole in "gram.h" if you run out. */
508:
509: {0}, {0}, {0},
510:
511: /* Next three entries must be the last entries of the table. */
512: /* (See comments in "gram.c", initgram().) */
513:
514: {XX(Suggestion), {0}, {sugg_body}},
515: {XX(Optional), {0}, {0}},
516: {XX(Hole), {"?"}, {0}},
517: };
518:
519: Visible struct table *table= b_grammar;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.