![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to strfile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / games / fortune|
Return to strfile.c CVS log | Up to [CSRG BSD Unix] / 43BSD / games / fortune |
1.1 root 1: # include <stdio.h>
2: # include <ctype.h>
3: # include "strfile.h"
4:
5: /*
6: * This program takes a file composed of strings seperated by
7: * lines starting with two consecutive delimiting character (default
8: * character is '%') and creates another file which consists of a table
9: * describing the file (structure from "strfile.h"), a table of seek
10: * pointers to the start of the strings, and the strings, each terinated
11: * by a null byte. Usage:
12: *
13: * % strfile [ - ] [ -cC ] [ -sv ] [ -oir ] sourcefile [ datafile ]
14: *
15: * - - Give a usage summary useful for jogging the memory
16: * c - Change delimiting character from '%' to 'C'
17: * s - Silent. Give no summary of data processed at the end of
18: * the run.
19: * v - Verbose. Give summary of data processed. (Default)
20: * o - order the strings in alphabetic order
21: * i - if ordering, ignore case
22: * r - randomize the order of the strings
23: *
24: * Ken Arnold Sept. 7, 1978 --
25: *
26: * Added method to indicate dividers. A "%-" will cause the address
27: * to be added to the structure in one of the pointer elements.
28: *
29: * Ken Arnold Nov., 1984 --
30: *
31: * Added ordering options.
32: */
33:
34: # define TRUE 1
35: # define FALSE 0
36:
37: # define DELIM_CH '-'
38:
39: typedef struct {
40: char first;
41: long pos;
42: } STR;
43:
44: char *Infile = NULL, /* input file name */
45: Outfile[100] = "", /* output file name */
46: Delimch = '%', /* delimiting character */
47: *Usage[] = { /* usage summary */
48: "usage: strfile [ - ] [ -cC ] [ -sv ] [ -oir ] inputfile [ datafile ]",
49: " - - Give this usage summary",
50: " c - Replace delimiting character with 'C'",
51: " s - Silent. Give no summary",
52: " v - Verbose. Give summary. (default)",
53: " o - order strings alphabetically",
54: " i - ignore case in ordering",
55: " r - randomize the order of the strings",
56: " Default \"datafile\" is inputfile.dat",
57: NULL
58: };
59:
60: int Sflag = FALSE; /* silent run flag */
61: int Oflag = FALSE; /* ordering flag */
62: int Iflag = FALSE; /* ignore case flag */
63: int Rflag = FALSE; /* randomize order flag */
64: int Delim = 0; /* current delimiter number */
65:
66: long *Seekpts;
67:
68: FILE *Sort_1, *Sort_2; /* pointers for sorting */
69:
70: STRFILE Tbl; /* statistics table */
71:
72: STR *Firstch; /* first chars of each string */
73:
74: char *fgets(), *malloc(), *strcpy(), *strcat();
75:
76: long ftell();
77:
78: main(ac, av)
79: int ac;
80: char **av;
81: {
82: register char *sp, dc;
83: register long *lp;
84: register unsigned int curseek; /* number of strings */
85: register long *seekpts, li; /* table of seek pointers */
86: register FILE *inf, *outf;
87: register int first;
88: register char *nsp;
89: register STR *fp;
90: static char string[257];
91:
92: getargs(ac, av); /* evalute arguments */
93:
94: /*
95: * initial counting of input file
96: */
97:
98: dc = Delimch;
99: if ((inf = fopen(Infile, "r")) == NULL) {
100: perror(Infile);
101: exit(-1);
102: }
103: for (curseek = 0; (sp = fgets(string, 256, inf)) != NULL; )
104: if (*sp++ == dc && (*sp == dc || *sp == DELIM_CH))
105: curseek++;
106: curseek++;
107:
108: /*
109: * save space at begginning of file for tables
110: */
111:
112: if ((outf = fopen(Outfile, "w")) == NULL) {
113: perror(Outfile);
114: exit(-1);
115: }
116:
117: /*
118: * Allocate space for the pointers, adding one to the end so the
119: * length of the final string can be calculated.
120: */
121: ++curseek;
122: seekpts = (long *) malloc(sizeof *seekpts * curseek); /* NOSTRICT */
123: if (seekpts == NULL) {
124: perror("calloc");
125: exit(-1);
126: }
127: if (Oflag) {
128: Firstch = (STR *) malloc(sizeof *Firstch * curseek);
129: if (Firstch == NULL) {
130: perror("calloc");
131: exit(-1);
132: }
133: }
134:
135: (void) fseek(outf, (long) (sizeof Tbl + sizeof *seekpts * curseek), 0);
136: (void) fseek(inf, (long) 0, 0); /* goto start of input */
137:
138: /*
139: * write the strings onto the file
140: */
141:
142: Tbl.str_longlen = 0;
143: Tbl.str_shortlen = (unsigned int) 0xffffffff;
144: lp = seekpts;
145: first = Oflag;
146: *seekpts = ftell(outf);
147: fp = Firstch;
148: do {
149: sp = fgets(string, 256, inf);
150: if (sp == NULL ||
151: (*sp == dc && (sp[1] == dc || sp[1] == DELIM_CH))) {
152: putc('\0', outf);
153: *++lp = ftell(outf);
154: li = ftell(outf) - lp[-1] - 1;
155: if (Tbl.str_longlen < li)
156: Tbl.str_longlen = li;
157: if (Tbl.str_shortlen > li)
158: Tbl.str_shortlen = li;
159: if (sp && sp[1] == DELIM_CH && Delim < MAXDELIMS)
160: Tbl.str_delims[Delim++] = lp - seekpts;
161: first = Oflag;
162: }
163: else {
164: if (first) {
165: for (nsp = sp; !isalnum(*nsp); nsp++)
166: continue;
167: if (Iflag && isupper(*nsp))
168: fp->first = tolower(*nsp);
169: else
170: fp->first = *nsp;
171: fp->pos = *lp;
172: fp++;
173: first = FALSE;
174: }
175: fputs(sp, outf);
176: }
177: } while (sp != NULL);
178:
179: /*
180: * write the tables in
181: */
182:
183: (void) fclose(inf);
184: Tbl.str_numstr = curseek - 1;
185:
186: if (Oflag)
187: do_order(seekpts, outf);
188: else if (Rflag)
189: randomize(seekpts);
190:
191: (void) fseek(outf, (long) 0, 0);
192: (void) fwrite((char *) &Tbl, sizeof Tbl, 1, outf);
193: (void) fwrite((char *) seekpts, sizeof *seekpts, curseek, outf);
194: (void) fclose(outf);
195:
196: if (!Sflag) {
197: printf("\"%s\" converted to \"%s\"\n", Infile, Outfile);
198: if (curseek == 0)
199: puts("There was 1 string");
200: else
201: printf("There were %u strings\n", curseek - 1);
202: printf("Longest string: %u byte%s\n", Tbl.str_longlen,
203: Tbl.str_longlen == 1 ? "" : "s");
204: printf("Shortest string: %u byte%s\n", Tbl.str_shortlen,
205: Tbl.str_shortlen == 1 ? "" : "s");
206: }
207: exit(0);
208: }
209:
210: /*
211: * This routine evaluates arguments from the command line
212: */
213: getargs(ac, av)
214: register int ac;
215: register char **av;
216: {
217: register char *sp;
218: register int i;
219: register int bad, j;
220:
221: bad = 0;
222: for (i = 1; i < ac; i++)
223: if (*av[i] == '-' && av[i][1]) {
224: for (sp = &av[i][1]; *sp; sp++)
225: switch (*sp) {
226: case 'c': /* new delimiting char */
227: if ((Delimch = *++sp) == '\0') {
228: --sp;
229: Delimch = *av[++i];
230: }
231: if (Delimch <= 0 || Delimch > '~' ||
232: Delimch == DELIM_CH) {
233: printf("bad delimiting character: '\\%o\n'",
234: Delimch);
235: bad++;
236: }
237: break;
238: case 's': /* silent */
239: Sflag++;
240: break;
241: case 'v': /* verbose */
242: Sflag = 0;
243: break;
244: case 'o': /* order strings */
245: Oflag++;
246: break;
247: case 'i': /* ignore case in ordering */
248: Iflag++;
249: break;
250: case 'r': /* ignore case in ordering */
251: Rflag++;
252: break;
253: default: /* unknown flag */
254: bad++;
255: printf("bad flag: '%c'\n", *sp);
256: break;
257: }
258: }
259: else if (*av[i] == '-') {
260: for (j = 0; Usage[j]; j++)
261: puts(Usage[j]);
262: exit(0);
263: }
264: else if (Infile)
265: (void) strcpy(Outfile, av[i]);
266: else
267: Infile = av[i];
268: if (!Infile) {
269: bad++;
270: puts("No input file name");
271: }
272: if (*Outfile == '\0' && !bad) {
273: (void) strcpy(Outfile, Infile);
274: (void) strcat(Outfile, ".dat");
275: }
276: if (bad) {
277: puts("use \"strfile -\" to get usage");
278: exit(-1);
279: }
280: }
281:
282: /*
283: * do_order:
284: * Order the strings alphabetically (possibly ignoring case).
285: */
286: do_order(seekpts, outf)
287: long *seekpts;
288: FILE *outf;
289: {
290: register int i;
291: register long *lp;
292: register STR *fp;
293: extern int cmp_str();
294:
295: (void) fflush(outf);
296: Sort_1 = fopen(Outfile, "r");
297: Sort_2 = fopen(Outfile, "r");
298: Seekpts = seekpts;
299: qsort((char *) Firstch, Tbl.str_numstr, sizeof *Firstch, cmp_str);
300: i = Tbl.str_numstr;
301: lp = seekpts;
302: fp = Firstch;
303: while (i--)
304: *lp++ = fp++->pos;
305: (void) fclose(Sort_1);
306: (void) fclose(Sort_2);
307: Tbl.str_flags |= STR_ORDERED;
308: }
309:
310: /*
311: * cmp_str:
312: * Compare two strings in the file
313: */
314: cmp_str(p1, p2)
315: STR *p1, *p2;
316: {
317: register int c1, c2;
318:
319: c1 = p1->first;
320: c2 = p2->first;
321: if (c1 != c2)
322: return c1 - c2;
323:
324: (void) fseek(Sort_1, p1->pos, 0);
325: (void) fseek(Sort_2, p2->pos, 0);
326:
327: while (!isalnum(c1 = getc(Sort_1)) && c1 != '\0')
328: continue;
329: while (!isalnum(c2 = getc(Sort_2)) && c2 != '\0')
330: continue;
331:
332: while (c1 != '\0' && c2 != '\0') {
333: if (Iflag) {
334: if (isupper(c1))
335: c1 = tolower(c1);
336: if (isupper(c2))
337: c2 = tolower(c2);
338: }
339: if (c1 != c2)
340: return c1 - c2;
341: c1 = getc(Sort_1);
342: c2 = getc(Sort_2);
343: }
344: return c1 - c2;
345: }
346:
347: /*
348: * randomize:
349: * Randomize the order of the string table. We must be careful
350: * not to randomize across delimiter boundaries. All
351: * randomization is done within each block.
352: */
353: randomize(seekpts)
354: register long *seekpts;
355: {
356: register int cnt, i, j, start;
357: register long tmp;
358: register long *origsp;
359:
360: Tbl.str_flags |= STR_RANDOM;
361: srnd(time((long *) NULL) + getpid());
362: origsp = seekpts;
363: for (j = 0; j <= Delim; j++) {
364:
365: /*
366: * get the starting place for the block
367: */
368:
369: if (j == 0)
370: start = 0;
371: else
372: start = Tbl.str_delims[j - 1];
373:
374: /*
375: * get the ending point
376: */
377:
378: if (j == Delim)
379: cnt = Tbl.str_numstr;
380: else
381: cnt = Tbl.str_delims[j];
382:
383: /*
384: * move things around randomly
385: */
386:
387: for (seekpts = &origsp[start]; cnt > start; cnt--, seekpts++) {
388: i = rnd(cnt - start);
389: tmp = seekpts[0];
390: seekpts[0] = seekpts[i];
391: seekpts[i] = tmp;
392: }
393: }
394: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.