Context Navigation

cexp.y @ 11288

Visit:

Revision 11288, 29.3 KB checked in by ghudson, 26 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r11287, which included commits to RCS files with non-trunk default branches.

Line
1	/* Parse C expressions for CCCP.
2	Copyright (C) 1987, 1992, 1994, 1995, 1996, 1997 Free Software Foundation.
3
4	This program is free software; you can redistribute it and/or modify it
5	under the terms of the GNU General Public License as published by the
6	Free Software Foundation; either version 2, or (at your option) any
7	later version.
8
9	This program is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	GNU General Public License for more details.
13
14	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software
16	Foundation, 59 Temple Place - Suite 330,
17	Boston, MA 02111-1307, USA.
18
19	In other words, you are welcome to use, share and improve this program.
20	You are forbidden to forbid anyone else to use, share and improve
21	what you give them. Help stamp out software-hoarding!
22
23	Adapted from expread.y of GDB by Paul Rubin, July 1986. */
24
25	/* Parse a C expression from text in a string */
26
27	%{
28	#include "config.h"
29	#include <setjmp.h>
30	/* #define YYDEBUG 1 */
31
32
33	#ifdef HAVE_STRING_H
34	# include <string.h>
35	#endif
36
37	#ifdef HAVE_STDLIB_H
38	# include <stdlib.h>
39	#endif
40
41	#ifdef HAVE_LIMITS_H
42	# include <limits.h>
43	#endif
44
45	#ifdef MULTIBYTE_CHARS
46	#include <locale.h>
47	#endif
48
49	#include <stdio.h>
50
51	typedef unsigned char U_CHAR;
52
53	/* This is used for communicating lists of keywords with cccp.c. */
54	struct arglist {
55	struct arglist *next;
56	U_CHAR *name;
57	int length;
58	int argno;
59	};
60
61	/* Define a generic NULL if one hasn't already been defined. */
62
63	#ifndef NULL
64	#define NULL 0
65	#endif
66
67	#ifndef GENERIC_PTR
68	#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
69	#define GENERIC_PTR void *
70	#else
71	#define GENERIC_PTR char *
72	#endif
73	#endif
74
75	#ifndef NULL_PTR
76	#define NULL_PTR ((GENERIC_PTR) 0)
77	#endif
78
79	/* Find the largest host integer type and set its size and type.
80	Watch out: on some crazy hosts `long' is shorter than `int'. */
81
82	#ifndef HOST_WIDE_INT
83	# if HAVE_INTTYPES_H
84	# include <inttypes.h>
85	# define HOST_WIDE_INT intmax_t
86	# define unsigned_HOST_WIDE_INT uintmax_t
87	# else
88	# if (HOST_BITS_PER_LONG <= HOST_BITS_PER_INT && HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_INT)
89	# define HOST_WIDE_INT int
90	# else
91	# if (HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_LONG \|\| ! (defined LONG_LONG_MAX \|\| defined LLONG_MAX))
92	# define HOST_WIDE_INT long
93	# else
94	# define HOST_WIDE_INT long long
95	# endif
96	# endif
97	# endif
98	#endif
99
100	#ifndef unsigned_HOST_WIDE_INT
101	#define unsigned_HOST_WIDE_INT unsigned HOST_WIDE_INT
102	#endif
103
104	#ifndef CHAR_BIT
105	#define CHAR_BIT 8
106	#endif
107
108	#ifndef HOST_BITS_PER_WIDE_INT
109	#define HOST_BITS_PER_WIDE_INT (CHAR_BIT * sizeof (HOST_WIDE_INT))
110	#endif
111
112	#if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
113	# define __attribute__(x)
114	#endif
115
116	#ifndef PROTO
117	# if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
118	# define PROTO(ARGS) ARGS
119	# else
120	# define PROTO(ARGS) ()
121	# endif
122	#endif
123
124	#if defined (__STDC__) && defined (HAVE_VPRINTF)
125	# include <stdarg.h>
126	# define VA_START(va_list, var) va_start (va_list, var)
127	# define PRINTF_ALIST(msg) char *msg, ...
128	# define PRINTF_DCL(msg)
129	# define PRINTF_PROTO(ARGS, m, n) PROTO (ARGS) __attribute__ ((format (__printf__, m, n)))
130	#else
131	# include <varargs.h>
132	# define VA_START(va_list, var) va_start (va_list)
133	# define PRINTF_ALIST(msg) msg, va_alist
134	# define PRINTF_DCL(msg) char *msg; va_dcl
135	# define PRINTF_PROTO(ARGS, m, n) () __attribute__ ((format (__printf__, m, n)))
136	# define vfprintf(file, msg, args) \
137	{ \
138	char a0 = va_arg(args, char ); \
139	char a1 = va_arg(args, char ); \
140	char a2 = va_arg(args, char ); \
141	char a3 = va_arg(args, char ); \
142	fprintf (file, msg, a0, a1, a2, a3); \
143	}
144	#endif
145
146	#define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
147
148	HOST_WIDE_INT parse_c_expression PROTO((char *, int));
149
150	static int yylex PROTO((void));
151	static void yyerror PROTO((char *)) __attribute__ ((noreturn));
152	static HOST_WIDE_INT expression_value;
153	#ifdef TEST_EXP_READER
154	static int expression_signedp;
155	#endif
156
157	static jmp_buf parse_return_error;
158
159	/* Nonzero means count most punctuation as part of a name. */
160	static int keyword_parsing = 0;
161
162	/* Nonzero means do not evaluate this expression.
163	This is a count, since unevaluated expressions can nest. */
164	static int skip_evaluation;
165
166	/* Nonzero means warn if undefined identifiers are evaluated. */
167	static int warn_undef;
168
169	/* some external tables of character types */
170	extern unsigned char is_idstart[], is_idchar[], is_space[];
171
172	/* Flag for -pedantic. */
173	extern int pedantic;
174
175	/* Flag for -traditional. */
176	extern int traditional;
177
178	/* Flag for -lang-c89. */
179	extern int c89;
180
181	#ifndef CHAR_TYPE_SIZE
182	#define CHAR_TYPE_SIZE BITS_PER_UNIT
183	#endif
184
185	#ifndef INT_TYPE_SIZE
186	#define INT_TYPE_SIZE BITS_PER_WORD
187	#endif
188
189	#ifndef LONG_TYPE_SIZE
190	#define LONG_TYPE_SIZE BITS_PER_WORD
191	#endif
192
193	#ifndef WCHAR_TYPE_SIZE
194	#define WCHAR_TYPE_SIZE INT_TYPE_SIZE
195	#endif
196
197	#ifndef MAX_CHAR_TYPE_SIZE
198	#define MAX_CHAR_TYPE_SIZE CHAR_TYPE_SIZE
199	#endif
200
201	#ifndef MAX_INT_TYPE_SIZE
202	#define MAX_INT_TYPE_SIZE INT_TYPE_SIZE
203	#endif
204
205	#ifndef MAX_LONG_TYPE_SIZE
206	#define MAX_LONG_TYPE_SIZE LONG_TYPE_SIZE
207	#endif
208
209	#ifndef MAX_WCHAR_TYPE_SIZE
210	#define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
211	#endif
212
213	#define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
214	? (~ (~ (HOST_WIDE_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
215	: ~ (HOST_WIDE_INT) 0)
216
217	#define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
218	? ~ (~ (HOST_WIDE_INT) 0 << MAX_WCHAR_TYPE_SIZE) \
219	: ~ (HOST_WIDE_INT) 0)
220
221	/* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
222	Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
223	Suppose SIGNEDP is negative if the result is signed, zero if unsigned.
224	Then this yields nonzero if overflow occurred during the addition.
225	Overflow occurs if A and B have the same sign, but A and SUM differ in sign,
226	and SIGNEDP is negative.
227	Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
228	#define overflow_sum_sign(a, b, sum, signedp) \
229	((~((a) ^ (b)) & ((a) ^ (sum)) & (signedp)) < 0)
230
231	struct constant;
232
233	GENERIC_PTR xmalloc PROTO((size_t));
234	HOST_WIDE_INT parse_escape PROTO((char **, HOST_WIDE_INT));
235	int check_assertion PROTO((U_CHAR , int, int, struct arglist ));
236	struct hashnode lookup PROTO((U_CHAR , int, int));
237	void error PRINTF_PROTO_1((char *, ...));
238	void pedwarn PRINTF_PROTO_1((char *, ...));
239	void warning PRINTF_PROTO_1((char *, ...));
240
241	static int parse_number PROTO((int));
242	static HOST_WIDE_INT left_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
243	static HOST_WIDE_INT right_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
244	static void integer_overflow PROTO((void));
245
246	/* `signedp' values */
247	#define SIGNED (~0)
248	#define UNSIGNED 0
249	%}
250
251	%union {
252	struct constant {HOST_WIDE_INT value; int signedp;} integer;
253	struct name {U_CHAR *address; int length;} name;
254	struct arglist *keywords;
255	}
256
257	%type <integer> exp exp1 start
258	%type <keywords> keywords
259	%token <integer> INT CHAR
260	%token <name> NAME
261	%token <integer> ERROR
262
263	%right '?' ':'
264	%left ','
265	%left OR
266	%left AND
267	%left '\|'
268	%left '^'
269	%left '&'
270	%left EQUAL NOTEQUAL
271	%left '<' '>' LEQ GEQ
272	%left LSH RSH
273	%left '+' '-'
274	%left '*' '/' '%'
275	%right UNARY
276
277	/* %expect 40 */
278
279	%%
280
281	start : exp1
282	{
283	expression_value = $1.value;
284	#ifdef TEST_EXP_READER
285	expression_signedp = $1.signedp;
286	#endif
287	}
288	;
289
290	/* Expressions, including the comma operator. */
291	exp1 : exp
292	\| exp1 ',' exp
293	{ if (pedantic)
294	pedwarn ("comma operator in operand of `#if'");
295	$$ = $3; }
296	;
297
298	/* Expressions, not including the comma operator. */
299	exp : '-' exp %prec UNARY
300	{ $$.value = - $2.value;
301	$$.signedp = $2.signedp;
302	if (($$.value & $2.value & $$.signedp) < 0)
303	integer_overflow (); }
304	\| '!' exp %prec UNARY
305	{ $$.value = ! $2.value;
306	$$.signedp = SIGNED; }
307	\| '+' exp %prec UNARY
308	{ $$ = $2; }
309	\| '~' exp %prec UNARY
310	{ $$.value = ~ $2.value;
311	$$.signedp = $2.signedp; }
312	\| '#' NAME
313	{ $$.value = check_assertion ($2.address, $2.length,
314	0, NULL_PTR);
315	$$.signedp = SIGNED; }
316	\| '#' NAME
317	{ keyword_parsing = 1; }
318	'(' keywords ')'
319	{ $$.value = check_assertion ($2.address, $2.length,
320	1, $5);
321	keyword_parsing = 0;
322	$$.signedp = SIGNED; }
323	\| '(' exp1 ')'
324	{ $$ = $2; }
325	;
326
327	/* Binary operators in order of decreasing precedence. */
328	exp : exp '*' exp
329	{ $$.signedp = $1.signedp & $3.signedp;
330	if ($$.signedp)
331	{
332	$$.value = $1.value * $3.value;
333	if ($1.value
334	&& ($$.value / $1.value != $3.value
335	\|\| ($$.value & $1.value & $3.value) < 0))
336	integer_overflow ();
337	}
338	else
339	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
340	* $3.value); }
341	\| exp '/' exp
342	{ if ($3.value == 0)
343	{
344	if (!skip_evaluation)
345	error ("division by zero in #if");
346	$3.value = 1;
347	}
348	$$.signedp = $1.signedp & $3.signedp;
349	if ($$.signedp)
350	{
351	$$.value = $1.value / $3.value;
352	if (($$.value & $1.value & $3.value) < 0)
353	integer_overflow ();
354	}
355	else
356	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
357	/ $3.value); }
358	\| exp '%' exp
359	{ if ($3.value == 0)
360	{
361	if (!skip_evaluation)
362	error ("division by zero in #if");
363	$3.value = 1;
364	}
365	$$.signedp = $1.signedp & $3.signedp;
366	if ($$.signedp)
367	$$.value = $1.value % $3.value;
368	else
369	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
370	% $3.value); }
371	\| exp '+' exp
372	{ $$.value = $1.value + $3.value;
373	$$.signedp = $1.signedp & $3.signedp;
374	if (overflow_sum_sign ($1.value, $3.value,
375	$$.value, $$.signedp))
376	integer_overflow (); }
377	\| exp '-' exp
378	{ $$.value = $1.value - $3.value;
379	$$.signedp = $1.signedp & $3.signedp;
380	if (overflow_sum_sign ($$.value, $3.value,
381	$1.value, $$.signedp))
382	integer_overflow (); }
383	\| exp LSH exp
384	{ $$.signedp = $1.signedp;
385	if (($3.value & $3.signedp) < 0)
386	$$.value = right_shift (&$1, -$3.value);
387	else
388	$$.value = left_shift (&$1, $3.value); }
389	\| exp RSH exp
390	{ $$.signedp = $1.signedp;
391	if (($3.value & $3.signedp) < 0)
392	$$.value = left_shift (&$1, -$3.value);
393	else
394	$$.value = right_shift (&$1, $3.value); }
395	\| exp EQUAL exp
396	{ $$.value = ($1.value == $3.value);
397	$$.signedp = SIGNED; }
398	\| exp NOTEQUAL exp
399	{ $$.value = ($1.value != $3.value);
400	$$.signedp = SIGNED; }
401	\| exp LEQ exp
402	{ $$.signedp = SIGNED;
403	if ($1.signedp & $3.signedp)
404	$$.value = $1.value <= $3.value;
405	else
406	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
407	<= $3.value); }
408	\| exp GEQ exp
409	{ $$.signedp = SIGNED;
410	if ($1.signedp & $3.signedp)
411	$$.value = $1.value >= $3.value;
412	else
413	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
414	>= $3.value); }
415	\| exp '<' exp
416	{ $$.signedp = SIGNED;
417	if ($1.signedp & $3.signedp)
418	$$.value = $1.value < $3.value;
419	else
420	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
421	< $3.value); }
422	\| exp '>' exp
423	{ $$.signedp = SIGNED;
424	if ($1.signedp & $3.signedp)
425	$$.value = $1.value > $3.value;
426	else
427	$$.value = ((unsigned_HOST_WIDE_INT) $1.value
428	> $3.value); }
429	\| exp '&' exp
430	{ $$.value = $1.value & $3.value;
431	$$.signedp = $1.signedp & $3.signedp; }
432	\| exp '^' exp
433	{ $$.value = $1.value ^ $3.value;
434	$$.signedp = $1.signedp & $3.signedp; }
435	\| exp '\|' exp
436	{ $$.value = $1.value \| $3.value;
437	$$.signedp = $1.signedp & $3.signedp; }
438	\| exp AND
439	{ skip_evaluation += !$1.value; }
440	exp
441	{ skip_evaluation -= !$1.value;
442	$$.value = ($1.value && $4.value);
443	$$.signedp = SIGNED; }
444	\| exp OR
445	{ skip_evaluation += !!$1.value; }
446	exp
447	{ skip_evaluation -= !!$1.value;
448	$$.value = ($1.value \|\| $4.value);
449	$$.signedp = SIGNED; }
450	\| exp '?'
451	{ skip_evaluation += !$1.value; }
452	exp ':'
453	{ skip_evaluation += !!$1.value - !$1.value; }
454	exp
455	{ skip_evaluation -= !!$1.value;
456	$$.value = $1.value ? $4.value : $7.value;
457	$$.signedp = $4.signedp & $7.signedp; }
458	\| INT
459	{ $$ = yylval.integer; }
460	\| CHAR
461	{ $$ = yylval.integer; }
462	\| NAME
463	{ if (warn_undef && !skip_evaluation)
464	warning ("`%.*s' is not defined",
465	$1.length, $1.address);
466	$$.value = 0;
467	$$.signedp = SIGNED; }
468	;
469
470	keywords :
471	{ $$ = 0; }
472	\| '(' keywords ')' keywords
473	{ struct arglist *temp;
474	$$ = (struct arglist *) xmalloc (sizeof (struct arglist));
475	$$->next = $2;
476	$$->name = (U_CHAR *) "(";
477	$$->length = 1;
478	temp = $$;
479	while (temp != 0 && temp->next != 0)
480	temp = temp->next;
481	temp->next = (struct arglist *) xmalloc (sizeof (struct arglist));
482	temp->next->next = $4;
483	temp->next->name = (U_CHAR *) ")";
484	temp->next->length = 1; }
485	\| NAME keywords
486	{ $$ = (struct arglist *) xmalloc (sizeof (struct arglist));
487	$$->name = $1.address;
488	$$->length = $1.length;
489	$$->next = $2; }
490	;
491	%%
492
493	/* During parsing of a C expression, the pointer to the next character
494	is in this variable. */
495
496	static char *lexptr;
497
498	/* Take care of parsing a number (anything that starts with a digit).
499	Set yylval and return the token type; update lexptr.
500	LEN is the number of characters in it. */
501
502	/* maybe needs to actually deal with floating point numbers */
503
504	static int
505	parse_number (olen)
506	int olen;
507	{
508	register char *p = lexptr;
509	register int c;
510	register unsigned_HOST_WIDE_INT n = 0, nd, max_over_base;
511	register int base = 10;
512	register int len = olen;
513	register int overflow = 0;
514	register int digit, largest_digit = 0;
515	int spec_long = 0;
516
517	yylval.integer.signedp = SIGNED;
518
519	if (*p == '0') {
520	base = 8;
521	if (len >= 3 && (p[1] == 'x' \|\| p[1] == 'X')) {
522	p += 2;
523	base = 16;
524	len -= 2;
525	}
526	}
527
528	max_over_base = (unsigned_HOST_WIDE_INT) -1 / base;
529
530	for (; len > 0; len--) {
531	c = *p++;
532
533	if (c >= '0' && c <= '9')
534	digit = c - '0';
535	else if (base == 16 && c >= 'a' && c <= 'f')
536	digit = c - 'a' + 10;
537	else if (base == 16 && c >= 'A' && c <= 'F')
538	digit = c - 'A' + 10;
539	else {
540	/* `l' means long, and `u' means unsigned. */
541	while (1) {
542	if (c == 'l' \|\| c == 'L')
543	{
544	if (!pedantic < spec_long)
545	yyerror ("too many `l's in integer constant");
546	spec_long++;
547	}
548	else if (c == 'u' \|\| c == 'U')
549	{
550	if (! yylval.integer.signedp)
551	yyerror ("two `u's in integer constant");
552	yylval.integer.signedp = UNSIGNED;
553	}
554	else {
555	if (c == '.' \|\| c == 'e' \|\| c == 'E' \|\| c == 'p' \|\| c == 'P')
556	yyerror ("Floating point numbers not allowed in #if expressions");
557	else {
558	char buf = (char ) alloca (p - lexptr + 40);
559	sprintf (buf, "missing white space after number `%.*s'",
560	(int) (p - lexptr - 1), lexptr);
561	yyerror (buf);
562	}
563	}
564
565	if (--len == 0)
566	break;
567	c = *p++;
568	}
569	/* Don't look for any more digits after the suffixes. */
570	break;
571	}
572	if (largest_digit < digit)
573	largest_digit = digit;
574	nd = n * base + digit;
575	overflow \|= (max_over_base < n) \| (nd < n);
576	n = nd;
577	}
578
579	if (base <= largest_digit)
580	pedwarn ("integer constant contains digits beyond the radix");
581
582	if (overflow)
583	pedwarn ("integer constant out of range");
584
585	/* If too big to be signed, consider it unsigned. */
586	if (((HOST_WIDE_INT) n & yylval.integer.signedp) < 0)
587	{
588	if (base == 10)
589	warning ("integer constant is so large that it is unsigned");
590	yylval.integer.signedp = UNSIGNED;
591	}
592
593	lexptr = p;
594	yylval.integer.value = n;
595	return INT;
596	}
597
598	struct token {
599	char *operator;
600	int token;
601	};
602
603	static struct token tokentab2[] = {
604	{"&&", AND},
605	{"\|\|", OR},
606	{"<<", LSH},
607	{">>", RSH},
608	{"==", EQUAL},
609	{"!=", NOTEQUAL},
610	{"<=", LEQ},
611	{">=", GEQ},
612	{"++", ERROR},
613	{"--", ERROR},
614	{NULL, ERROR}
615	};
616
617	/* Read one token, getting characters through lexptr. */
618
619	static int
620	yylex ()
621	{
622	register int c;
623	register int namelen;
624	register unsigned char *tokstart;
625	register struct token *toktab;
626	int wide_flag;
627	HOST_WIDE_INT mask;
628
629	retry:
630
631	tokstart = (unsigned char *) lexptr;
632	c = *tokstart;
633	/* See if it is a special token of length 2. */
634	if (! keyword_parsing)
635	for (toktab = tokentab2; toktab->operator != NULL; toktab++)
636	if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
637	lexptr += 2;
638	if (toktab->token == ERROR)
639	{
640	char buf = (char ) alloca (40);
641	sprintf (buf, "`%s' not allowed in operand of `#if'", toktab->operator);
642	yyerror (buf);
643	}
644	return toktab->token;
645	}
646
647	switch (c) {
648	case '\n':
649	return 0;
650
651	case ' ':
652	case '\t':
653	case '\r':
654	lexptr++;
655	goto retry;
656
657	case 'L':
658	/* Capital L may start a wide-string or wide-character constant. */
659	if (lexptr[1] == '\'')
660	{
661	lexptr++;
662	wide_flag = 1;
663	mask = MAX_WCHAR_TYPE_MASK;
664	goto char_constant;
665	}
666	if (lexptr[1] == '"')
667	{
668	lexptr++;
669	wide_flag = 1;
670	mask = MAX_WCHAR_TYPE_MASK;
671	goto string_constant;
672	}
673	break;
674
675	case '\'':
676	wide_flag = 0;
677	mask = MAX_CHAR_TYPE_MASK;
678	char_constant:
679	lexptr++;
680	if (keyword_parsing) {
681	char *start_ptr = lexptr - 1;
682	while (1) {
683	c = *lexptr++;
684	if (c == '\\')
685	c = parse_escape (&lexptr, mask);
686	else if (c == '\'')
687	break;
688	}
689	yylval.name.address = tokstart;
690	yylval.name.length = lexptr - start_ptr;
691	return NAME;
692	}
693
694	/* This code for reading a character constant
695	handles multicharacter constants and wide characters.
696	It is mostly copied from c-lex.c. */
697	{
698	register HOST_WIDE_INT result = 0;
699	register int num_chars = 0;
700	unsigned width = MAX_CHAR_TYPE_SIZE;
701	int max_chars;
702	char *token_buffer;
703
704	if (wide_flag)
705	{
706	width = MAX_WCHAR_TYPE_SIZE;
707	#ifdef MULTIBYTE_CHARS
708	max_chars = MB_CUR_MAX;
709	#else
710	max_chars = 1;
711	#endif
712	}
713	else
714	max_chars = MAX_LONG_TYPE_SIZE / width;
715
716	token_buffer = (char *) alloca (max_chars + 1);
717
718	while (1)
719	{
720	c = *lexptr++;
721
722	if (c == '\'' \|\| c == EOF)
723	break;
724
725	if (c == '\\')
726	{
727	c = parse_escape (&lexptr, mask);
728	}
729
730	num_chars++;
731
732	/* Merge character into result; ignore excess chars. */
733	if (num_chars <= max_chars)
734	{
735	if (width < HOST_BITS_PER_WIDE_INT)
736	result = (result << width) \| c;
737	else
738	result = c;
739	token_buffer[num_chars - 1] = c;
740	}
741	}
742
743	token_buffer[num_chars] = 0;
744
745	if (c != '\'')
746	error ("malformatted character constant");
747	else if (num_chars == 0)
748	error ("empty character constant");
749	else if (num_chars > max_chars)
750	{
751	num_chars = max_chars;
752	error ("character constant too long");
753	}
754	else if (num_chars != 1 && ! traditional)
755	warning ("multi-character character constant");
756
757	/* If char type is signed, sign-extend the constant. */
758	if (! wide_flag)
759	{
760	int num_bits = num_chars * width;
761
762	if (lookup ((U_CHAR *) "__CHAR_UNSIGNED__",
763	sizeof ("__CHAR_UNSIGNED__") - 1, -1)
764	\|\| ((result >> (num_bits - 1)) & 1) == 0)
765	yylval.integer.value
766	= result & (~ (unsigned_HOST_WIDE_INT) 0
767	>> (HOST_BITS_PER_WIDE_INT - num_bits));
768	else
769	yylval.integer.value
770	= result \| ~(~ (unsigned_HOST_WIDE_INT) 0
771	>> (HOST_BITS_PER_WIDE_INT - num_bits));
772	}
773	else
774	{
775	#ifdef MULTIBYTE_CHARS
776	/* Set the initial shift state and convert the next sequence. */
777	result = 0;
778	/* In all locales L'\0' is zero and mbtowc will return zero,
779	so don't use it. */
780	if (num_chars > 1
781	\|\| (num_chars == 1 && token_buffer[0] != '\0'))
782	{
783	wchar_t wc;
784	(void) mbtowc (NULL_PTR, NULL_PTR, 0);
785	if (mbtowc (& wc, token_buffer, num_chars) == num_chars)
786	result = wc;
787	else
788	pedwarn ("Ignoring invalid multibyte character");
789	}
790	#endif
791	yylval.integer.value = result;
792	}
793	}
794
795	/* This is always a signed type. */
796	yylval.integer.signedp = SIGNED;
797
798	return CHAR;
799
800	/* some of these chars are invalid in constant expressions;
801	maybe do something about them later */
802	case '/':
803	case '+':
804	case '-':
805	case '*':
806	case '%':
807	case '\|':
808	case '&':
809	case '^':
810	case '~':
811	case '!':
812	case '@':
813	case '<':
814	case '>':
815	case '[':
816	case ']':
817	case '.':
818	case '?':
819	case ':':
820	case '=':
821	case '{':
822	case '}':
823	case ',':
824	case '#':
825	if (keyword_parsing)
826	break;
827	case '(':
828	case ')':
829	lexptr++;
830	return c;
831
832	case '"':
833	mask = MAX_CHAR_TYPE_MASK;
834	string_constant:
835	if (keyword_parsing) {
836	char *start_ptr = lexptr;
837	lexptr++;
838	while (1) {
839	c = *lexptr++;
840	if (c == '\\')
841	c = parse_escape (&lexptr, mask);
842	else if (c == '"')
843	break;
844	}
845	yylval.name.address = tokstart;
846	yylval.name.length = lexptr - start_ptr;
847	return NAME;
848	}
849	yyerror ("string constants not allowed in #if expressions");
850	return ERROR;
851	}
852
853	if (c >= '0' && c <= '9' && !keyword_parsing) {
854	/* It's a number */
855	for (namelen = 1; ; namelen++) {
856	int d = tokstart[namelen];
857	if (! ((is_idchar[d] \|\| d == '.')
858	\|\| ((d == '-' \|\| d == '+')
859	&& (c == 'e' \|\| c == 'E'
860	\|\| ((c == 'p' \|\| c == 'P') && ! c89))
861	&& ! traditional)))
862	break;
863	c = d;
864	}
865	return parse_number (namelen);
866	}
867
868	/* It is a name. See how long it is. */
869
870	if (keyword_parsing) {
871	for (namelen = 0;; namelen++) {
872	if (is_space[tokstart[namelen]])
873	break;
874	if (tokstart[namelen] == '(' \|\| tokstart[namelen] == ')')
875	break;
876	if (tokstart[namelen] == '"' \|\| tokstart[namelen] == '\'')
877	break;
878	}
879	} else {
880	if (!is_idstart[c]) {
881	yyerror ("Invalid token in expression");
882	return ERROR;
883	}
884
885	for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
886	;
887	}
888
889	lexptr += namelen;
890	yylval.name.address = tokstart;
891	yylval.name.length = namelen;
892	return NAME;
893	}
894
895
896	/* Parse a C escape sequence. STRING_PTR points to a variable
897	containing a pointer to the string to parse. That pointer
898	is updated past the characters we use. The value of the
899	escape sequence is returned.
900
901	RESULT_MASK is used to mask out the result;
902	an error is reported if bits are lost thereby.
903
904	A negative value means the sequence \ newline was seen,
905	which is supposed to be equivalent to nothing at all.
906
907	If \ is followed by a null character, we return a negative
908	value and leave the string pointer pointing at the null character.
909
910	If \ is followed by 000, we return 0 and leave the string pointer
911	after the zeros. A value of 0 does not mean end of string. */
912
913	HOST_WIDE_INT
914	parse_escape (string_ptr, result_mask)
915	char **string_ptr;
916	HOST_WIDE_INT result_mask;
917	{
918	register int c = (string_ptr)++;
919	switch (c)
920	{
921	case 'a':
922	return TARGET_BELL;
923	case 'b':
924	return TARGET_BS;
925	case 'e':
926	case 'E':
927	if (pedantic)
928	pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
929	return 033;
930	case 'f':
931	return TARGET_FF;
932	case 'n':
933	return TARGET_NEWLINE;
934	case 'r':
935	return TARGET_CR;
936	case 't':
937	return TARGET_TAB;
938	case 'v':
939	return TARGET_VT;
940	case '\n':
941	return -2;
942	case 0:
943	(*string_ptr)--;
944	return 0;
945
946	case '0':
947	case '1':
948	case '2':
949	case '3':
950	case '4':
951	case '5':
952	case '6':
953	case '7':
954	{
955	register HOST_WIDE_INT i = c - '0';
956	register int count = 0;
957	while (++count < 3)
958	{
959	c = (string_ptr)++;
960	if (c >= '0' && c <= '7')
961	i = (i << 3) + c - '0';
962	else
963	{
964	(*string_ptr)--;
965	break;
966	}
967	}
968	if (i != (i & result_mask))
969	{
970	i &= result_mask;
971	pedwarn ("octal escape sequence out of range");
972	}
973	return i;
974	}
975	case 'x':
976	{
977	register unsigned_HOST_WIDE_INT i = 0, overflow = 0;
978	register int digits_found = 0, digit;
979	for (;;)
980	{
981	c = (string_ptr)++;
982	if (c >= '0' && c <= '9')
983	digit = c - '0';
984	else if (c >= 'a' && c <= 'f')
985	digit = c - 'a' + 10;
986	else if (c >= 'A' && c <= 'F')
987	digit = c - 'A' + 10;
988	else
989	{
990	(*string_ptr)--;
991	break;
992	}
993	overflow \|= i ^ (i << 4 >> 4);
994	i = (i << 4) + digit;
995	digits_found = 1;
996	}
997	if (!digits_found)
998	yyerror ("\\x used with no following hex digits");
999	if (overflow \| (i != (i & result_mask)))
1000	{
1001	i &= result_mask;
1002	pedwarn ("hex escape sequence out of range");
1003	}
1004	return i;
1005	}
1006	default:
1007	return c;
1008	}
1009	}
1010
1011	static void
1012	yyerror (s)
1013	char *s;
1014	{
1015	error ("%s", s);
1016	skip_evaluation = 0;
1017	longjmp (parse_return_error, 1);
1018	}
1019
1020	static void
1021	integer_overflow ()
1022	{
1023	if (!skip_evaluation && pedantic)
1024	pedwarn ("integer overflow in preprocessor expression");
1025	}
1026
1027	static HOST_WIDE_INT
1028	left_shift (a, b)
1029	struct constant *a;
1030	unsigned_HOST_WIDE_INT b;
1031	{
1032	/* It's unclear from the C standard whether shifts can overflow.
1033	The following code ignores overflow; perhaps a C standard
1034	interpretation ruling is needed. */
1035	if (b >= HOST_BITS_PER_WIDE_INT)
1036	return 0;
1037	else
1038	return (unsigned_HOST_WIDE_INT) a->value << b;
1039	}
1040
1041	static HOST_WIDE_INT
1042	right_shift (a, b)
1043	struct constant *a;
1044	unsigned_HOST_WIDE_INT b;
1045	{
1046	if (b >= HOST_BITS_PER_WIDE_INT)
1047	return a->signedp ? a->value >> (HOST_BITS_PER_WIDE_INT - 1) : 0;
1048	else if (a->signedp)
1049	return a->value >> b;
1050	else
1051	return (unsigned_HOST_WIDE_INT) a->value >> b;
1052	}
1053
1054	/* This page contains the entry point to this file. */
1055
1056	/* Parse STRING as an expression, and complain if this fails
1057	to use up all of the contents of STRING.
1058	STRING may contain '\0' bytes; it is terminated by the first '\n'
1059	outside a string constant, so that we can diagnose '\0' properly.
1060	If WARN_UNDEFINED is nonzero, warn if undefined identifiers are evaluated.
1061	We do not support C comments. They should be removed before
1062	this function is called. */
1063
1064	HOST_WIDE_INT
1065	parse_c_expression (string, warn_undefined)
1066	char *string;
1067	int warn_undefined;
1068	{
1069	lexptr = string;
1070	warn_undef = warn_undefined;
1071
1072	/* if there is some sort of scanning error, just return 0 and assume
1073	the parsing routine has printed an error message somewhere.
1074	there is surely a better thing to do than this. */
1075	if (setjmp (parse_return_error))
1076	return 0;
1077
1078	if (yyparse () != 0)
1079	abort ();
1080
1081	if (*lexptr != '\n')
1082	error ("Junk after end of expression.");
1083
1084	return expression_value; /* set by yyparse () */
1085	}
1086
1087	#ifdef TEST_EXP_READER
1088
1089	#if YYDEBUG
1090	extern int yydebug;
1091	#endif
1092
1093	int pedantic;
1094	int traditional;
1095
1096	int main PROTO((int, char **));
1097	static void initialize_random_junk PROTO((void));
1098	static void print_unsigned_host_wide_int PROTO((unsigned_HOST_WIDE_INT));
1099
1100	/* Main program for testing purposes. */
1101	int
1102	main (argc, argv)
1103	int argc;
1104	char **argv;
1105	{
1106	int n, c;
1107	char buf[1024];
1108	unsigned_HOST_WIDE_INT u;
1109
1110	pedantic = 1 < argc;
1111	traditional = 2 < argc;
1112	#if YYDEBUG
1113	yydebug = 3 < argc;
1114	#endif
1115	initialize_random_junk ();
1116
1117	for (;;) {
1118	printf ("enter expression: ");
1119	n = 0;
1120	while ((buf[n] = c = getchar ()) != '\n' && c != EOF)
1121	n++;
1122	if (c == EOF)
1123	break;
1124	parse_c_expression (buf, 1);
1125	printf ("parser returned ");
1126	u = (unsigned_HOST_WIDE_INT) expression_value;
1127	if (expression_value < 0 && expression_signedp) {
1128	u = -u;
1129	printf ("-");
1130	}
1131	if (u == 0)
1132	printf ("0");
1133	else
1134	print_unsigned_host_wide_int (u);
1135	if (! expression_signedp)
1136	printf("u");
1137	printf ("\n");
1138	}
1139
1140	return 0;
1141	}
1142
1143	static void
1144	print_unsigned_host_wide_int (u)
1145	unsigned_HOST_WIDE_INT u;
1146	{
1147	if (u) {
1148	print_unsigned_host_wide_int (u / 10);
1149	putchar ('0' + (int) (u % 10));
1150	}
1151	}
1152
1153	/* table to tell if char can be part of a C identifier. */
1154	unsigned char is_idchar[256];
1155	/* table to tell if char can be first char of a c identifier. */
1156	unsigned char is_idstart[256];
1157	/* table to tell if c is horizontal or vertical space. */
1158	unsigned char is_space[256];
1159
1160	/*
1161	* initialize random junk in the hash table and maybe other places
1162	*/
1163	static void
1164	initialize_random_junk ()
1165	{
1166	register int i;
1167
1168	/*
1169	* Set up is_idchar and is_idstart tables. These should be
1170	* faster than saying (is_alpha (c) \|\| c == '_'), etc.
1171	* Must do set up these things before calling any routines tthat
1172	* refer to them.
1173	*/
1174	for (i = 'a'; i <= 'z'; i++) {
1175	++is_idchar[i - 'a' + 'A'];
1176	++is_idchar[i];
1177	++is_idstart[i - 'a' + 'A'];
1178	++is_idstart[i];
1179	}
1180	for (i = '0'; i <= '9'; i++)
1181	++is_idchar[i];
1182	++is_idchar['_'];
1183	++is_idstart['_'];
1184	++is_idchar['$'];
1185	++is_idstart['$'];
1186
1187	++is_space[' '];
1188	++is_space['\t'];
1189	++is_space['\v'];
1190	++is_space['\f'];
1191	++is_space['\n'];
1192	++is_space['\r'];
1193	}
1194
1195	void
1196	error (PRINTF_ALIST (msg))
1197	PRINTF_DCL (msg)
1198	{
1199	va_list args;
1200
1201	VA_START (args, msg);
1202	fprintf (stderr, "error: ");
1203	vfprintf (stderr, msg, args);
1204	fprintf (stderr, "\n");
1205	va_end (args);
1206	}
1207
1208	void
1209	pedwarn (PRINTF_ALIST (msg))
1210	PRINTF_DCL (msg)
1211	{
1212	va_list args;
1213
1214	VA_START (args, msg);
1215	fprintf (stderr, "pedwarn: ");
1216	vfprintf (stderr, msg, args);
1217	fprintf (stderr, "\n");
1218	va_end (args);
1219	}
1220
1221	void
1222	warning (PRINTF_ALIST (msg))
1223	PRINTF_DCL (msg)
1224	{
1225	va_list args;
1226
1227	VA_START (args, msg);
1228	fprintf (stderr, "warning: ");
1229	vfprintf (stderr, msg, args);
1230	fprintf (stderr, "\n");
1231	va_end (args);
1232	}
1233
1234	int
1235	check_assertion (name, sym_length, tokens_specified, tokens)
1236	U_CHAR *name;
1237	int sym_length;
1238	int tokens_specified;
1239	struct arglist *tokens;
1240	{
1241	return 0;
1242	}
1243
1244	struct hashnode *
1245	lookup (name, len, hash)
1246	U_CHAR *name;
1247	int len;
1248	int hash;
1249	{
1250	return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
1251	}
1252
1253	GENERIC_PTR
1254	xmalloc (size)
1255	size_t size;
1256	{
1257	return (GENERIC_PTR) malloc (size);
1258	}
1259	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format