gcc/c/c-parser.h

   1 /* Declarations for the parser for C and Objective-C.
   2    Copyright (C) 1987-2018 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   source_range get_range () const
  73   {
  74     return get_range_from_loc (line_table, location);
  75   }
  76
  77   location_t get_finish () const
  78   {
  79     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 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
 166 {
 167   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 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
 175 {
 176   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 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
 184 {
 185   return c_parser_peek_token (parser)->keyword == keyword;
 186 }
 187
 188 extern struct c_declarator *
 189 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
 190                      bool *seen_id);
 191 extern void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
 192                                 bool, bool, bool, enum c_lookahead_kind);
 193 extern struct c_type_name *c_parser_type_name (c_parser *, bool = false);
 194
 195 #endif