1/* C global declaration parser for genksyms. 2 Copyright 1996, 1997 Linux International. 3 4 New implementation contributed by Richard Henderson <rth@tamu.edu> 5 Based on original work by Bjorn Ekwall <bj0rn@blox.se> 6 7 This file is part of the Linux modutils. 8 9 This program is free software; you can redistribute it and/or modify it 10 under the terms of the GNU General Public License as published by the 11 Free Software Foundation; either version 2 of the License, or (at your 12 option) any later version. 13 14 This program is distributed in the hope that it will be useful, but 15 WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software Foundation, 21 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23 24%{ 25 26#include <assert.h> 27#include <malloc.h> 28#include "genksyms.h" 29 30static int is_typedef; 31static int is_extern; 32static char *current_name; 33static struct string_list *decl_spec; 34 35static void yyerror(const char *); 36 37static inline void 38remove_node(struct string_list **p) 39{ 40 struct string_list *node = *p; 41 *p = node->next; 42 free_node(node); 43} 44 45static inline void 46remove_list(struct string_list **pb, struct string_list **pe) 47{ 48 struct string_list *b = *pb, *e = *pe; 49 *pb = e; 50 free_list(b, e); 51} 52 53%} 54 55%token ASM_KEYW 56%token ATTRIBUTE_KEYW 57%token AUTO_KEYW 58%token BOOL_KEYW 59%token CHAR_KEYW 60%token CONST_KEYW 61%token DOUBLE_KEYW 62%token ENUM_KEYW 63%token EXTERN_KEYW 64%token FLOAT_KEYW 65%token INLINE_KEYW 66%token INT_KEYW 67%token LONG_KEYW 68%token REGISTER_KEYW 69%token RESTRICT_KEYW 70%token SHORT_KEYW 71%token SIGNED_KEYW 72%token STATIC_KEYW 73%token STRUCT_KEYW 74%token TYPEDEF_KEYW 75%token UNION_KEYW 76%token UNSIGNED_KEYW 77%token VOID_KEYW 78%token VOLATILE_KEYW 79%token TYPEOF_KEYW 80 81%token EXPORT_SYMBOL_KEYW 82 83%token ASM_PHRASE 84%token ATTRIBUTE_PHRASE 85%token BRACE_PHRASE 86%token BRACKET_PHRASE 87%token EXPRESSION_PHRASE 88 89%token CHAR 90%token DOTS 91%token IDENT 92%token INT 93%token REAL 94%token STRING 95%token TYPE 96%token OTHER 97%token FILENAME 98 99%% 100 101declaration_seq: 102 declaration 103 | declaration_seq declaration 104 ; 105 106declaration: 107 { is_typedef = 0; is_extern = 0; current_name = NULL; decl_spec = NULL; } 108 declaration1 109 { free_list(*$2, NULL); *$2 = NULL; } 110 ; 111 112declaration1: 113 TYPEDEF_KEYW { is_typedef = 1; } simple_declaration 114 { $$ = $3; } 115 | simple_declaration 116 | function_definition 117 | asm_definition 118 | export_definition 119 | error ';' { $$ = $2; } 120 | error '}' { $$ = $2; } 121 ; 122 123simple_declaration: 124 decl_specifier_seq_opt init_declarator_list_opt ';' 125 { if (current_name) { 126 struct string_list *decl = (*$3)->next; 127 (*$3)->next = NULL; 128 add_symbol(current_name, 129 is_typedef ? SYM_TYPEDEF : SYM_NORMAL, 130 decl, is_extern); 131 current_name = NULL; 132 } 133 $$ = $3; 134 } 135 ; 136 137init_declarator_list_opt: 138 /* empty */ { $$ = NULL; } 139 | init_declarator_list 140 ; 141 142init_declarator_list: 143 init_declarator 144 { struct string_list *decl = *$1; 145 *$1 = NULL; 146 add_symbol(current_name, 147 is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern); 148 current_name = NULL; 149 $$ = $1; 150 } 151 | init_declarator_list ',' init_declarator 152 { struct string_list *decl = *$3; 153 *$3 = NULL; 154 free_list(*$2, NULL); 155 *$2 = decl_spec; 156 add_symbol(current_name, 157 is_typedef ? SYM_TYPEDEF : SYM_NORMAL, decl, is_extern); 158 current_name = NULL; 159 $$ = $3; 160 } 161 ; 162 163init_declarator: 164 declarator asm_phrase_opt attribute_opt initializer_opt 165 { $$ = $4 ? $4 : $3 ? $3 : $2 ? $2 : $1; } 166 ; 167 168/* Hang on to the specifiers so that we can reuse them. */ 169decl_specifier_seq_opt: 170 /* empty */ { decl_spec = NULL; } 171 | decl_specifier_seq 172 ; 173 174decl_specifier_seq: 175 decl_specifier { decl_spec = *$1; } 176 | decl_specifier_seq decl_specifier { decl_spec = *$2; } 177 ; 178 179decl_specifier: 180 storage_class_specifier 181 { /* Version 2 checksumming ignores storage class, as that 182 is really irrelevant to the linkage. */ 183 remove_node($1); 184 $$ = $1; 185 } 186 | type_specifier 187 ; 188 189storage_class_specifier: 190 AUTO_KEYW 191 | REGISTER_KEYW 192 | STATIC_KEYW 193 | EXTERN_KEYW { is_extern = 1; $$ = $1; } 194 | INLINE_KEYW { is_extern = 0; $$ = $1; } 195 ; 196 197type_specifier: 198 simple_type_specifier 199 | cvar_qualifier 200 | TYPEOF_KEYW '(' decl_specifier_seq '*' ')' 201 | TYPEOF_KEYW '(' decl_specifier_seq ')' 202 203 /* References to s/u/e's defined elsewhere. Rearrange things 204 so that it is easier to expand the definition fully later. */ 205 | STRUCT_KEYW IDENT 206 { remove_node($1); (*$2)->tag = SYM_STRUCT; $$ = $2; } 207 | UNION_KEYW IDENT 208 { remove_node($1); (*$2)->tag = SYM_UNION; $$ = $2; } 209 | ENUM_KEYW IDENT 210 { remove_node($1); (*$2)->tag = SYM_ENUM; $$ = $2; } 211 212 /* Full definitions of an s/u/e. Record it. */ 213 | STRUCT_KEYW IDENT class_body 214 { struct string_list *s = *$3, *i = *$2, *r; 215 r = copy_node(i); r->tag = SYM_STRUCT; 216 r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL; 217 add_symbol(i->string, SYM_STRUCT, s, is_extern); 218 $$ = $3; 219 } 220 | UNION_KEYW IDENT class_body 221 { struct string_list *s = *$3, *i = *$2, *r; 222 r = copy_node(i); r->tag = SYM_UNION; 223 r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL; 224 add_symbol(i->string, SYM_UNION, s, is_extern); 225 $$ = $3; 226 } 227 | ENUM_KEYW IDENT BRACE_PHRASE 228 { struct string_list *s = *$3, *i = *$2, *r; 229 r = copy_node(i); r->tag = SYM_ENUM; 230 r->next = (*$1)->next; *$3 = r; (*$1)->next = NULL; 231 add_symbol(i->string, SYM_ENUM, s, is_extern); 232 $$ = $3; 233 } 234 235 /* Anonymous s/u/e definitions. Nothing needs doing. */ 236 | ENUM_KEYW BRACE_PHRASE { $$ = $2; } 237 | STRUCT_KEYW class_body { $$ = $2; } 238 | UNION_KEYW class_body { $$ = $2; } 239 ; 240 241simple_type_specifier: 242 CHAR_KEYW 243 | SHORT_KEYW 244 | INT_KEYW 245 | LONG_KEYW 246 | SIGNED_KEYW 247 | UNSIGNED_KEYW 248 | FLOAT_KEYW 249 | DOUBLE_KEYW 250 | VOID_KEYW 251 | BOOL_KEYW 252 | TYPE { (*$1)->tag = SYM_TYPEDEF; $$ = $1; } 253 ; 254 255ptr_operator: 256 '*' cvar_qualifier_seq_opt 257 { $$ = $2 ? $2 : $1; } 258 ; 259 260cvar_qualifier_seq_opt: 261 /* empty */ { $$ = NULL; } 262 | cvar_qualifier_seq 263 ; 264 265cvar_qualifier_seq: 266 cvar_qualifier 267 | cvar_qualifier_seq cvar_qualifier { $$ = $2; } 268 ; 269 270cvar_qualifier: 271 CONST_KEYW | VOLATILE_KEYW | ATTRIBUTE_PHRASE 272 | RESTRICT_KEYW 273 { /* restrict has no effect in prototypes so ignore it */ 274 remove_node($1); 275 $$ = $1; 276 } 277 ; 278 279declarator: 280 ptr_operator declarator { $$ = $2; } 281 | direct_declarator 282 ; 283 284direct_declarator: 285 IDENT 286 { if (current_name != NULL) { 287 error_with_pos("unexpected second declaration name"); 288 YYERROR; 289 } else { 290 current_name = (*$1)->string; 291 $$ = $1; 292 } 293 } 294 | direct_declarator '(' parameter_declaration_clause ')' 295 { $$ = $4; } 296 | direct_declarator '(' error ')' 297 { $$ = $4; } 298 | direct_declarator BRACKET_PHRASE 299 { $$ = $2; } 300 | '(' declarator ')' 301 { $$ = $3; } 302 | '(' error ')' 303 { $$ = $3; } 304 ; 305 306/* Nested declarators differ from regular declarators in that they do 307 not record the symbols they find in the global symbol table. */ 308nested_declarator: 309 ptr_operator nested_declarator { $$ = $2; } 310 | direct_nested_declarator 311 ; 312 313direct_nested_declarator: 314 IDENT 315 | TYPE 316 | direct_nested_declarator '(' parameter_declaration_clause ')' 317 { $$ = $4; } 318 | direct_nested_declarator '(' error ')' 319 { $$ = $4; } 320 | direct_nested_declarator BRACKET_PHRASE 321 { $$ = $2; } 322 | '(' nested_declarator ')' 323 { $$ = $3; } 324 | '(' error ')' 325 { $$ = $3; } 326 ; 327 328parameter_declaration_clause: 329 parameter_declaration_list_opt DOTS { $$ = $2; } 330 | parameter_declaration_list_opt 331 | parameter_declaration_list ',' DOTS { $$ = $3; } 332 ; 333 334parameter_declaration_list_opt: 335 /* empty */ { $$ = NULL; } 336 | parameter_declaration_list 337 ; 338 339parameter_declaration_list: 340 parameter_declaration 341 | parameter_declaration_list ',' parameter_declaration 342 { $$ = $3; } 343 ; 344 345parameter_declaration: 346 decl_specifier_seq m_abstract_declarator 347 { $$ = $2 ? $2 : $1; } 348 ; 349 350m_abstract_declarator: 351 ptr_operator m_abstract_declarator 352 { $$ = $2 ? $2 : $1; } 353 | direct_m_abstract_declarator 354 ; 355 356direct_m_abstract_declarator: 357 /* empty */ { $$ = NULL; } 358 | IDENT 359 { /* For version 2 checksums, we don't want to remember 360 private parameter names. */ 361 remove_node($1); 362 $$ = $1; 363 } 364 /* This wasn't really a typedef name but an identifier that 365 shadows one. */ 366 | TYPE 367 { remove_node($1); 368 $$ = $1; 369 } 370 | direct_m_abstract_declarator '(' parameter_declaration_clause ')' 371 { $$ = $4; } 372 | direct_m_abstract_declarator '(' error ')' 373 { $$ = $4; } 374 | direct_m_abstract_declarator BRACKET_PHRASE 375 { $$ = $2; } 376 | '(' m_abstract_declarator ')' 377 { $$ = $3; } 378 | '(' error ')' 379 { $$ = $3; } 380 ; 381 382function_definition: 383 decl_specifier_seq_opt declarator BRACE_PHRASE 384 { struct string_list *decl = *$2; 385 *$2 = NULL; 386 add_symbol(current_name, SYM_NORMAL, decl, is_extern); 387 $$ = $3; 388 } 389 ; 390 391initializer_opt: 392 /* empty */ { $$ = NULL; } 393 | initializer 394 ; 395 396/* We never care about the contents of an initializer. */ 397initializer: 398 '=' EXPRESSION_PHRASE 399 { remove_list($2, &(*$1)->next); $$ = $2; } 400 ; 401 402class_body: 403 '{' member_specification_opt '}' { $$ = $3; } 404 | '{' error '}' { $$ = $3; } 405 ; 406 407member_specification_opt: 408 /* empty */ { $$ = NULL; } 409 | member_specification 410 ; 411 412member_specification: 413 member_declaration 414 | member_specification member_declaration { $$ = $2; } 415 ; 416 417member_declaration: 418 decl_specifier_seq_opt member_declarator_list_opt ';' 419 { $$ = $3; } 420 | error ';' 421 { $$ = $2; } 422 ; 423 424member_declarator_list_opt: 425 /* empty */ { $$ = NULL; } 426 | member_declarator_list 427 ; 428 429member_declarator_list: 430 member_declarator 431 | member_declarator_list ',' member_declarator { $$ = $3; } 432 ; 433 434member_declarator: 435 nested_declarator attribute_opt { $$ = $2 ? $2 : $1; } 436 | IDENT member_bitfield_declarator { $$ = $2; } 437 | member_bitfield_declarator 438 ; 439 440member_bitfield_declarator: 441 ':' EXPRESSION_PHRASE { $$ = $2; } 442 ; 443 444attribute_opt: 445 /* empty */ { $$ = NULL; } 446 | ATTRIBUTE_PHRASE 447 ; 448 449asm_definition: 450 ASM_PHRASE ';' { $$ = $2; } 451 ; 452 453asm_phrase_opt: 454 /* empty */ { $$ = NULL; } 455 | ASM_PHRASE 456 ; 457 458export_definition: 459 EXPORT_SYMBOL_KEYW '(' IDENT ')' ';' 460 { export_symbol((*$3)->string); $$ = $5; } 461 ; 462 463 464%% 465 466static void 467yyerror(const char *e) 468{ 469 error_with_pos("%s", e); 470} 471