xref: /illumos-gate/usr/src/cmd/localedef/scanner.c (revision d8109ce4330e1b8ad6c29f9fccacec969066bb9d)
1 /*
2  * This file and its contents are supplied under the terms of the
3  * Common Development and Distribution License ("CDDL"), version 1.0.
4  * You may only use this file in accordance with the terms of version
5  * 1.0 of the CDDL.
6  *
7  * A full copy of the text of the CDDL should have accompanied this
8  * source.  A copy of the CDDL is also available via the Internet at
9  * http://www.illumos.org/license/CDDL.
10  */
11 
12 /*
13  * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.
14  * Copyright 2013 DEY Storage Systems, Inc.
15  */
16 
17 /*
18  * This file contains the "scanner", which tokenizes the input files
19  * for localedef for processing by the higher level grammar processor.
20  */
21 
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <ctype.h>
25 #include <limits.h>
26 #include <string.h>
27 #include <widec.h>
28 #include <sys/types.h>
29 #include <assert.h>
30 #include "localedef.h"
31 #include "parser.tab.h"
32 
33 int			com_char = '#';
34 int			esc_char = '\\';
35 int			mb_cur_min = 1;
36 int			mb_cur_max = 1;
37 int			lineno = 1;
38 int			warnings = 0;
39 static int		nextline;
40 static FILE		*input = stdin;
41 static const char	*filename = "<stdin>";
42 static int		instring = 0;
43 static int		escaped = 0;
44 
45 /*
46  * Token space ... grows on demand.
47  */
48 static char *token = NULL;
49 static int tokidx;
50 static int toksz = 0;
51 static int hadtok = 0;
52 
53 /*
54  * Wide string space ... grows on demand.
55  */
56 static wchar_t *widestr = NULL;
57 static int wideidx = 0;
58 static int widesz = 0;
59 
60 /*
61  * The last keyword seen.  This is useful to trigger the special lexer rules
62  * for "copy" and also collating symbols and elements.
63  */
64 int	last_kw = 0;
65 static int	category = T_END;
66 
67 static struct token {
68 	int id;
69 	const char *name;
70 } keywords[] = {
71 	{ T_COM_CHAR,		"comment_char" },
72 	{ T_ESC_CHAR,		"escape_char" },
73 	{ T_END,		"END" },
74 	{ T_COPY,		"copy" },
75 	{ T_MESSAGES,		"LC_MESSAGES" },
76 	{ T_YESSTR,		"yesstr" },
77 	{ T_YESEXPR,		"yesexpr" },
78 	{ T_NOSTR,		"nostr" },
79 	{ T_NOEXPR,		"noexpr" },
80 	{ T_MONETARY,		"LC_MONETARY" },
81 	{ T_INT_CURR_SYMBOL,	"int_curr_symbol" },
82 	{ T_CURRENCY_SYMBOL,	"currency_symbol" },
83 	{ T_MON_DECIMAL_POINT,	"mon_decimal_point" },
84 	{ T_MON_THOUSANDS_SEP,	"mon_thousands_sep" },
85 	{ T_POSITIVE_SIGN,	"positive_sign" },
86 	{ T_NEGATIVE_SIGN,	"negative_sign" },
87 	{ T_MON_GROUPING,	"mon_grouping" },
88 	{ T_INT_FRAC_DIGITS,	"int_frac_digits" },
89 	{ T_FRAC_DIGITS,	"frac_digits" },
90 	{ T_P_CS_PRECEDES,	"p_cs_precedes" },
91 	{ T_P_SEP_BY_SPACE,	"p_sep_by_space" },
92 	{ T_N_CS_PRECEDES,	"n_cs_precedes" },
93 	{ T_N_SEP_BY_SPACE,	"n_sep_by_space" },
94 	{ T_P_SIGN_POSN,	"p_sign_posn" },
95 	{ T_N_SIGN_POSN,	"n_sign_posn" },
96 	{ T_INT_P_CS_PRECEDES,	"int_p_cs_precedes" },
97 	{ T_INT_N_CS_PRECEDES,	"int_n_cs_precedes" },
98 	{ T_INT_P_SEP_BY_SPACE,	"int_p_sep_by_space" },
99 	{ T_INT_N_SEP_BY_SPACE,	"int_n_sep_by_space" },
100 	{ T_INT_P_SIGN_POSN,	"int_p_sign_posn" },
101 	{ T_INT_N_SIGN_POSN,	"int_n_sign_posn" },
102 	{ T_COLLATE,		"LC_COLLATE" },
103 	{ T_COLLATING_SYMBOL,	"collating-symbol" },
104 	{ T_COLLATING_ELEMENT,	"collating-element" },
105 	{ T_FROM,		"from" },
106 	{ T_ORDER_START,	"order_start" },
107 	{ T_ORDER_END,		"order_end" },
108 	{ T_FORWARD,		"forward" },
109 	{ T_BACKWARD,		"backward" },
110 	{ T_POSITION,		"position" },
111 	{ T_IGNORE,		"IGNORE" },
112 	{ T_UNDEFINED,		"UNDEFINED" },
113 	{ T_NUMERIC,		"LC_NUMERIC" },
114 	{ T_DECIMAL_POINT,	"decimal_point" },
115 	{ T_THOUSANDS_SEP,	"thousands_sep" },
116 	{ T_GROUPING,		"grouping" },
117 	{ T_TIME,		"LC_TIME" },
118 	{ T_ABDAY,		"abday" },
119 	{ T_DAY,		"day" },
120 	{ T_ABMON,		"abmon" },
121 	{ T_MON,		"mon" },
122 	{ T_D_T_FMT,		"d_t_fmt" },
123 	{ T_D_FMT,		"d_fmt" },
124 	{ T_T_FMT,		"t_fmt" },
125 	{ T_AM_PM,		"am_pm" },
126 	{ T_T_FMT_AMPM,		"t_fmt_ampm" },
127 	{ T_ERA,		"era" },
128 	{ T_ERA_D_FMT,		"era_d_fmt" },
129 	{ T_ERA_T_FMT,		"era_t_fmt" },
130 	{ T_ERA_D_T_FMT,	"era_d_t_fmt" },
131 	{ T_ALT_DIGITS,		"alt_digits" },
132 	{ T_CTYPE,		"LC_CTYPE" },
133 	{ T_ISUPPER,		"upper" },
134 	{ T_ISLOWER,		"lower" },
135 	{ T_ISALPHA,		"alpha" },
136 	{ T_ISDIGIT,		"digit" },
137 	{ T_ISPUNCT,		"punct" },
138 	{ T_ISXDIGIT,		"xdigit" },
139 	{ T_ISSPACE,		"space" },
140 	{ T_ISPRINT,		"print" },
141 	{ T_ISGRAPH,		"graph" },
142 	{ T_ISBLANK,		"blank" },
143 	{ T_ISCNTRL,		"cntrl" },
144 	/*
145 	 * These entries are local additions, and not specified by
146 	 * TOG.  Note that they are not guaranteed to be accurate for
147 	 * all locales, and so applications should not depend on them.
148 	 */
149 	{ T_ISSPECIAL,		"special" },
150 	{ T_ISENGLISH,		"english" },
151 	{ T_ISPHONOGRAM,	"phonogram" },
152 	{ T_ISIDEOGRAM,		"ideogram" },
153 	{ T_ISNUMBER,		"number" },
154 	/*
155 	 * We have to support this in the grammar, but it would be a
156 	 * syntax error to define a character as one of these without
157 	 * also defining it as an alpha or digit.  We ignore it in our
158 	 * parsing.
159 	 */
160 	{ T_ISALNUM,		"alnum" },
161 	{ T_TOUPPER,		"toupper" },
162 	{ T_TOLOWER,		"tolower" },
163 
164 	/*
165 	 * These are keywords used in the charmap file.  Note that
166 	 * Solaris originally used angle brackets to wrap some of them,
167 	 * but we removed that to simplify our parser.  The first of these
168 	 * items are "global items."
169 	 */
170 	{ T_CHARMAP,		"CHARMAP" },
171 	{ T_WIDTH,		"WIDTH" },
172 
173 	{ -1, NULL },
174 };
175 
176 /*
177  * These special words are only used in a charmap file, enclosed in <>.
178  */
179 static struct token symwords[] = {
180 	{ T_COM_CHAR,		"comment_char" },
181 	{ T_ESC_CHAR,		"escape_char" },
182 	{ T_CODE_SET,		"code_set_name" },
183 	{ T_MB_CUR_MAX,		"mb_cur_max" },
184 	{ T_MB_CUR_MIN,		"mb_cur_min" },
185 	{ -1, NULL },
186 };
187 
188 static int categories[] = {
189 	T_CHARMAP,
190 	T_CTYPE,
191 	T_COLLATE,
192 	T_MESSAGES,
193 	T_MONETARY,
194 	T_NUMERIC,
195 	T_TIME,
196 	T_WIDTH,
197 	0
198 };
199 
200 void
201 reset_scanner(const char *fname)
202 {
203 	if (fname == NULL) {
204 		filename = "<stdin>";
205 		input = stdin;
206 	} else {
207 		if (input != stdin)
208 			(void) fclose(input);
209 		if ((input = fopen(fname, "r")) == NULL) {
210 			perror("fopen");
211 			exit(4);
212 		}
213 		filename = fname;
214 	}
215 	com_char = '#';
216 	esc_char = '\\';
217 	instring = 0;
218 	escaped = 0;
219 	lineno = 1;
220 	nextline = 1;
221 	tokidx = 0;
222 	wideidx = 0;
223 }
224 
225 #define	hex(x)	\
226 	(isdigit(x) ? (x - '0') : ((islower(x) ? (x - 'a') : (x - 'A')) + 10))
227 #define	isodigit(x)	((x >= '0') && (x <= '7'))
228 
229 static int
230 scanc(void)
231 {
232 	int	c;
233 
234 	c = getc(input);
235 	lineno = nextline;
236 	if (c == '\n') {
237 		nextline++;
238 	}
239 	return (c);
240 }
241 
242 static void
243 unscanc(int c)
244 {
245 	if (c == '\n') {
246 		nextline--;
247 	}
248 	if (ungetc(c, input) < 0) {
249 		yyerror(_("ungetc failed"));
250 	}
251 }
252 
253 static int
254 scan_hex_byte(void)
255 {
256 	int	c1, c2;
257 	int	v;
258 
259 	c1 = scanc();
260 	if (!isxdigit(c1)) {
261 		yyerror(_("malformed hex digit"));
262 		return (0);
263 	}
264 	c2 = scanc();
265 	if (!isxdigit(c2)) {
266 		yyerror(_("malformed hex digit"));
267 		return (0);
268 	}
269 	v = ((hex(c1) << 4) | hex(c2));
270 	return (v);
271 }
272 
273 static int
274 scan_dec_byte(void)
275 {
276 	int	c1, c2, c3;
277 	int	b;
278 
279 	c1 = scanc();
280 	if (!isdigit(c1)) {
281 		yyerror(_("malformed decimal digit"));
282 		return (0);
283 	}
284 	b = c1 - '0';
285 	c2 = scanc();
286 	if (!isdigit(c2)) {
287 		yyerror(_("malformed decimal digit"));
288 		return (0);
289 	}
290 	b *= 10;
291 	b += (c2 - '0');
292 	c3 = scanc();
293 	if (!isdigit(c3)) {
294 		unscanc(c3);
295 	} else {
296 		b *= 10;
297 		b += (c3 - '0');
298 	}
299 	return (b);
300 }
301 
302 static int
303 scan_oct_byte(void)
304 {
305 	int c1, c2, c3;
306 	int	b;
307 
308 	b = 0;
309 
310 	c1 = scanc();
311 	if (!isodigit(c1)) {
312 		yyerror(_("malformed octal digit"));
313 		return (0);
314 	}
315 	b = c1 - '0';
316 	c2 = scanc();
317 	if (!isodigit(c2)) {
318 		yyerror(_("malformed octal digit"));
319 		return (0);
320 	}
321 	b *= 8;
322 	b += (c2 - '0');
323 	c3 = scanc();
324 	if (!isodigit(c3)) {
325 		unscanc(c3);
326 	} else {
327 		b *= 8;
328 		b += (c3 - '0');
329 	}
330 	return (b);
331 }
332 
333 void
334 add_tok(int c)
335 {
336 	if ((tokidx + 1) >= toksz) {
337 		toksz += 64;
338 		if ((token = realloc(token, toksz)) == NULL) {
339 			yyerror(_("out of memory"));
340 			tokidx = 0;
341 			toksz = 0;
342 			return;
343 		}
344 	}
345 
346 	token[tokidx++] = (char)c;
347 	token[tokidx] = 0;
348 }
349 void
350 add_wcs(wchar_t c)
351 {
352 	if ((wideidx + 1) >= widesz) {
353 		widesz += 64;
354 		widestr = realloc(widestr, (widesz * sizeof (wchar_t)));
355 		if (widestr == NULL) {
356 			yyerror(_("out of memory"));
357 			wideidx = 0;
358 			widesz = 0;
359 			return;
360 		}
361 	}
362 
363 	widestr[wideidx++] = c;
364 	widestr[wideidx] = 0;
365 }
366 
367 wchar_t *
368 get_wcs(void)
369 {
370 	wchar_t *ws = widestr;
371 	wideidx = 0;
372 	widestr = NULL;
373 	widesz = 0;
374 	if (ws == NULL) {
375 		if ((ws = wsdup(L"")) == NULL) {
376 			yyerror(_("out of memory"));
377 		}
378 	}
379 	return (ws);
380 }
381 
382 static int
383 get_byte(void)
384 {
385 	int	c;
386 
387 	if ((c = scanc()) != esc_char) {
388 		unscanc(c);
389 		return (EOF);
390 	}
391 	c = scanc();
392 
393 	switch (c) {
394 	case 'd':
395 	case 'D':
396 		return (scan_dec_byte());
397 	case 'x':
398 	case 'X':
399 		return (scan_hex_byte());
400 	case '0':
401 	case '1':
402 	case '2':
403 	case '3':
404 	case '4':
405 	case '5':
406 	case '6':
407 	case '7':
408 		/* put the character back so we can get it */
409 		unscanc(c);
410 		return (scan_oct_byte());
411 	default:
412 		unscanc(c);
413 		unscanc(esc_char);
414 		return (EOF);
415 	}
416 }
417 
418 int
419 get_escaped(int c)
420 {
421 	switch (c) {
422 	case 'n':
423 		return ('\n');
424 	case 'r':
425 		return ('\r');
426 	case 't':
427 		return ('\t');
428 	case 'f':
429 		return ('\f');
430 	case 'v':
431 		return ('\v');
432 	case 'b':
433 		return ('\b');
434 	case 'a':
435 		return ('\a');
436 	default:
437 		return (c);
438 	}
439 }
440 
441 int
442 get_wide(void)
443 {
444 	static char mbs[MB_LEN_MAX + 1] = "";
445 	static int mbi = 0;
446 	int c;
447 	wchar_t	wc;
448 
449 	if (mb_cur_max >= sizeof (mbs)) {
450 		yyerror(_("max multibyte character size too big"));
451 		mbi = 0;
452 		return (T_NULL);
453 	}
454 	for (;;) {
455 		if ((mbi == mb_cur_max) || ((c = get_byte()) == EOF)) {
456 			/*
457 			 * end of the byte sequence reached, but no
458 			 * valid wide decoding.  fatal error.
459 			 */
460 			mbi = 0;
461 			yyerror(_("not a valid character encoding"));
462 			return (T_NULL);
463 		}
464 		mbs[mbi++] = c;
465 		mbs[mbi] = 0;
466 
467 		/* does it decode? */
468 		if (to_wide(&wc, mbs) >= 0) {
469 			break;
470 		}
471 	}
472 
473 	mbi = 0;
474 	if ((category != T_CHARMAP) && (category != T_WIDTH)) {
475 		if (check_charmap(wc) < 0) {
476 			yyerror(_("no symbolic name for character"));
477 			return (T_NULL);
478 		}
479 	}
480 
481 	yylval.wc = wc;
482 	return (T_CHAR);
483 }
484 
485 int
486 get_symbol(void)
487 {
488 	int	c;
489 
490 	while ((c = scanc()) != EOF) {
491 		if (escaped) {
492 			escaped = 0;
493 			if (c == '\n')
494 				continue;
495 			add_tok(get_escaped(c));
496 			continue;
497 		}
498 		if (c == esc_char) {
499 			escaped = 1;
500 			continue;
501 		}
502 		if (c == '\n') {	/* well that's strange! */
503 			yyerror(_("unterminated symbolic name"));
504 			continue;
505 		}
506 		if (c == '>') {		/* end of symbol */
507 
508 			/*
509 			 * This restarts the token from the beginning
510 			 * the next time we scan a character.  (This
511 			 * token is complete.)
512 			 */
513 
514 			if (token == NULL) {
515 				yyerror(_("missing symbolic name"));
516 				return (T_NULL);
517 			}
518 			tokidx = 0;
519 
520 			/*
521 			 * A few symbols are handled as keywords outside
522 			 * of the normal categories.
523 			 */
524 			if (category == T_END) {
525 				int i;
526 				for (i = 0; symwords[i].name != 0; i++) {
527 					if (strcmp(token, symwords[i].name) ==
528 					    0) {
529 						last_kw = symwords[i].id;
530 						return (last_kw);
531 					}
532 				}
533 			}
534 			/*
535 			 * Contextual rule: Only literal characters are
536 			 * permitted in CHARMAP.  Anywhere else the symbolic
537 			 * forms are fine.
538 			 */
539 			if ((category != T_CHARMAP) &&
540 			    (lookup_charmap(token, &yylval.wc)) != -1) {
541 				return (T_CHAR);
542 			}
543 			if ((yylval.collsym = lookup_collsym(token)) != NULL) {
544 				return (T_COLLSYM);
545 			}
546 			if ((yylval.collelem = lookup_collelem(token)) !=
547 			    NULL) {
548 				return (T_COLLELEM);
549 			}
550 			/* its an undefined symbol */
551 			yylval.token = strdup(token);
552 			token = NULL;
553 			toksz = 0;
554 			tokidx = 0;
555 			return (T_SYMBOL);
556 		}
557 		add_tok(c);
558 	}
559 
560 	yyerror(_("unterminated symbolic name"));
561 	return (EOF);
562 }
563 
564 int
565 get_category(void)
566 {
567 	return (category);
568 }
569 
570 static int
571 consume_token(void)
572 {
573 	int	len = tokidx;
574 	int	i;
575 
576 	tokidx = 0;
577 	if (token == NULL)
578 		return (T_NULL);
579 
580 	/*
581 	 * this one is special, because we don't want it to alter the
582 	 * last_kw field.
583 	 */
584 	if (strcmp(token, "...") == 0) {
585 		return (T_ELLIPSIS);
586 	}
587 
588 	/* search for reserved words first */
589 	for (i = 0; keywords[i].name; i++) {
590 		int j;
591 		if (strcmp(keywords[i].name, token) != 0) {
592 			continue;
593 		}
594 
595 		last_kw = keywords[i].id;
596 
597 		/* clear the top level category if we're done with it */
598 		if (last_kw == T_END) {
599 			category = T_END;
600 		}
601 
602 		/* set the top level category if we're changing */
603 		for (j = 0; categories[j]; j++) {
604 			if (categories[j] != last_kw)
605 				continue;
606 			category = last_kw;
607 		}
608 
609 		return (keywords[i].id);
610 	}
611 
612 	/* maybe its a numeric constant? */
613 	if (isdigit(*token) || (*token == '-' && isdigit(token[1]))) {
614 		char *eptr;
615 		yylval.num = strtol(token, &eptr, 10);
616 		if (*eptr != 0)
617 			yyerror(_("malformed number"));
618 		return (T_NUMBER);
619 	}
620 
621 	/*
622 	 * A single lone character is treated as a character literal.
623 	 * To avoid duplication of effort, we stick in the charmap.
624 	 */
625 	if (len == 1) {
626 		yylval.wc = token[0];
627 		return (T_CHAR);
628 	}
629 
630 	/* anything else is treated as a symbolic name */
631 	yylval.token = strdup(token);
632 	token = NULL;
633 	toksz = 0;
634 	tokidx = 0;
635 	return (T_NAME);
636 }
637 
638 void
639 scan_to_eol(void)
640 {
641 	int	c;
642 	while ((c = scanc()) != '\n') {
643 		if (c == EOF) {
644 			/* end of file without newline! */
645 			errf(_("missing newline"));
646 			return;
647 		}
648 	}
649 	assert(c == '\n');
650 }
651 
652 int
653 yylex(void)
654 {
655 	int		c;
656 
657 	while ((c = scanc()) != EOF) {
658 
659 		/* special handling for quoted string */
660 		if (instring) {
661 			if (escaped) {
662 				escaped = 0;
663 
664 				/* if newline, just eat and forget it */
665 				if (c == '\n')
666 					continue;
667 
668 				if (strchr("xXd01234567", c)) {
669 					unscanc(c);
670 					unscanc(esc_char);
671 					return (get_wide());
672 				}
673 				yylval.wc = get_escaped(c);
674 				return (T_CHAR);
675 			}
676 			if (c == esc_char) {
677 				escaped = 1;
678 				continue;
679 			}
680 			switch (c) {
681 			case '<':
682 				return (get_symbol());
683 			case '>':
684 				/* oops! should generate syntax error  */
685 				return (T_GT);
686 			case '"':
687 				instring = 0;
688 				return (T_QUOTE);
689 			default:
690 				yylval.wc = c;
691 				return (T_CHAR);
692 			}
693 		}
694 
695 		/* escaped characters first */
696 		if (escaped) {
697 			escaped = 0;
698 			if (c == '\n') {
699 				/* eat the newline */
700 				continue;
701 			}
702 			hadtok = 1;
703 			if (tokidx) {
704 				/* an escape mid-token is nonsense */
705 				return (T_NULL);
706 			}
707 
708 			/* numeric escapes are treated as wide characters */
709 			if (strchr("xXd01234567", c)) {
710 				unscanc(c);
711 				unscanc(esc_char);
712 				return (get_wide());
713 			}
714 
715 			add_tok(get_escaped(c));
716 			continue;
717 		}
718 
719 		/* if it is the escape charter itself note it */
720 		if (c == esc_char) {
721 			escaped = 1;
722 			continue;
723 		}
724 
725 		/* remove from the comment char to end of line */
726 		if (c == com_char) {
727 			while (c != '\n') {
728 				if ((c = scanc()) == EOF) {
729 					/* end of file without newline! */
730 					return (EOF);
731 				}
732 			}
733 			assert(c == '\n');
734 			if (!hadtok) {
735 				/*
736 				 * If there were no tokens on this line,
737 				 * then just pretend it didn't exist at all.
738 				 */
739 				continue;
740 			}
741 			hadtok = 0;
742 			return (T_NL);
743 		}
744 
745 		if (strchr(" \t\n;()<>,\"", c) && (tokidx != 0)) {
746 			/*
747 			 * These are all token delimiters.  If there
748 			 * is a token already in progress, we need to
749 			 * process it.
750 			 */
751 			unscanc(c);
752 			return (consume_token());
753 		}
754 
755 		switch (c) {
756 		case '\n':
757 			if (!hadtok) {
758 				/*
759 				 * If the line was completely devoid of tokens,
760 				 * then just ignore it.
761 				 */
762 				continue;
763 			}
764 			/* we're starting a new line, reset the token state */
765 			hadtok = 0;
766 			return (T_NL);
767 		case ',':
768 			hadtok = 1;
769 			return (T_COMMA);
770 		case ';':
771 			hadtok = 1;
772 			return (T_SEMI);
773 		case '(':
774 			hadtok = 1;
775 			return (T_LPAREN);
776 		case ')':
777 			hadtok = 1;
778 			return (T_RPAREN);
779 		case '>':
780 			hadtok = 1;
781 			return (T_GT);
782 		case '<':
783 			/* symbol start! */
784 			hadtok = 1;
785 			return (get_symbol());
786 		case ' ':
787 		case '\t':
788 			/* whitespace, just ignore it */
789 			continue;
790 		case '"':
791 			hadtok = 1;
792 			instring = 1;
793 			return (T_QUOTE);
794 		default:
795 			hadtok = 1;
796 			add_tok(c);
797 			continue;
798 		}
799 	}
800 	return (EOF);
801 }
802 
803 void
804 yyerror(const char *msg)
805 {
806 	(void) fprintf(stderr, _("%s: %d: error: %s\n"),
807 	    filename, lineno, msg);
808 	exit(4);
809 }
810 
811 void
812 errf(const char *fmt, ...)
813 {
814 	char	*msg;
815 
816 	va_list	va;
817 	va_start(va, fmt);
818 	(void) vasprintf(&msg, fmt, va);
819 	va_end(va);
820 
821 	(void) fprintf(stderr, _("%s: %d: error: %s\n"),
822 	    filename, lineno, msg);
823 	free(msg);
824 	exit(4);
825 }
826 
827 void
828 warn(const char *fmt, ...)
829 {
830 	char	*msg;
831 
832 	va_list	va;
833 	va_start(va, fmt);
834 	(void) vasprintf(&msg, fmt, va);
835 	va_end(va);
836 
837 	(void) fprintf(stderr, _("%s: %d: warning: %s\n"),
838 	    filename, lineno, msg);
839 	free(msg);
840 	warnings++;
841 	if (!warnok)
842 		exit(4);
843 }
844