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