Merge from vendor branch OPENSSH:
[dragonfly.git] / usr.bin / xstr / xstr.c
1 /*
2  * Copyright (c) 1980, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
34  * @(#)xstr.c   8.1 (Berkeley) 6/9/93
35  * $FreeBSD: src/usr.bin/xstr/xstr.c,v 1.4.2.1 2002/11/16 01:01:21 tjr Exp $
36  * $DragonFly: src/usr.bin/xstr/xstr.c,v 1.3 2005/07/26 20:17:31 liamfoy Exp $
37  */
38
39 #include <sys/types.h>
40
41 #include <ctype.h>
42 #include <err.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <signal.h>
46 #include <string.h>
47 #include <unistd.h>
48
49 #include "pathnames.h"
50
51 /*
52  * xstr - extract and hash strings in a C program
53  *
54  * Bill Joy UCB
55  * November, 1978
56  */
57
58 #define ignore(a)       ((void) a)
59
60 off_t   tellpt;
61
62 off_t   mesgpt;
63 char    cstrings[] =    "strings";
64 char    *strings =      cstrings;
65
66 int     cflg;
67 int     vflg;
68 int     readstd;
69
70 char lastchr(char *);
71
72 int fgetNUL(char *, int, FILE *);
73 int istail(char *, char *);
74 int octdigit(char);
75 int xgetc(FILE *);
76
77 off_t hashit(char *, int);
78 off_t yankstr(char **);
79
80 static void usage(void);
81
82 void flushsh(void);
83 void found(int, off_t, char *);
84 void inithash(void);
85 void onintr(int);
86 void process(const char *);
87 void prstr(char *);
88 void xsdotc(void);
89
90 int
91 main(int argc, char *argv[])
92 {
93         int c;
94
95         while ((c = getopt(argc, argv, "-cv")) != -1)
96                 switch (c) {
97                 case '-':
98                         readstd++;
99                         break;
100                 case 'c':
101                         cflg++;
102                         break;
103                 case 'v':
104                         vflg++;
105                         break;
106                 default:
107                         usage();
108                 }
109         argc -= optind;
110         argv += optind;
111                 
112         if (signal(SIGINT, SIG_IGN) == SIG_DFL)
113                 signal(SIGINT, onintr);
114         if (cflg || (argc == 0 && !readstd))
115                 inithash();
116         else
117                 strings = mktemp(strdup(_PATH_TMP));
118         while (readstd || argc > 0) {
119                 if (freopen("x.c", "w", stdout) == NULL)
120                         err(1, "x.c");
121                 if (!readstd && freopen(argv[0], "r", stdin) == NULL)
122                         err(2, "%s", argv[0]);
123                 process("x.c");
124                 if (readstd == 0)
125                         argc--, argv++;
126                 else
127                         readstd = 0;
128         };
129         flushsh();
130         if (cflg == 0)
131                 xsdotc();
132         if (strings[0] == '/')
133                 ignore(unlink(strings));
134         exit(0);
135 }
136
137 static void
138 usage(void)
139 {
140         fprintf(stderr, "usage: xstr [-v] [-c] [-] [name ...]\n");
141         exit (1);
142 }
143
144 char linebuf[BUFSIZ];
145
146 void
147 process(const char *name)
148 {
149         char *cp;
150         int c;
151         int incomm = 0;
152         int ret;
153
154         printf("extern char\txstr[];\n");
155         for (;;) {
156                 if (fgets(linebuf, sizeof linebuf, stdin) == NULL) {
157                         if (ferror(stdin))
158                                 err(3, "%s", name);
159                         break;
160                 }
161                 if (linebuf[0] == '#') {
162                         if (linebuf[1] == ' ' && isdigit(linebuf[2]))
163                                 printf("#line%s", &linebuf[1]);
164                         else
165                                 printf("%s", linebuf);
166                         continue;
167                 }
168                 for (cp = linebuf; (c = *cp++);) switch (c) {
169
170                 case '"':
171                         if (incomm)
172                                 goto def;
173                         if ((ret = (int) yankstr(&cp)) == -1)
174                                 goto out;
175                         printf("(&xstr[%d])", ret);
176                         break;
177
178                 case '\'':
179                         if (incomm)
180                                 goto def;
181                         putchar(c);
182                         if (*cp)
183                                 putchar(*cp++);
184                         break;
185
186                 case '/':
187                         if (incomm || *cp != '*')
188                                 goto def;
189                         incomm = 1;
190                         cp++;
191                         printf("/*");
192                         continue;
193
194                 case '*':
195                         if (incomm && *cp == '/') {
196                                 incomm = 0;
197                                 cp++;
198                                 printf("*/");
199                                 continue;
200                         }
201                         goto def;
202
203 def:
204                 default:
205                         putchar(c);
206                         break;
207                 }
208         }
209 out:
210         if (ferror(stdout))
211                 warn("x.c"), onintr(0);
212 }
213
214 off_t
215 yankstr(char **cpp)
216 {
217         char *cp = *cpp;
218         int c, ch;
219         char dbuf[BUFSIZ];
220         char *dp = dbuf;
221         char *tp;
222         static char tmp[] = "b\bt\tr\rn\nf\f\\\\\"\"";
223
224         while ((c = *cp++)) {
225                 if (dp == dbuf + sizeof(dbuf) - 3)
226                         errx(1, "message too long");
227                 switch (c) {
228
229                 case '"':
230                         cp++;
231                         goto out;
232
233                 case '\\':
234                         c = *cp++;
235                         if (c == 0)
236                                 break;
237                         if (c == '\n') {
238                                 if (fgets(linebuf, sizeof linebuf, stdin)
239                                     == NULL) {
240                                         if (ferror(stdin))
241                                                 err(3, "x.c");
242                                         return(-1);
243                                 }
244                                 cp = linebuf;
245                                 continue;
246                         }
247                         for (tp = tmp; (ch = *tp++); tp++)
248                                 if (c == ch) {
249                                         c = *tp;
250                                         goto gotc;
251                                 }
252                         if (!octdigit(c)) {
253                                 *dp++ = '\\';
254                                 break;
255                         }
256                         c -= '0';
257                         if (!octdigit(*cp))
258                                 break;
259                         c <<= 3, c += *cp++ - '0';
260                         if (!octdigit(*cp))
261                                 break;
262                         c <<= 3, c += *cp++ - '0';
263                         break;
264                 }
265 gotc:
266                 *dp++ = c;
267         }
268 out:
269         *cpp = --cp;
270         *dp = 0;
271         return (hashit(dbuf, 1));
272 }
273
274 int
275 octdigit(char c)
276 {
277         return (isdigit(c) && c != '8' && c != '9');
278 }
279
280 void
281 inithash(void)
282 {
283         char buf[BUFSIZ];
284         FILE *mesgread = fopen(strings, "r");
285
286         if (mesgread == NULL)
287                 return;
288         for (;;) {
289                 mesgpt = tellpt;
290                 if (fgetNUL(buf, sizeof buf, mesgread) == 0)
291                         break;
292                 ignore(hashit(buf, 0));
293         }
294         ignore(fclose(mesgread));
295 }
296
297 int
298 fgetNUL(char *obuf, int rmdr, FILE *file)
299 {
300         int c;
301         char *buf = obuf;
302
303         while (--rmdr > 0 && (c = xgetc(file)) != 0 && c != EOF)
304                 *buf++ = c;
305         *buf++ = 0;
306         return ((feof(file) || ferror(file)) ? 0 : 1);
307 }
308
309 int
310 xgetc(FILE *file)
311 {
312
313         tellpt++;
314         return (getc(file));
315 }
316
317 #define BUCKETS 128
318
319 struct  hash {
320         off_t   hpt;
321         char    *hstr;
322         struct  hash *hnext;
323         short   hnew;
324 } bucket[BUCKETS];
325
326 off_t
327 hashit(char *str, int new)
328 {
329         int i;
330         struct hash *hp, *hp0;
331
332         hp = hp0 = &bucket[lastchr(str) & 0177];
333         while (hp->hnext) {
334                 hp = hp->hnext;
335                 i = istail(str, hp->hstr);
336                 if (i >= 0)
337                         return (hp->hpt + i);
338         }
339         if ((hp = (struct hash *) calloc(1, sizeof (*hp))) == NULL)
340                 errx(8, "calloc");
341         hp->hpt = mesgpt;
342         if (!(hp->hstr = strdup(str)))
343                 err(1, NULL);
344         mesgpt += strlen(hp->hstr) + 1;
345         hp->hnext = hp0->hnext;
346         hp->hnew = new;
347         hp0->hnext = hp;
348         return (hp->hpt);
349 }
350
351 void
352 flushsh(void)
353 {
354         int i;
355         struct hash *hp;
356         FILE *mesgwrit;
357         int old = 0, new = 0;
358
359         for (i = 0; i < BUCKETS; i++)
360                 for (hp = bucket[i].hnext; hp != NULL; hp = hp->hnext)
361                         if (hp->hnew)
362                                 new++;
363                         else
364                                 old++;
365         if (new == 0 && old != 0)
366                 return;
367         mesgwrit = fopen(strings, old ? "r+" : "w");
368         if (mesgwrit == NULL)
369                 err(4, "%s", strings);
370         for (i = 0; i < BUCKETS; i++)
371                 for (hp = bucket[i].hnext; hp != NULL; hp = hp->hnext) {
372                         found(hp->hnew, hp->hpt, hp->hstr);
373                         if (hp->hnew) {
374                                 fseek(mesgwrit, hp->hpt, 0);
375                                 ignore(fwrite(hp->hstr, strlen(hp->hstr) + 1, 1, mesgwrit));
376                                 if (ferror(mesgwrit))
377                                         err(4, "%s", strings);
378                         }
379                 }
380         if (fclose(mesgwrit) == EOF)
381                 err(4, "%s", strings);
382 }
383
384 void
385 found(int new, off_t off, char *str)
386 {
387         if (vflg == 0)
388                 return;
389         if (!new)
390                 fprintf(stderr, "found at %d:", (int) off);
391         else
392                 fprintf(stderr, "new at %d:", (int) off);
393         prstr(str);
394         fprintf(stderr, "\n");
395 }
396
397 void
398 prstr(char *cp)
399 {
400         int c;
401
402         while ((c = (*cp++ & 0377)))
403                 if (c < ' ')
404                         fprintf(stderr, "^%c", c + '`');
405                 else if (c == 0177)
406                         fprintf(stderr, "^?");
407                 else if (c > 0200)
408                         fprintf(stderr, "\\%03o", c);
409                 else
410                         fprintf(stderr, "%c", c);
411 }
412
413 void
414 xsdotc(void)
415 {
416         FILE *strf = fopen(strings, "r");
417         FILE *xdotcf;
418
419         if (strf == NULL)
420                 err(5, "%s", strings);
421         xdotcf = fopen("xs.c", "w");
422         if (xdotcf == NULL)
423                 err(6, "xs.c");
424         fprintf(xdotcf, "char\txstr[] = {\n");
425         for (;;) {
426                 int i, c;
427
428                 for (i = 0; i < 8; i++) {
429                         c = getc(strf);
430                         if (ferror(strf)) {
431                                 warn("%s", strings);
432                                 onintr(0);
433                         }
434                         if (feof(strf)) {
435                                 fprintf(xdotcf, "\n");
436                                 goto out;
437                         }
438                         fprintf(xdotcf, "0x%02x,", c);
439                 }
440                 fprintf(xdotcf, "\n");
441         }
442 out:
443         fprintf(xdotcf, "};\n");
444         ignore(fclose(xdotcf));
445         ignore(fclose(strf));
446 }
447
448 char
449 lastchr(char *cp)
450 {
451
452         while (cp[0] && cp[1])
453                 cp++;
454         return (*cp);
455 }
456
457 int
458 istail(char *str, char *of)
459 {
460         int d = strlen(of) - strlen(str);
461
462         if (d < 0 || strcmp(&of[d], str) != 0)
463                 return (-1);
464         return (d);
465 }
466
467 void
468 onintr(int dummy __unused)
469 {
470
471         ignore(signal(SIGINT, SIG_IGN));
472         if (strings[0] == '/')
473                 ignore(unlink(strings));
474         ignore(unlink("x.c"));
475         ignore(unlink("xs.c"));
476         exit(7);
477 }