LCOV - code coverage report
Current view: top level - gcc/c - c-parser.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 10 10 100.0 %
Date: 2020-03-28 11:57:23 Functions: 0 0 -
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Declarations for the parser for C and Objective-C.
       2                 :            :    Copyright (C) 1987-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    Parser actions based on the old Bison parser; structure somewhat
       5                 :            :    influenced by and fragments based on the C++ parser.
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it under
      10                 :            : the terms of the GNU General Public License as published by the Free
      11                 :            : Software Foundation; either version 3, or (at your option) any later
      12                 :            : version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :            : for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : #ifndef GCC_C_PARSER_H
      24                 :            : #define GCC_C_PARSER_H
      25                 :            : 
      26                 :            : /* The C lexer intermediates between the lexer in cpplib and c-lex.c
      27                 :            :    and the C parser.  Unlike the C++ lexer, the parser structure
      28                 :            :    stores the lexer information instead of using a separate structure.
      29                 :            :    Identifiers are separated into ordinary identifiers, type names,
      30                 :            :    keywords and some other Objective-C types of identifiers, and some
      31                 :            :    look-ahead is maintained.
      32                 :            : 
      33                 :            :    ??? It might be a good idea to lex the whole file up front (as for
      34                 :            :    C++).  It would then be possible to share more of the C and C++
      35                 :            :    lexer code, if desired.  */
      36                 :            : 
      37                 :            : /* More information about the type of a CPP_NAME token.  */
      38                 :            : enum c_id_kind {
      39                 :            :   /* An ordinary identifier.  */
      40                 :            :   C_ID_ID,
      41                 :            :   /* An identifier declared as a typedef name.  */
      42                 :            :   C_ID_TYPENAME,
      43                 :            :   /* An identifier declared as an Objective-C class name.  */
      44                 :            :   C_ID_CLASSNAME,
      45                 :            :   /* An address space identifier.  */
      46                 :            :   C_ID_ADDRSPACE,
      47                 :            :   /* Not an identifier.  */
      48                 :            :   C_ID_NONE
      49                 :            : };
      50                 :            : 
      51                 :            : /* A single C token after string literal concatenation and conversion
      52                 :            :    of preprocessing tokens to tokens.  */
      53                 :            : struct GTY (()) c_token {
      54                 :            :   /* The kind of token.  */
      55                 :            :   ENUM_BITFIELD (cpp_ttype) type : 8;
      56                 :            :   /* If this token is a CPP_NAME, this value indicates whether also
      57                 :            :      declared as some kind of type.  Otherwise, it is C_ID_NONE.  */
      58                 :            :   ENUM_BITFIELD (c_id_kind) id_kind : 8;
      59                 :            :   /* If this token is a keyword, this value indicates which keyword.
      60                 :            :      Otherwise, this value is RID_MAX.  */
      61                 :            :   ENUM_BITFIELD (rid) keyword : 8;
      62                 :            :   /* If this token is a CPP_PRAGMA, this indicates the pragma that
      63                 :            :      was seen.  Otherwise it is PRAGMA_NONE.  */
      64                 :            :   ENUM_BITFIELD (pragma_kind) pragma_kind : 8;
      65                 :            :   /* The location at which this token was found.  */
      66                 :            :   location_t location;
      67                 :            :   /* The value associated with this token, if any.  */
      68                 :            :   tree value;
      69                 :            :   /* Token flags.  */
      70                 :            :   unsigned char flags;
      71                 :            : 
      72                 :  153928701 :   source_range get_range () const
      73                 :            :   {
      74                 :  124581671 :     return get_range_from_loc (line_table, location);
      75                 :            :   }
      76                 :            : 
      77                 :   29347030 :   location_t get_finish () const
      78                 :            :   {
      79                 :   29347030 :     return get_range ().m_finish;
      80                 :            :   }
      81                 :            : };
      82                 :            : 
      83                 :            : /* The parser.  */
      84                 :            : struct c_parser;
      85                 :            : 
      86                 :            : /* Possibly kinds of declarator to parse.  */
      87                 :            : enum c_dtr_syn {
      88                 :            :   /* A normal declarator with an identifier.  */
      89                 :            :   C_DTR_NORMAL,
      90                 :            :   /* An abstract declarator (maybe empty).  */
      91                 :            :   C_DTR_ABSTRACT,
      92                 :            :   /* A parameter declarator: may be either, but after a type name does
      93                 :            :      not redeclare a typedef name as an identifier if it can
      94                 :            :      alternatively be interpreted as a typedef name; see DR#009,
      95                 :            :      applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
      96                 :            :      following DR#249.  For example, given a typedef T, "int T" and
      97                 :            :      "int *T" are valid parameter declarations redeclaring T, while
      98                 :            :      "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
      99                 :            :      abstract declarators rather than involving redundant parentheses;
     100                 :            :      the same applies with attributes inside the parentheses before
     101                 :            :      "T".  */
     102                 :            :   C_DTR_PARM
     103                 :            : };
     104                 :            : 
     105                 :            : /* The binary operation precedence levels, where 0 is a dummy lowest level
     106                 :            :    used for the bottom of the stack.  */
     107                 :            : enum c_parser_prec {
     108                 :            :   PREC_NONE,
     109                 :            :   PREC_LOGOR,
     110                 :            :   PREC_LOGAND,
     111                 :            :   PREC_BITOR,
     112                 :            :   PREC_BITXOR,
     113                 :            :   PREC_BITAND,
     114                 :            :   PREC_EQ,
     115                 :            :   PREC_REL,
     116                 :            :   PREC_SHIFT,
     117                 :            :   PREC_ADD,
     118                 :            :   PREC_MULT,
     119                 :            :   NUM_PRECS
     120                 :            : };
     121                 :            : 
     122                 :            : enum c_lookahead_kind {
     123                 :            :   /* Always treat unknown identifiers as typenames.  */
     124                 :            :   cla_prefer_type,
     125                 :            : 
     126                 :            :   /* Could be parsing a nonabstract declarator.  Only treat an identifier
     127                 :            :      as a typename if followed by another identifier or a star.  */
     128                 :            :   cla_nonabstract_decl,
     129                 :            : 
     130                 :            :   /* Never treat identifiers as typenames.  */
     131                 :            :   cla_prefer_id
     132                 :            : };
     133                 :            : 
     134                 :            : 
     135                 :            : extern c_token * c_parser_peek_token (c_parser *parser);
     136                 :            : extern c_token * c_parser_peek_2nd_token (c_parser *parser);
     137                 :            : extern c_token * c_parser_peek_nth_token (c_parser *parser, unsigned int n);
     138                 :            : extern bool c_parser_require (c_parser *parser, enum cpp_ttype type,
     139                 :            :                               const char *msgid,
     140                 :            :                               location_t matching_location = UNKNOWN_LOCATION,
     141                 :            :                               bool type_is_unique=true);
     142                 :            : extern bool c_parser_error (c_parser *parser, const char *gmsgid);
     143                 :            : extern void c_parser_consume_token (c_parser *parser);
     144                 :            : extern void c_parser_skip_until_found (c_parser *parser, enum cpp_ttype type,
     145                 :            :                                        const char *msgid,
     146                 :            :                                        location_t = UNKNOWN_LOCATION);
     147                 :            : extern bool c_parser_next_token_starts_declspecs (c_parser *parser);
     148                 :            : bool c_parser_next_tokens_start_declaration (c_parser *parser);
     149                 :            : bool c_token_starts_typename (c_token *token);
     150                 :            : 
     151                 :            : /* Abstraction to avoid defining c_parser here which messes up gengtype
     152                 :            :    output wrt ObjC due to vec<c_token> routines being put in gtype-c.h
     153                 :            :    but not gtype-objc.h.  */
     154                 :            : extern c_token * c_parser_tokens_buf (c_parser *parser, unsigned n);
     155                 :            : extern bool c_parser_error (c_parser *parser);
     156                 :            : extern void c_parser_set_error (c_parser *parser, bool);
     157                 :            : 
     158                 :            : /* A bit of a hack to have this here.  It would be better in a c-decl.h.  */
     159                 :            : extern bool old_style_parameter_scope (void);
     160                 :            : 
     161                 :            : /* Return true if the next token from PARSER has the indicated
     162                 :            :    TYPE.  */
     163                 :            : 
     164                 :            : static inline bool
     165                 : 4497773774 : c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
     166                 :            : {
     167                 : 3025190258 :   return c_parser_peek_token (parser)->type == type;
     168                 :            : }
     169                 :            : 
     170                 :            : /* Return true if the next token from PARSER does not have the
     171                 :            :    indicated TYPE.  */
     172                 :            : 
     173                 :            : static inline bool
     174                 :  327347649 : c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
     175                 :            : {
     176                 :  306994649 :   return !c_parser_next_token_is (parser, type);
     177                 :            : }
     178                 :            : 
     179                 :            : /* Return true if the next token from PARSER is the indicated
     180                 :            :    KEYWORD.  */
     181                 :            : 
     182                 :            : static inline bool
     183                 :  515372959 : c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
     184                 :            : {
     185                 :  417719959 :   return c_parser_peek_token (parser)->keyword == keyword;
     186                 :            : }
     187                 :            : 
     188                 :            : struct c_expr c_parser_string_literal (c_parser *, bool, bool);
     189                 :            : extern struct c_declarator *
     190                 :            : c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
     191                 :            :                      bool *seen_id);
     192                 :            : extern void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
     193                 :            :                                 bool, bool, bool, bool, bool,
     194                 :            :                                 enum c_lookahead_kind);
     195                 :            : extern struct c_type_name *c_parser_type_name (c_parser *, bool = false);
     196                 :            : 
     197                 :            : #endif

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.