1 %
{ /* -*- c -*- emacs mode c */
4 TREELANG Compiler parser.
6 ---------------------------------------------------------------------
8 Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA.
25 In other words, you are welcome to use, share and improve this program.
26 You are forbidden to forbid anyone else to use, share and improve
27 what you give them. Help stamp out software-hoarding!
29 ---------------------------------------------------------------------
31 Written by Tim Josling 1999-2001, based in part on other parts of
41 There are no conflicts in this grammar. Please keep it that way.
45 /* Undefine IN_GCC so malloc etc work. The alternative is to redefine
46 the out of stack routine in bison. */
48 /* Front ends should not have to see these, but config.h needs everything. */
59 #include "diagnostic.h"
65 #define YYPRINT(file, type, value) print_token (file, type, value)
66 #define YYERROR_VERBOSE YES
69 extern
int option_parser_trace
;
71 /* Local prototypes. */
73 static void yyerror (const char *error_message
);
76 void print_token
(FILE * file
, unsigned int type ATTRIBUTE_UNUSED
, YYSTYPE value
);
77 static struct prod_token_parm_item
*reverse_prod_list
(struct prod_token_parm_item
*old_first
);
78 static void ensure_not_void
(unsigned int type
, struct prod_token_parm_item
* name
);
79 static int check_type_match
(int type_num
, struct prod_token_parm_item
*exp
);
80 static int get_common_type
(struct prod_token_parm_item
*type1
, struct prod_token_parm_item
*type2
);
81 static struct prod_token_parm_item
*make_integer_constant
(struct prod_token_parm_item
* value
);
82 static void set_storage
(struct prod_token_parm_item
*prod
);
84 /* File global variables. */
86 static struct prod_token_parm_item
*current_function
=NULL
;
90 /* Not %raw - seems to have bugs. */
96 %token RIGHT_SQUARE_BRACKET
97 %token LEFT_SQUARE_BRACKET
98 %token RIGHT_PARENTHESIS
99 %token LEFT_PARENTHESIS
123 %token EXTERNAL_DEFINITION
124 %token EXTERNAL_REFERENCE
126 /* Tokens not passed to parser. */
130 /* Pseudo tokens - productions. */
131 %token PROD_VARIABLE_NAME
132 %token PROD_TYPE_NAME
133 %token PROD_FUNCTION_NAME
134 %token PROD_INTEGER_CONSTANT
135 %token PROD_PLUS_EXPRESSION
136 %token PROD_MINUS_EXPRESSION
137 %token PROD_ASSIGN_EXPRESSION
138 %token PROD_VARIABLE_REFERENCE_EXPRESSION
139 %token PROD_PARAMETER
140 %token PROD_FUNCTION_INVOCATION
158 | declarations declaration
{
167 |function_prototype
{
176 storage typename NAME init_opt SEMICOLON
{
177 struct prod_token_parm_item
* tok
;
178 struct prod_token_parm_item
*prod
;
180 prod
= make_production
(PROD_VARIABLE_NAME
, tok
);
181 SYMBOL_TABLE_NAME
(prod
) = tok
;
182 EXPRESSION_TYPE
(prod
) = $2;
183 VAR_INIT
(prod
) = $4;
184 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(( (struct prod_token_parm_item
*)EXPRESSION_TYPE
(prod
)));
185 ensure_not_void
(NUMERIC_TYPE
(prod
), tok
);
186 if
(insert_tree_name
(prod
))
190 STORAGE_CLASS_TOKEN
(prod
) = $1;
195 if
(! ((struct prod_token_parm_item
*)VAR_INIT
(prod
))->tp.pro.code
)
197 if
(STORAGE_CLASS
(prod
) == EXTERNAL_REFERENCE_STORAGE
)
199 fprintf
(stderr
, "%s:%i:%i: External reference variables may not have initial value\n", in_fname
,
200 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
201 print_token
(stderr
, 0, tok
);
206 prod
->tp.pro.code
= tree_code_create_variable
207 (STORAGE_CLASS
(prod
),
208 ((struct prod_token_parm_item
*)SYMBOL_TABLE_NAME
(prod
))->tp.tok.chars
,
209 ((struct prod_token_parm_item
*)SYMBOL_TABLE_NAME
(prod
))->tp.tok.length
,
211 VAR_INIT
(prod
)?
((struct prod_token_parm_item
*)VAR_INIT
(prod
))->tp.pro.code
:NULL
,
214 if
(!prod
->tp.pro.code
)
228 struct prod_token_parm_item
* tok
;
229 struct prod_token_parm_item
*prod
;
230 struct prod_token_parm_item
*prod2
;
232 prod
= make_production
(PROD_VARIABLE_NAME
, tok
);
233 SYMBOL_TABLE_NAME
(prod
) = $2;
234 EXPRESSION_TYPE
(prod
) = $1;
235 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(( (struct prod_token_parm_item
*)EXPRESSION_TYPE
(prod
)));
236 ensure_not_void
(NUMERIC_TYPE
(prod
), tok
);
237 if
(insert_tree_name
(prod
))
241 prod2
= make_production
(PROD_PARAMETER
, tok
);
242 VARIABLE
(prod2
) = prod
;
248 storage typename NAME LEFT_PARENTHESIS parameters RIGHT_PARENTHESIS SEMICOLON
{
249 struct prod_token_parm_item
* tok
;
250 struct prod_token_parm_item
*prod
;
251 struct prod_token_parm_item
*type
;
252 struct prod_token_parm_item
* first_parms
;
253 struct prod_token_parm_item
* last_parms
;
254 struct prod_token_parm_item
* this_parms
;
255 struct prod_token_parm_item
*this_parm
;
256 struct prod_token_parm_item
*this_parm_var
;
258 prod
= make_production
(PROD_FUNCTION_NAME
, $3);
259 SYMBOL_TABLE_NAME
(prod
) = $3;
260 EXPRESSION_TYPE
(prod
) = $2;
261 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(( (struct prod_token_parm_item
*)EXPRESSION_TYPE
(prod
)));
262 PARAMETERS
(prod
) = reverse_prod_list
($5);
263 insert_tree_name
(prod
);
264 STORAGE_CLASS_TOKEN
(prod
) = $1;
266 switch
(STORAGE_CLASS
(prod
))
269 case EXTERNAL_DEFINITION_STORAGE
:
272 case AUTOMATIC_STORAGE
:
273 fprintf
(stderr
, "%s:%i:%i: A function cannot be automatic\n", in_fname
,
274 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
275 print_token
(stderr
, 0, tok
);
283 type
= EXPRESSION_TYPE
(prod
);
284 /* Create a parameter list in a non-front end specific format. */
285 for
(first_parms
= NULL
, last_parms
= NULL
, this_parm
= PARAMETERS
(prod
);
287 this_parm
= this_parm
->tp.pro.next
)
289 if
(this_parm
->category
!= production_category
)
291 this_parm_var
= VARIABLE
(this_parm
);
294 if
(this_parm_var
->category
!= production_category
)
296 this_parms
= my_malloc
(sizeof
(struct prod_token_parm_item
));
297 if
(!this_parm_var
->tp.pro.main_token
)
299 this_parms
->tp.par.variable_name
= this_parm_var
->tp.pro.main_token
->tp.tok.chars
;
300 this_parms
->type
= NUMERIC_TYPE
(( (struct prod_token_parm_item
*)EXPRESSION_TYPE
(this_parm_var
)));
303 last_parms
->tp.par.next
= this_parms
;
304 last_parms
= this_parms
;
308 first_parms
= this_parms
;
309 last_parms
= this_parms
;
311 this_parms
->tp.par.where_to_put_var_tree
=
312 & (( (struct prod_token_parm_item
*)VARIABLE
(this_parm
))->tp.pro.code
);
314 FIRST_PARMS
(prod
) = first_parms
;
316 prod
->tp.pro.code
= tree_code_create_function_prototype
317 (tok
->tp.tok.chars
, STORAGE_CLASS
(prod
), NUMERIC_TYPE
(type
),
318 first_parms
, in_fname
, tok
->tp.tok.lineno
);
325 struct prod_token_parm_item
*proto
;
326 struct prod_token_parm_item search_prod
;
327 struct prod_token_parm_item
* tok
;
328 struct prod_token_parm_item
*this_parm
;
330 SYMBOL_TABLE_NAME
((&search_prod
)) = tok
;
331 current_function
= proto
= lookup_tree_name
(&search_prod
);
334 fprintf
(stderr
, "%s:%i:%i: Function prototype not found\n", in_fname
,
335 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
336 print_token
(stderr
, 0, tok
);
340 if
(!proto
->tp.pro.code
)
342 tree_code_create_function_initial
343 (proto
->tp.pro.code
, in_fname
, tok
->tp.tok.lineno
,
344 FIRST_PARMS
(current_function
));
346 /* Check all the parameters have code. */
347 for
(this_parm
= PARAMETERS
(proto
);
349 this_parm
= this_parm
->tp.pro.next
)
351 if
(! (struct prod_token_parm_item
*)VARIABLE
(this_parm
))
353 if
(! (( (struct prod_token_parm_item
*)VARIABLE
(this_parm
))->tp.pro.code
))
357 variable_defs_opt statements_opt RIGHT_BRACE
{
358 struct prod_token_parm_item
* tok
;
360 tree_code_create_function_wrapup
(in_fname
, tok
->tp.tok.lineno
);
361 current_function
= NULL
;
387 |variable_defs variable_def
{
394 struct prod_token_parm_item
* tok
;
395 struct prod_token_parm_item
*prod
;
397 prod
= make_production
(PROD_TYPE_NAME
, tok
);
398 NUMERIC_TYPE
(prod
) = SIGNED_INT
;
399 prod
->tp.pro.code
= tree_code_get_type
(NUMERIC_TYPE
(prod
));
403 struct prod_token_parm_item
* tok
;
404 struct prod_token_parm_item
*prod
;
406 prod
= make_production
(PROD_TYPE_NAME
, tok
);
407 NUMERIC_TYPE
(prod
) = UNSIGNED_INT
;
408 prod
->tp.pro.code
= tree_code_get_type
(NUMERIC_TYPE
(prod
));
412 struct prod_token_parm_item
* tok
;
413 struct prod_token_parm_item
*prod
;
415 prod
= make_production
(PROD_TYPE_NAME
, tok
);
416 NUMERIC_TYPE
(prod
) = SIGNED_CHAR
;
417 prod
->tp.pro.code
= tree_code_get_type
(NUMERIC_TYPE
(prod
));
421 struct prod_token_parm_item
* tok
;
422 struct prod_token_parm_item
*prod
;
424 prod
= make_production
(PROD_TYPE_NAME
, tok
);
425 NUMERIC_TYPE
(prod
) = UNSIGNED_CHAR
;
426 prod
->tp.pro.code
= tree_code_get_type
(NUMERIC_TYPE
(prod
));
430 struct prod_token_parm_item
* tok
;
431 struct prod_token_parm_item
*prod
;
433 prod
= make_production
(PROD_TYPE_NAME
, tok
);
434 NUMERIC_TYPE
(prod
) = VOID_TYPE
;
435 prod
->tp.pro.code
= tree_code_get_type
(NUMERIC_TYPE
(prod
));
445 |parameters COMMA parameter
{
446 struct prod_token_parm_item
*prod1
;
448 prod1
->tp.pro.next
= $1; /* Insert in reverse order. */
457 |statements statement
{
463 expression SEMICOLON
{
464 struct prod_token_parm_item
*exp
;
466 tree_code_output_expression_statement
(exp
->tp.pro.code
, in_fname
, exp
->tp.pro.main_token
->tp.tok.lineno
);
477 IF LEFT_PARENTHESIS expression RIGHT_PARENTHESIS
{
478 struct prod_token_parm_item
* tok
;
479 struct prod_token_parm_item
*exp
;
482 ensure_not_void
(NUMERIC_TYPE
(exp
), exp
->tp.pro.main_token
);
483 tree_code_if_start
(exp
->tp.pro.code
, in_fname
, tok
->tp.tok.lineno
);
485 LEFT_BRACE statements_opt RIGHT_BRACE
{
486 /* Just let the statements flow. */
489 struct prod_token_parm_item
* tok
;
491 tree_code_if_else
(in_fname
, tok
->tp.tok.lineno
);
493 LEFT_BRACE statements_opt RIGHT_BRACE
{
494 struct prod_token_parm_item
* tok
;
496 tree_code_if_end
(in_fname
, tok
->tp.tok.lineno
);
502 RETURN expression_opt
{
503 struct prod_token_parm_item
*type_prod
;
504 struct prod_token_parm_item
* ret_tok
;
506 type_prod
= EXPRESSION_TYPE
(current_function
);
507 if
(NUMERIC_TYPE
(type_prod
) == VOID
)
509 tree_code_generate_return
(type_prod
->tp.pro.code
, NULL
);
512 fprintf
(stderr
, "%s:%i:%i: Redundant expression in return\n", in_fname
,
513 ret_tok
->tp.tok.lineno
, ret_tok
->tp.tok.charno
);
514 print_token
(stderr
, 0, ret_tok
);
516 tree_code_generate_return
(type_prod
->tp.pro.code
, NULL
);
521 fprintf
(stderr
, "%s:%i:%i: Expression missing in return\n", in_fname
,
522 ret_tok
->tp.tok.lineno
, ret_tok
->tp.tok.charno
);
523 print_token
(stderr
, 0, ret_tok
);
528 struct prod_token_parm_item
*exp
;
530 /* Check same type. */
531 if
(check_type_match
(NUMERIC_TYPE
(type_prod
), $2))
533 if
(!type_prod
->tp.pro.code
)
535 if
(!exp
->tp.pro.code
)
537 /* Generate the code. */
538 tree_code_generate_return
(type_prod
->tp.pro.code
, exp
->tp.pro.code
);
549 struct prod_token_parm_item
*exp
;
551 if
(!exp
->tp.pro.code
)
560 $$
= make_integer_constant
($1);
565 |expression PLUS expression
{
566 struct prod_token_parm_item
* tok
;
567 struct prod_token_parm_item
*prod
;
568 struct prod_token_parm_item
*op1
;
569 struct prod_token_parm_item
*op2
;
575 ensure_not_void
(NUMERIC_TYPE
(op1
), op1
->tp.pro.main_token
);
576 ensure_not_void
(NUMERIC_TYPE
(op2
), op2
->tp.pro.main_token
);
577 prod
= make_production
(PROD_PLUS_EXPRESSION
, tok
);
578 NUMERIC_TYPE
(prod
) = get_common_type
(op1
, op2
);
579 if
(!NUMERIC_TYPE
(prod
))
583 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
589 prod
->tp.pro.code
= tree_code_get_expression
590 (EXP_PLUS
, type
, op1
->tp.pro.code
, op2
->tp.pro.code
, NULL
);
594 |expression MINUS expression %prec PLUS
{
595 struct prod_token_parm_item
* tok
;
596 struct prod_token_parm_item
*prod
;
597 struct prod_token_parm_item
*op1
;
598 struct prod_token_parm_item
*op2
;
603 ensure_not_void
(NUMERIC_TYPE
(op1
), op1
->tp.pro.main_token
);
604 ensure_not_void
(NUMERIC_TYPE
(op2
), op2
->tp.pro.main_token
);
606 prod
= make_production
(PROD_PLUS_EXPRESSION
, tok
);
607 NUMERIC_TYPE
(prod
) = get_common_type
(op1
, op2
);
608 if
(!NUMERIC_TYPE
(prod
))
612 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
618 prod
->tp.pro.code
= tree_code_get_expression
(EXP_MINUS
,
619 type
, op1
->tp.pro.code
, op2
->tp.pro.code
, NULL
);
623 |expression EQUALS expression
{
624 struct prod_token_parm_item
* tok
;
625 struct prod_token_parm_item
*prod
;
626 struct prod_token_parm_item
*op1
;
627 struct prod_token_parm_item
*op2
;
632 ensure_not_void
(NUMERIC_TYPE
(op1
), op1
->tp.pro.main_token
);
633 ensure_not_void
(NUMERIC_TYPE
(op2
), op2
->tp.pro.main_token
);
635 prod
= make_production
(PROD_PLUS_EXPRESSION
, tok
);
636 NUMERIC_TYPE
(prod
) = SIGNED_INT
;
637 if
(!NUMERIC_TYPE
(prod
))
641 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
647 prod
->tp.pro.code
= tree_code_get_expression
(EXP_EQUALS
,
648 type
, op1
->tp.pro.code
, op2
->tp.pro.code
, NULL
);
652 |variable_ref ASSIGN expression
{
653 struct prod_token_parm_item
* tok
;
654 struct prod_token_parm_item
*prod
;
655 struct prod_token_parm_item
*op1
;
656 struct prod_token_parm_item
*op2
;
662 ensure_not_void
(NUMERIC_TYPE
(op2
), op2
->tp.pro.main_token
);
663 prod
= make_production
(PROD_ASSIGN_EXPRESSION
, tok
);
664 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(op1
);
665 if
(!NUMERIC_TYPE
(prod
))
669 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
674 prod
->tp.pro.code
= tree_code_get_expression
(EXP_ASSIGN
,
675 type
, op1
->tp.pro.code
, op2
->tp.pro.code
, NULL
);
679 |function_invocation
{
685 NAME LEFT_PARENTHESIS expressions_with_commas RIGHT_PARENTHESIS
{
686 struct prod_token_parm_item
*prod
;
687 struct prod_token_parm_item
* tok
;
688 struct prod_token_parm_item search_prod
;
689 struct prod_token_parm_item
*proto
;
690 struct prod_token_parm_item
*exp
;
691 struct prod_token_parm_item
*exp_proto
;
692 struct prod_token_parm_item
*var
;
699 prod
= make_production
(PROD_FUNCTION_INVOCATION
, tok
);
700 SYMBOL_TABLE_NAME
(prod
) = tok
;
701 PARAMETERS
(prod
) = reverse_prod_list
($3);
702 SYMBOL_TABLE_NAME
((&search_prod
)) = tok
;
703 proto
= lookup_tree_name
(&search_prod
);
706 fprintf
(stderr
, "%s:%i:%i: Function prototype not found\n", in_fname
,
707 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
708 print_token
(stderr
, 0, tok
);
712 EXPRESSION_TYPE
(prod
) = EXPRESSION_TYPE
(proto
);
713 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(proto
);
714 /* Count the expressions and ensure they match the prototype. */
715 for
(exp_proto_count
= 0, exp_proto
= PARAMETERS
(proto
);
716 exp_proto
; exp_proto
= exp_proto
->tp.pro.next
)
719 for
(exp_count
= 0, exp
= PARAMETERS
(prod
); exp
; exp
= exp
->tp.pro.next
)
722 if
(exp_count
!= exp_proto_count
)
724 fprintf
(stderr
, "%s:%i:%i: expression count mismatch with prototype\n", in_fname
,
725 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
726 print_token
(stderr
, 0, tok
);
730 parms
= tree_code_init_parameters
();
731 for
(exp_proto
= PARAMETERS
(proto
), exp
= PARAMETERS
(prod
);
733 exp
= exp
->tp.pro.next
, exp_proto
= exp_proto
->tp.pro.next
)
739 if
(!exp
->tp.pro.code
)
741 var
= VARIABLE
(exp_proto
);
744 if
(!var
->tp.pro.code
)
746 parms
= tree_code_add_parameter
(parms
, var
->tp.pro.code
, exp
->tp.pro.code
);
748 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
749 prod
->tp.pro.code
= tree_code_get_expression
750 (EXP_FUNCTION_INVOCATION
, type
, proto
->tp.pro.code
, parms
, NULL
);
755 expressions_with_commas:
757 struct prod_token_parm_item
*exp
;
759 ensure_not_void
(NUMERIC_TYPE
(exp
), exp
->tp.pro.main_token
);
762 |expressions_with_commas COMMA expression
{
763 struct prod_token_parm_item
*exp
;
765 ensure_not_void
(NUMERIC_TYPE
(exp
), exp
->tp.pro.main_token
);
766 exp
->tp.pro.next
= $1; /* Reverse order. */
773 struct prod_token_parm_item search_prod
;
774 struct prod_token_parm_item
*prod
;
775 struct prod_token_parm_item
*symbol_table_entry
;
776 struct prod_token_parm_item
* tok
;
780 SYMBOL_TABLE_NAME
((&search_prod
)) = tok
;
781 symbol_table_entry
= lookup_tree_name
(&search_prod
);
782 if
(!symbol_table_entry
)
784 fprintf
(stderr
, "%s:%i:%i: Variable referred to but not defined\n", in_fname
,
785 tok
->tp.tok.lineno
, tok
->tp.tok.charno
);
786 print_token
(stderr
, 0, tok
);
791 prod
= make_production
(PROD_VARIABLE_REFERENCE_EXPRESSION
, tok
);
792 NUMERIC_TYPE
(prod
) = NUMERIC_TYPE
(symbol_table_entry
);
793 type
= get_type_for_numeric_type
(NUMERIC_TYPE
(prod
));
794 if
(!NUMERIC_TYPE
(prod
))
798 prod
->tp.pro.code
= tree_code_get_expression
(EXP_REFERENCE
, type
,
799 symbol_table_entry
->tp.pro.code
, NULL
, NULL
);
813 ASSIGN init_element
{
819 $$
= make_integer_constant
($1);
825 /* Print a token VALUE to file FILE. Ignore TYPE which is the token
829 print_token
(FILE * file
, unsigned int type ATTRIBUTE_UNUSED
, YYSTYPE value
)
831 struct prod_token_parm_item
*tok
;
835 fprintf
(file
, "%d \"", tok
->tp.tok.lineno
);
836 for
(ix
= 0; ix
< tok
->tp.tok.length
; ix
++)
837 fprintf
(file
, "%c", tok
->tp.tok.chars
[ix
]);
838 fprintf
(file
, "\"");
841 /* Output a message ERROR_MESSAGE from the parser. */
843 yyerror (const char *error_message
)
845 struct prod_token_parm_item
*tok
;
850 fprintf
(stderr
, "%s:%i:%i: %s\n", in_fname
, tok
->tp.tok.lineno
, tok
->tp.tok.charno
, error_message
);
851 print_token
(stderr
, 0, tok
);
854 fprintf
(stderr
, "%s\n", error_message
);
860 /* Reverse the order of a token list, linked by parse_next, old first
861 token is OLD_FIRST. */
863 static struct prod_token_parm_item
*
864 reverse_prod_list
(struct prod_token_parm_item
*old_first
)
866 struct prod_token_parm_item
*current
;
867 struct prod_token_parm_item
*next
;
868 struct prod_token_parm_item
*prev
= NULL
;
875 if
(current
->category
!= production_category
)
877 next
= current
->tp.pro.next
;
878 current
->tp.pro.next
= prev
;
885 /* Ensure TYPE is not VOID. Use NAME as the token for the error location. */
888 ensure_not_void
(unsigned int type
, struct prod_token_parm_item
* name
)
892 fprintf
(stderr
, "%s:%i:%i: Type must not be void in this context\n", in_fname
,
893 name
->tp.tok.lineno
, name
->tp.tok.charno
);
894 print_token
(stderr
, 0, name
);
899 /* Check TYPE1 and TYPE2 which are integral types. Return the lowest
900 common type (min is signed int). */
903 get_common_type
(struct prod_token_parm_item
*type1
, struct prod_token_parm_item
*type2
)
905 if
(NUMERIC_TYPE
(type1
) == UNSIGNED_INT
)
907 if
(NUMERIC_TYPE
(type2
) == UNSIGNED_INT
)
913 /* Check type (TYPE_NUM) and expression (EXP) match. Return the 1 if
914 OK else 0. Must be exact match - same name unless it is an
918 check_type_match
(int type_num
, struct prod_token_parm_item
*exp
)
926 switch
(NUMERIC_TYPE
(exp
))
951 /* Make a production for an integer constant VALUE. */
953 static struct prod_token_parm_item
*
954 make_integer_constant
(struct prod_token_parm_item
* value
)
956 struct prod_token_parm_item
* tok
;
957 struct prod_token_parm_item
*prod
;
959 prod
= make_production
(PROD_INTEGER_CONSTANT
, tok
);
960 if
((tok
->tp.tok.chars
[0] == (unsigned char)'-')||
(tok
->tp.tok.chars
[0] == (unsigned char)'+'))
961 NUMERIC_TYPE
(prod
) = SIGNED_INT
;
963 NUMERIC_TYPE
(prod
) = UNSIGNED_INT
;
964 prod
->tp.pro.code
= tree_code_get_integer_value
(tok
->tp.tok.chars
, tok
->tp.tok.length
);
968 /* Set STORAGE_CLASS in PROD according to CLASS_TOKEN. */
971 set_storage
(struct prod_token_parm_item
*prod
)
973 struct prod_token_parm_item
* stg_class
;
974 stg_class
= STORAGE_CLASS_TOKEN
(prod
);
975 switch
(stg_class
->type
)
978 STORAGE_CLASS
(prod
) = STATIC_STORAGE
;
982 STORAGE_CLASS
(prod
) = AUTOMATIC_STORAGE
;
985 case EXTERNAL_DEFINITION
:
986 STORAGE_CLASS
(prod
) = EXTERNAL_DEFINITION_STORAGE
;
989 case EXTERNAL_REFERENCE
:
990 STORAGE_CLASS
(prod
) = EXTERNAL_REFERENCE_STORAGE
;
998 /* Set parse trace. */
1001 treelang_debug
(void)
1003 if
(option_parser_trace
)