![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to cmd2.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* cmd2.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains some of the commands - mostly ones that change text */
12:
13: #include "config.h"
14: #include "ctype.h"
15: #include "vi.h"
16: #include "regexp.h"
17: #if TOS
18: # include <stat.h>
19: #else
20: # if OSK
21: # include "osk.h"
22: # else
23: # if AMIGA
24: # include "amistat.h"
25: # else
26: # include <sys/stat.h>
27: # endif
28: # endif
29: #endif
30:
31:
32: /*ARGSUSED*/
33: void cmd_substitute(frommark, tomark, cmd, bang, extra)
34: MARK frommark;
35: MARK tomark;
36: CMD cmd;
37: int bang;
38: char *extra; /* rest of the command line */
39: {
40: char *line; /* a line from the file */
41: regexp *re; /* the compiled search expression */
42: char *subst; /* the substitution string */
43: char *opt; /* substitution options */
44: long l; /* a line number */
45: char *s, *d; /* used during subtitutions */
46: char *conf; /* used during confirmation */
47: long chline; /* # of lines changed */
48: long chsub; /* # of substitutions made */
49: static optp; /* boolean option: print when done? */
50: static optg; /* boolean option: substitute globally in line? */
51: static optc; /* boolean option: confirm before subst? */
52: #ifndef CRUNCH
53: long oldnlines;
54: #endif
55:
56:
57: /* for now, assume this will fail */
58: rptlines = -1L;
59:
60: if (cmd == CMD_SUBAGAIN)
61: {
62: #ifndef NO_MAGIC
63: if (*o_magic)
64: subst = "~";
65: else
66: #endif
67: subst = "\\~";
68: re = regcomp("");
69:
70: /* if visual "&", then turn off the "p" and "c" options */
71: if (bang)
72: {
73: optp = optc = FALSE;
74: }
75: }
76: else /* CMD_SUBSTITUTE */
77: {
78: /* make sure we got a search pattern */
79: if (*extra != '/' && *extra != '?')
80: {
81: msg("Usage: s/regular expression/new text/");
82: return;
83: }
84:
85: /* parse & compile the search pattern */
86: subst = parseptrn(extra);
87: re = regcomp(extra + 1);
88: }
89:
90: /* abort if RE error -- error message already given by regcomp() */
91: if (!re)
92: {
93: return;
94: }
95:
96: if (cmd == CMD_SUBSTITUTE)
97: {
98: /* parse the substitution string & find the option string */
99: for (opt = subst; *opt && *opt != *extra; opt++)
100: {
101: if (*opt == '\\' && opt[1])
102: {
103: opt++;
104: }
105: }
106: if (*opt)
107: {
108: *opt++ = '\0';
109: }
110:
111: /* analyse the option string */
112: if (!*o_edcompatible)
113: {
114: optp = optg = optc = FALSE;
115: }
116: while (*opt)
117: {
118: switch (*opt++)
119: {
120: case 'p': optp = !optp; break;
121: case 'g': optg = !optg; break;
122: case 'c': optc = !optc; break;
123: case ' ':
124: case '\t': break;
125: default:
126: msg("Subst options are p, c, and g -- not %c", opt[-1]);
127: return;
128: }
129: }
130: }
131:
132: /* if "c" or "p" flag was given, and we're in visual mode, then NEWLINE */
133: if ((optc || optp) && mode == MODE_VI)
134: {
135: addch('\n');
136: exrefresh();
137: }
138:
139: ChangeText
140: {
141: /* reset the change counters */
142: chline = chsub = 0L;
143:
144: /* for each selected line */
145: for (l = markline(frommark); l <= markline(tomark); l++)
146: {
147: /* fetch the line */
148: line = fetchline(l);
149:
150: /* if it contains the search pattern... */
151: if (regexec(re, line, TRUE))
152: {
153: /* increment the line change counter */
154: chline++;
155:
156: /* initialize the pointers */
157: s = line;
158: d = tmpblk.c;
159:
160: /* do once or globally ... */
161: do
162: {
163: #ifndef CRUNCH
164: /* confirm, if necessary */
165: if (optc)
166: {
167: for (conf = line; conf < re->startp[0]; conf++)
168: addch(*conf);
169: standout();
170: for ( ; conf < re->endp[0]; conf++)
171: addch(*conf);
172: standend();
173: for (; *conf; conf++)
174: addch(*conf);
175: addch('\n');
176: exrefresh();
177: if (getkey(0) != 'y')
178: {
179: /* copy accross the original chars */
180: while (s < re->endp[0])
181: *d++ = *s++;
182:
183: /* skip to next match on this line, if any */
184: goto Continue;
185: }
186: }
187: #endif /* not CRUNCH */
188:
189: /* increment the substitution change counter */
190: chsub++;
191:
192: /* copy stuff from before the match */
193: while (s < re->startp[0])
194: {
195: *d++ = *s++;
196: }
197:
198: /* substitute for the matched part */
199: regsub(re, subst, d);
200: s = re->endp[0];
201: d += strlen(d);
202:
203: Continue:
204: /* if this regexp could conceivably match
205: * a zero-length string, then require at
206: * least 1 unmatched character between
207: * matches.
208: */
209: if (re->minlen == 0)
210: {
211: if (!*s)
212: break;
213: *d++ = *s++;
214: }
215:
216: } while (optg && regexec(re, s, FALSE));
217:
218: /* copy stuff from after the match */
219: while (*d++ = *s++) /* yes, ASSIGNMENT! */
220: {
221: }
222:
223: #ifndef CRUNCH
224: /* NOTE: since the substitution text is allowed to have ^Ms which are
225: * translated into newlines, it is possible that the number of lines
226: * in the file will increase after each line has been substituted.
227: * we need to adjust for this.
228: */
229: oldnlines = nlines;
230: #endif
231:
232: /* replace the old version of the line with the new */
233: d[-1] = '\n';
234: d[0] = '\0';
235: change(MARK_AT_LINE(l), MARK_AT_LINE(l + 1), tmpblk.c);
236:
237: #ifndef CRUNCH
238: l += nlines - oldnlines;
239: tomark += MARK_AT_LINE(nlines - oldnlines);
240: #endif
241:
242: /* if supposed to print it, do so */
243: if (optp)
244: {
245: addstr(tmpblk.c);
246: exrefresh();
247: }
248:
249: /* move the cursor to that line */
250: cursor = MARK_AT_LINE(l);
251: }
252: }
253: }
254:
255: /* free the regexp */
256: _free_(re);
257:
258: /* if done from within a ":g" command, then finish silently */
259: if (doingglobal)
260: {
261: rptlines = chline;
262: rptlabel = "changed";
263: return;
264: }
265:
266: /* Reporting */
267: if (chsub == 0)
268: {
269: msg("Substitution failed");
270: }
271: else if (chline >= *o_report)
272: {
273: msg("%ld substitutions on %ld lines", chsub, chline);
274: }
275: rptlines = 0L;
276: }
277:
278:
279:
280:
281: /*ARGSUSED*/
282: void cmd_delete(frommark, tomark, cmd, bang, extra)
283: MARK frommark;
284: MARK tomark;
285: CMD cmd;
286: int bang;
287: char *extra;
288: {
289: MARK curs2; /* an altered form of the cursor */
290:
291: /* choose your cut buffer */
292: if (*extra == '"')
293: {
294: extra++;
295: }
296: if (*extra)
297: {
298: cutname(*extra);
299: }
300:
301: /* make sure we're talking about whole lines here */
302: frommark = frommark & ~(BLKSIZE - 1);
303: tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE;
304:
305: /* yank the lines */
306: cut(frommark, tomark);
307:
308: /* if CMD_DELETE then delete the lines */
309: if (cmd != CMD_YANK)
310: {
311: curs2 = cursor;
312: ChangeText
313: {
314: /* delete the lines */
315: delete(frommark, tomark);
316: }
317: if (curs2 > tomark)
318: {
319: cursor = curs2 - tomark + frommark;
320: }
321: else if (curs2 > frommark)
322: {
323: cursor = frommark;
324: }
325: }
326: }
327:
328:
329: /*ARGSUSED*/
330: void cmd_append(frommark, tomark, cmd, bang, extra)
331: MARK frommark;
332: MARK tomark;
333: CMD cmd;
334: int bang;
335: char *extra;
336: {
337: long l; /* line counter */
338:
339: #ifndef CRUNCH
340: /* if '!' then toggle auto-indent */
341: if (bang)
342: {
343: *o_autoindent = !*o_autoindent;
344: }
345: #endif
346:
347: ChangeText
348: {
349: /* if we're doing a change, delete the old version */
350: if (cmd == CMD_CHANGE)
351: {
352: /* delete 'em */
353: cmd_delete(frommark, tomark, cmd, bang, extra);
354: }
355:
356: /* new lines start at the frommark line, or after it */
357: l = markline(frommark);
358: if (cmd == CMD_APPEND)
359: {
360: l++;
361: }
362:
363: /* get lines until no more lines, or "." line, and insert them */
364: while (vgets('\0', tmpblk.c, BLKSIZE) >= 0)
365: {
366: addch('\n');
367: if (!strcmp(tmpblk.c, "."))
368: {
369: break;
370: }
371:
372: strcat(tmpblk.c, "\n");
373: add(MARK_AT_LINE(l), tmpblk.c);
374: l++;
375: }
376: }
377:
378: /* on the odd chance that we're calling this from vi mode ... */
379: redraw(MARK_UNSET, FALSE);
380: }
381:
382:
383: /*ARGSUSED*/
384: void cmd_put(frommark, tomark, cmd, bang, extra)
385: MARK frommark;
386: MARK tomark;
387: CMD cmd;
388: int bang;
389: char *extra;
390: {
391: /* choose your cut buffer */
392: if (*extra == '"')
393: {
394: extra++;
395: }
396: if (*extra)
397: {
398: cutname(*extra);
399: }
400:
401: /* paste it */
402: ChangeText
403: {
404: cursor = paste(frommark, TRUE, FALSE);
405: }
406: }
407:
408:
409: /*ARGSUSED*/
410: void cmd_join(frommark, tomark, cmd, bang, extra)
411: MARK frommark;
412: MARK tomark;
413: CMD cmd;
414: int bang;
415: char *extra;
416: {
417: long l;
418: char *scan;
419: int len; /* length of the new line */
420:
421: /* if only one line is specified, assume the following one joins too */
422: if (markline(frommark) == nlines)
423: {
424: msg("Nothing to join with this line");
425: return;
426: }
427: if (markline(frommark) == markline(tomark))
428: {
429: tomark += BLKSIZE;
430: }
431:
432: /* get the first line */
433: l = markline(frommark);
434: strcpy(tmpblk.c, fetchline(l));
435: len = strlen(tmpblk.c);
436:
437: /* build the longer line */
438: while (++l <= markline(tomark))
439: {
440: /* get the next line */
441: scan = fetchline(l);
442:
443: /* remove any leading whitespace */
444: while (*scan == '\t' || *scan == ' ')
445: {
446: scan++;
447: }
448:
449: /* see if the line will fit */
450: if (strlen(scan) + len + 3 > BLKSIZE)
451: {
452: msg("Can't join -- the resulting line would be too long");
453: return;
454: }
455:
456: /* catenate it, with a space (or two) in between */
457: if (!bang)
458: {
459: if (len >= 1)
460: {
461: if (tmpblk.c[len - 1] == '.'
462: || tmpblk.c[len - 1] == '?'
463: || tmpblk.c[len - 1] == '!')
464: {
465: tmpblk.c[len++] = ' ';
466: tmpblk.c[len++] = ' ';
467: }
468: else if (tmpblk.c[len - 1] != ' ')
469: {
470: tmpblk.c[len++] = ' ';
471: }
472: }
473: }
474: strcpy(tmpblk.c + len, scan);
475: len += strlen(scan);
476: }
477: tmpblk.c[len++] = '\n';
478: tmpblk.c[len] = '\0';
479:
480: /* make the change */
481: ChangeText
482: {
483: frommark &= ~(BLKSIZE - 1);
484: tomark &= ~(BLKSIZE - 1);
485: tomark += BLKSIZE;
486: change(frommark, tomark, tmpblk.c);
487: }
488:
489: /* Reporting... */
490: rptlines = markline(tomark) - markline(frommark) - 1L;
491: rptlabel = "joined";
492: }
493:
494:
495:
496: /*ARGSUSED*/
497: void cmd_shift(frommark, tomark, cmd, bang, extra)
498: MARK frommark;
499: MARK tomark;
500: CMD cmd;
501: int bang;
502: char *extra;
503: {
504: long l; /* line number counter */
505: int oldidx; /* number of chars previously used for indent */
506: int newidx; /* number of chars in the new indent string */
507: int oldcol; /* previous indent amount */
508: int newcol; /* new indent amount */
509: char *text; /* pointer to the old line's text */
510:
511: ChangeText
512: {
513: /* for each line to shift... */
514: for (l = markline(frommark); l <= markline(tomark); l++)
515: {
516: /* get the line - ignore empty lines unless ! mode */
517: text = fetchline(l);
518: if (!*text && !bang)
519: continue;
520:
521: /* calc oldidx and oldcol */
522: for (oldidx = 0, oldcol = 0;
523: text[oldidx] == ' ' || text[oldidx] == '\t';
524: oldidx++)
525: {
526: if (text[oldidx] == ' ')
527: {
528: oldcol += 1;
529: }
530: else
531: {
532: oldcol += *o_tabstop - (oldcol % *o_tabstop);
533: }
534: }
535:
536: /* calc newcol */
537: if (cmd == CMD_SHIFTR)
538: {
539: newcol = oldcol + (*o_shiftwidth & 0xff);
540: }
541: else
542: {
543: newcol = oldcol - (*o_shiftwidth & 0xff);
544: if (newcol < 0)
545: newcol = 0;
546: }
547:
548: /* if no change, then skip to next line */
549: if (oldcol == newcol)
550: continue;
551:
552: /* build a new indent string */
553: newidx = 0;
554: if (*o_autotab)
555: {
556: while (newcol >= *o_tabstop)
557: {
558: tmpblk.c[newidx++] = '\t';
559: newcol -= *o_tabstop;
560: }
561: }
562: while (newcol > 0)
563: {
564: tmpblk.c[newidx++] = ' ';
565: newcol--;
566: }
567: tmpblk.c[newidx] = '\0';
568:
569: /* change the old indent string into the new */
570: change(MARK_AT_LINE(l), MARK_AT_LINE(l) + oldidx, tmpblk.c);
571: }
572: }
573:
574: /* Reporting... */
575: rptlines = markline(tomark) - markline(frommark) + 1L;
576: if (cmd == CMD_SHIFTR)
577: {
578: rptlabel = ">ed";
579: }
580: else
581: {
582: rptlabel = "<ed";
583: }
584: }
585:
586:
587: /*ARGSUSED*/
588: void cmd_read(frommark, tomark, cmd, bang, extra)
589: MARK frommark;
590: MARK tomark;
591: CMD cmd;
592: int bang;
593: char *extra;
594: {
595: int fd, rc; /* used while reading from the file */
596: char *scan; /* used for finding NUL characters */
597: int hadnul; /* boolean: any NULs found? */
598: int addnl; /* boolean: forced to add newlines? */
599: int len; /* number of chars in current line */
600: long lines; /* number of lines in current block */
601: struct stat statb;
602:
603: /* special case: if ":r !cmd" then let the filter() function do it */
604: if (extra[0] == '!')
605: {
606: filter(frommark, MARK_UNSET, extra + 1, TRUE);
607: return;
608: }
609:
610: /* open the file */
611: fd = open(extra, O_RDONLY);
612: if (fd < 0)
613: {
614: msg("Can't open \"%s\"", extra);
615: return;
616: }
617:
618: #ifndef CRUNCH
619: if (stat(extra, &statb) < 0)
620: {
621: msg("Can't stat \"%s\"", extra);
622: }
623: # if TOS
624: if (statb.st_mode & S_IJDIR)
625: # else
626: # if OSK
627: if (statb.st_mode & S_IFDIR)
628: # else
629: if ((statb.st_mode & S_IFMT) != S_IFREG)
630: # endif
631: # endif
632: {
633: msg("\"%s\" is not a regular file", extra);
634: return;
635: }
636: #endif /* not CRUNCH */
637:
638: /* get blocks from the file, and add them */
639: ChangeText
640: {
641: /* insertion starts at the line following frommark */
642: tomark = frommark = (frommark | (BLKSIZE - 1L)) + 1L;
643: len = 0;
644: hadnul = addnl = FALSE;
645:
646: /* add an extra newline, so partial lines at the end of
647: * the file don't trip us up
648: */
649: add(tomark, "\n");
650:
651: /* for each chunk of text... */
652: while ((rc = tread(fd, tmpblk.c, BLKSIZE - 1)) > 0)
653: {
654: /* count newlines, convert NULs, etc. ... */
655: for (lines = 0, scan = tmpblk.c; rc > 0; rc--, scan++)
656: {
657: /* break up long lines */
658: if (*scan != '\n' && len + 2 > BLKSIZE)
659: {
660: *scan = '\n';
661: addnl = TRUE;
662: }
663:
664: /* protect against NUL chars in file */
665: if (!*scan)
666: {
667: *scan = 0x80;
668: hadnul = TRUE;
669: }
670:
671: /* starting a new line? */
672: if (*scan == '\n')
673: {
674: /* reset length at newline */
675: len = 0;
676: lines++;
677: }
678: else
679: {
680: len++;
681: }
682: }
683:
684: /* add the text */
685: *scan = '\0';
686: add(tomark, tmpblk.c);
687: tomark += MARK_AT_LINE(lines) + len - markidx(tomark);
688: }
689:
690: /* if partial last line, then retain that first newline */
691: if (len > 0)
692: {
693: msg("Last line had no newline");
694: tomark += BLKSIZE; /* <- for the rptlines calc */
695: }
696: else /* delete that first newline */
697: {
698: delete(tomark, (tomark | (BLKSIZE - 1L)) + 1L);
699: }
700: }
701:
702: /* close the file */
703: close(fd);
704:
705: /* Reporting... */
706: rptlines = markline(tomark) - markline(frommark);
707: rptlabel = "read";
708: if (mode == MODE_EX)
709: {
710: cursor = (tomark & ~BLKSIZE) - BLKSIZE;
711: }
712: else
713: {
714: cursor = frommark;
715: }
716:
717: if (addnl)
718: msg("Newlines were added to break up long lines");
719: if (hadnul)
720: msg("NULs were converted to 0x80");
721: }
722:
723:
724:
725: /*ARGSUSED*/
726: void cmd_undo(frommark, tomark, cmd, bang, extra)
727: MARK frommark;
728: MARK tomark;
729: CMD cmd;
730: int bang;
731: char *extra;
732: {
733: undo();
734: }
735:
736:
737: /* print the selected lines */
738: /*ARGSUSED*/
739: void cmd_print(frommark, tomark, cmd, bang, extra)
740: MARK frommark;
741: MARK tomark;
742: CMD cmd;
743: int bang;
744: char *extra;
745: {
746: REG char *scan;
747: REG long l;
748: REG int col;
749:
750: for (l = markline(frommark); l <= markline(tomark); l++)
751: {
752: /* display a line number, if CMD_NUMBER */
753: if (cmd == CMD_NUMBER)
754: {
755: sprintf(tmpblk.c, "%6ld ", l);
756: qaddstr(tmpblk.c);
757: col = 8;
758: }
759: else
760: {
761: col = 0;
762: }
763:
764: /* get the next line & display it */
765: for (scan = fetchline(l); *scan; scan++)
766: {
767: /* expand tabs to the proper width */
768: if (*scan == '\t' && cmd != CMD_LIST)
769: {
770: do
771: {
772: qaddch(' ');
773: col++;
774: } while (col % *o_tabstop != 0);
775: }
776: else if (*scan > 0 && *scan < ' ' || *scan == '\177')
777: {
778: qaddch('^');
779: qaddch(*scan ^ 0x40);
780: col += 2;
781: }
782: else if ((*scan & 0x80) && cmd == CMD_LIST)
783: {
784: sprintf(tmpblk.c, "\\%03o", UCHAR(*scan));
785: qaddstr(tmpblk.c);
786: col += 4;
787: }
788: else
789: {
790: qaddch(*scan);
791: col++;
792: }
793:
794: /* wrap at the edge of the screen */
795: if (!has_AM && col >= COLS)
796: {
797: addch('\n');
798: col -= COLS;
799: }
800: }
801: if (cmd == CMD_LIST)
802: {
803: qaddch('$');
804: }
805: addch('\n');
806: exrefresh();
807: }
808: }
809:
810:
811: /* move or copy selected lines */
812: /*ARGSUSED*/
813: void cmd_move(frommark, tomark, cmd, bang, extra)
814: MARK frommark;
815: MARK tomark;
816: CMD cmd;
817: int bang;
818: char *extra;
819: {
820: MARK destmark;
821:
822: /* parse the destination linespec. No defaults. Line 0 is okay */
823: destmark = cursor;
824: if (!strcmp(extra, "0"))
825: {
826: destmark = 0L;
827: }
828: else if (linespec(extra, &destmark) == extra || !destmark)
829: {
830: msg("invalid destination address");
831: return;
832: }
833:
834: /* flesh the marks out to encompass whole lines */
835: frommark &= ~(BLKSIZE - 1);
836: tomark = (tomark & ~(BLKSIZE - 1)) + BLKSIZE;
837: destmark = (destmark & ~(BLKSIZE - 1)) + BLKSIZE;
838:
839: /* make sure the destination is valid */
840: if (cmd == CMD_MOVE && destmark >= frommark && destmark < tomark)
841: {
842: msg("invalid destination address");
843: }
844:
845: /* Do it */
846: ChangeText
847: {
848: /* save the text to a cut buffer */
849: cutname('\0');
850: cut(frommark, tomark);
851:
852: /* if we're not copying, delete the old text & adjust destmark */
853: if (cmd != CMD_COPY)
854: {
855: delete(frommark, tomark);
856: if (destmark >= frommark)
857: {
858: destmark -= (tomark - frommark);
859: }
860: }
861:
862: /* add the new text */
863: paste(destmark, FALSE, FALSE);
864: }
865:
866: /* move the cursor to the last line of the moved text */
867: cursor = destmark + (tomark - frommark) - BLKSIZE;
868: if (cursor < MARK_FIRST || cursor >= MARK_LAST + BLKSIZE)
869: {
870: cursor = MARK_LAST;
871: }
872:
873: /* Reporting... */
874: rptlabel = ( (cmd == CMD_COPY) ? "copied" : "moved" );
875: }
876:
877:
878:
879: /* execute EX commands from a file */
880: /*ARGSUSED*/
881: void cmd_source(frommark, tomark, cmd, bang, extra)
882: MARK frommark;
883: MARK tomark;
884: CMD cmd;
885: int bang;
886: char *extra;
887: {
888: /* must have a filename */
889: if (!*extra)
890: {
891: msg("\"source\" requires a filename");
892: return;
893: }
894:
895: doexrc(extra);
896: }
897:
898:
899: #ifndef NO_AT
900: /*ARGSUSED*/
901: void cmd_at(frommark, tomark, cmd, bang, extra)
902: MARK frommark;
903: MARK tomark;
904: CMD cmd;
905: int bang;
906: char *extra;
907: {
908: static nest = FALSE;
909: int result;
910: char buf[MAXRCLEN];
911:
912: /* don't allow nested macros */
913: if (nest)
914: {
915: msg("@ macros can't be nested");
916: return;
917: }
918: nest = TRUE;
919:
920: /* require a buffer name */
921: if (*extra == '"')
922: extra++;
923: if (!*extra || !isascii(*extra) ||!islower(*extra))
924: {
925: msg("@ requires a cut buffer name (a-z)");
926: }
927:
928: /* get the contents of the buffer */
929: result = cb2str(*extra, buf, (unsigned)(sizeof buf));
930: if (result <= 0)
931: {
932: msg("buffer \"%c is empty", *extra);
933: }
934: else if (result >= sizeof buf)
935: {
936: msg("buffer \"%c is too large to execute", *extra);
937: }
938: else
939: {
940: /* execute the contents of the buffer as ex commands */
941: exstring(buf, result, '\\');
942: }
943:
944: nest = FALSE;
945: }
946: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.