![[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] / 43BSDReno / games / fortune|
Return to strfile.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / fortune |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Ken Arnold.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that the above copyright notice and this paragraph are
10: * duplicated in all such forms and that any documentation,
11: * advertising materials, and other materials related to such
12: * distribution and use acknowledge that the software was developed
13: * by the University of California, Berkeley. The name of the
14: * University may not be used to endorse or promote products derived
15: * from this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: */
20:
21: #ifndef lint
22: char copyright[] =
23: "@(#) Copyright (c) 1989 The Regents of the University of California.\n\
24: All rights reserved.\n";
25: #endif /* not lint */
26:
27: #ifndef lint
28: static char sccsid[] = "@(#)strfile.c 5.11 (Berkeley) 12/15/89";
29: #endif /* not lint */
30:
31: # include <machine/endian.h>
32: # include <sys/param.h>
33: # include <stdio.h>
34: # include <ctype.h>
35: # include "strfile.h"
36:
37: # ifndef MAXPATHLEN
38: # define MAXPATHLEN 1024
39: # endif /* MAXPATHLEN */
40:
41: /*
42: * This program takes a file composed of strings seperated by
43: * lines starting with two consecutive delimiting character (default
44: * character is '%') and creates another file which consists of a table
45: * describing the file (structure from "strfile.h"), a table of seek
46: * pointers to the start of the strings, and the strings, each terminated
47: * by a null byte. Usage:
48: *
49: * % strfile [-iorsx] [ -cC ] sourcefile [ datafile ]
50: *
51: * c - Change delimiting character from '%' to 'C'
52: * s - Silent. Give no summary of data processed at the end of
53: * the run.
54: * o - order the strings in alphabetic order
55: * i - if ordering, ignore case
56: * r - randomize the order of the strings
57: * x - set rotated bit
58: *
59: * Ken Arnold Sept. 7, 1978 --
60: *
61: * Added ordering options.
62: */
63:
64: # define TRUE 1
65: # define FALSE 0
66:
67: # define STORING_PTRS (Oflag || Rflag)
68: # define CHUNKSIZE 512
69:
70: #ifdef lint
71: # define ALWAYS atoi("1")
72: #else
73: # define ALWAYS 1
74: #endif
75: # define ALLOC(ptr,sz) if (ALWAYS) { \
76: if (ptr == NULL) \
77: ptr = malloc((unsigned int) (CHUNKSIZE * sizeof *ptr)); \
78: else if (((sz) + 1) % CHUNKSIZE == 0) \
79: ptr = realloc((void *) ptr, ((unsigned int) ((sz) + CHUNKSIZE) * sizeof *ptr)); \
80: if (ptr == NULL) { \
81: fprintf(stderr, "out of space\n"); \
82: exit(1); \
83: } \
84: } else
85:
86: #ifdef NO_VOID
87: # define void char
88: #endif
89:
90: typedef struct {
91: char first;
92: off_t pos;
93: } STR;
94:
95: char *Infile = NULL, /* input file name */
96: Outfile[MAXPATHLEN] = "", /* output file name */
97: Delimch = '%'; /* delimiting character */
98:
99: int Sflag = FALSE; /* silent run flag */
100: int Oflag = FALSE; /* ordering flag */
101: int Iflag = FALSE; /* ignore case flag */
102: int Rflag = FALSE; /* randomize order flag */
103: int Xflag = FALSE; /* set rotated bit */
104: long Num_pts = 0; /* number of pointers/strings */
105:
106: off_t *Seekpts;
107:
108: FILE *Sort_1, *Sort_2; /* pointers for sorting */
109:
110: STRFILE Tbl; /* statistics table */
111:
112: STR *Firstch; /* first chars of each string */
113:
114: char *fgets(), *strcpy(), *strcat();
115:
116: void *malloc(), *realloc();
117:
118: /*
119: * main:
120: * Drive the sucker. There are two main modes -- either we store
121: * the seek pointers, if the table is to be sorted or randomized,
122: * or we write the pointer directly to the file, if we are to stay
123: * in file order. If the former, we allocate and re-allocate in
124: * CHUNKSIZE blocks; if the latter, we just write each pointer,
125: * and then seek back to the beginning to write in the table.
126: */
127: main(ac, av)
128: int ac;
129: char **av;
130: {
131: register char *sp, dc;
132: register FILE *inf, *outf;
133: register off_t last_off, length, pos, *p;
134: register int first, cnt;
135: register char *nsp;
136: register STR *fp;
137: static char string[257];
138:
139: getargs(ac, av); /* evalute arguments */
140: dc = Delimch;
141: if ((inf = fopen(Infile, "r")) == NULL) {
142: perror(Infile);
143: exit(1);
144: }
145:
146: if ((outf = fopen(Outfile, "w")) == NULL) {
147: perror(Outfile);
148: exit(1);
149: }
150: if (!STORING_PTRS)
151: (void) fseek(outf, sizeof Tbl, 0);
152:
153: /*
154: * Write the strings onto the file
155: */
156:
157: Tbl.str_longlen = 0;
158: Tbl.str_shortlen = (unsigned int) 0xffffffff;
159: Tbl.str_delim = dc;
160: Tbl.str_version = VERSION;
161: first = Oflag;
162: add_offset(outf, ftell(inf));
163: last_off = 0;
164: do {
165: sp = fgets(string, 256, inf);
166: if (sp == NULL || sp[0] == dc && sp[1] == '\n') {
167: pos = ftell(inf);
168: length = pos - last_off - (sp ? strlen(sp) : 0);
169: last_off = pos;
170: if (!length)
171: continue;
172: add_offset(outf, pos);
173: if (Tbl.str_longlen < length)
174: Tbl.str_longlen = length;
175: if (Tbl.str_shortlen > length)
176: Tbl.str_shortlen = length;
177: first = Oflag;
178: }
179: else if (first) {
180: for (nsp = sp; !isalnum(*nsp); nsp++)
181: continue;
182: ALLOC(Firstch, Num_pts);
183: fp = &Firstch[Num_pts - 1];
184: if (Iflag && isupper(*nsp))
185: fp->first = tolower(*nsp);
186: else
187: fp->first = *nsp;
188: fp->pos = Seekpts[Num_pts - 1];
189: first = FALSE;
190: }
191: } while (sp != NULL);
192:
193: /*
194: * write the tables in
195: */
196:
197: (void) fclose(inf);
198:
199: if (Oflag)
200: do_order();
201: else if (Rflag)
202: randomize();
203:
204: if (Xflag)
205: Tbl.str_flags |= STR_ROTATED;
206:
207: if (!Sflag) {
208: printf("\"%s\" created\n", Outfile);
209: if (Num_pts == 2)
210: puts("There was 1 string");
211: else
212: printf("There were %d strings\n", Num_pts - 1);
213: printf("Longest string: %lu byte%s\n", Tbl.str_longlen,
214: Tbl.str_longlen == 1 ? "" : "s");
215: printf("Shortest string: %lu byte%s\n", Tbl.str_shortlen,
216: Tbl.str_shortlen == 1 ? "" : "s");
217: }
218:
219: (void) fseek(outf, (off_t) 0, 0);
220: Tbl.str_version = htonl(Tbl.str_version);
221: Tbl.str_numstr = htonl(Num_pts - 1);
222: Tbl.str_longlen = htonl(Tbl.str_longlen);
223: Tbl.str_shortlen = htonl(Tbl.str_shortlen);
224: Tbl.str_flags = htonl(Tbl.str_flags);
225: (void) fwrite((char *) &Tbl, sizeof Tbl, 1, outf);
226: if (STORING_PTRS) {
227: for (p = Seekpts, cnt = Num_pts; cnt--; ++p)
228: *p = htonl(*p);
229: (void) fwrite((char *) Seekpts, sizeof *Seekpts, (int) Num_pts, outf);
230: }
231: (void) fclose(outf);
232: exit(0);
233: }
234:
235: /*
236: * This routine evaluates arguments from the command line
237: */
238: getargs(argc, argv)
239: int argc;
240: char **argv;
241: {
242: extern char *optarg;
243: extern int optind;
244: int ch;
245:
246: while ((ch = getopt(argc, argv, "c:iorsx")) != EOF)
247: switch(ch) {
248: case 'c': /* new delimiting char */
249: Delimch = *optarg;
250: if (!isascii(Delimch)) {
251: printf("bad delimiting character: '\\%o\n'",
252: Delimch);
253: }
254: break;
255: case 'i': /* ignore case in ordering */
256: Iflag++;
257: break;
258: case 'o': /* order strings */
259: Oflag++;
260: break;
261: case 'r': /* randomize pointers */
262: Rflag++;
263: break;
264: case 's': /* silent */
265: Sflag++;
266: break;
267: case 'x': /* set the rotated bit */
268: Xflag++;
269: break;
270: case '?':
271: default:
272: usage();
273: }
274: argv += optind;
275:
276: if (*argv) {
277: Infile = *argv;
278: if (*++argv)
279: (void) strcpy(Outfile, *argv);
280: }
281: if (!Infile) {
282: puts("No input file name");
283: usage();
284: }
285: if (*Outfile == '\0') {
286: (void) strcpy(Outfile, Infile);
287: (void) strcat(Outfile, ".dat");
288: }
289: }
290:
291: usage()
292: {
293: (void) fprintf(stderr,
294: "strfile [-iorsx] [-c char] sourcefile [datafile]\n");
295: exit(1);
296: }
297:
298: /*
299: * add_offset:
300: * Add an offset to the list, or write it out, as appropriate.
301: */
302: add_offset(fp, off)
303: FILE *fp;
304: off_t off;
305: {
306: off_t net;
307:
308: if (!STORING_PTRS) {
309: net = htonl(off);
310: fwrite(&net, 1, sizeof net, fp);
311: } else {
312: ALLOC(Seekpts, Num_pts + 1);
313: Seekpts[Num_pts] = off;
314: }
315: Num_pts++;
316: }
317:
318: /*
319: * do_order:
320: * Order the strings alphabetically (possibly ignoring case).
321: */
322: do_order()
323: {
324: register int i;
325: register off_t *lp;
326: register STR *fp;
327: extern int cmp_str();
328:
329: Sort_1 = fopen(Infile, "r");
330: Sort_2 = fopen(Infile, "r");
331: qsort((char *) Firstch, (int) Tbl.str_numstr, sizeof *Firstch, cmp_str);
332: i = Tbl.str_numstr;
333: lp = Seekpts;
334: fp = Firstch;
335: while (i--)
336: *lp++ = fp++->pos;
337: (void) fclose(Sort_1);
338: (void) fclose(Sort_2);
339: Tbl.str_flags |= STR_ORDERED;
340: }
341:
342: /*
343: * cmp_str:
344: * Compare two strings in the file
345: */
346: char *
347: unctrl(c)
348: char c;
349: {
350: static char buf[3];
351:
352: if (isprint(c)) {
353: buf[0] = c;
354: buf[1] = '\0';
355: }
356: else if (c == 0177) {
357: buf[0] = '^';
358: buf[1] = '?';
359: }
360: else {
361: buf[0] = '^';
362: buf[1] = c + 'A' - 1;
363: }
364: return buf;
365: }
366:
367: cmp_str(p1, p2)
368: STR *p1, *p2;
369: {
370: register int c1, c2;
371: register int n1, n2;
372:
373: # define SET_N(nf,ch) (nf = (ch == '\n'))
374: # define IS_END(ch,nf) (ch == Delimch && nf)
375:
376: c1 = p1->first;
377: c2 = p2->first;
378: if (c1 != c2)
379: return c1 - c2;
380:
381: (void) fseek(Sort_1, p1->pos, 0);
382: (void) fseek(Sort_2, p2->pos, 0);
383:
384: n1 = FALSE;
385: n2 = FALSE;
386: while (!isalnum(c1 = getc(Sort_1)) && c1 != '\0')
387: SET_N(n1, c1);
388: while (!isalnum(c2 = getc(Sort_2)) && c2 != '\0')
389: SET_N(n2, c2);
390:
391: while (!IS_END(c1, n1) && !IS_END(c2, n2)) {
392: if (Iflag) {
393: if (isupper(c1))
394: c1 = tolower(c1);
395: if (isupper(c2))
396: c2 = tolower(c2);
397: }
398: if (c1 != c2)
399: return c1 - c2;
400: SET_N(n1, c1);
401: SET_N(n2, c2);
402: c1 = getc(Sort_1);
403: c2 = getc(Sort_2);
404: }
405: if (IS_END(c1, n1))
406: c1 = 0;
407: if (IS_END(c2, n2))
408: c2 = 0;
409: return c1 - c2;
410: }
411:
412: /*
413: * randomize:
414: * Randomize the order of the string table. We must be careful
415: * not to randomize across delimiter boundaries. All
416: * randomization is done within each block.
417: */
418: randomize()
419: {
420: register int cnt, i;
421: register off_t tmp;
422: register off_t *sp;
423: extern time_t time();
424:
425: srandom((int)(time((time_t *) NULL) + getpid()));
426:
427: Tbl.str_flags |= STR_RANDOM;
428: cnt = Tbl.str_numstr;
429:
430: /*
431: * move things around randomly
432: */
433:
434: for (sp = Seekpts; cnt > 0; cnt--, sp++) {
435: i = random() % cnt;
436: tmp = sp[0];
437: sp[0] = sp[i];
438: sp[i] = tmp;
439: }
440: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.