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