linux/scripts/genksyms/parse.y
<<
>>
Prefs
   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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.