gcc/c/c-parser.h

   1 /* Declarations for the parser for C and Objective-C.
   2    Copyright (C) 1987-2024 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.cc
  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 /* This should have the same layout as c_tree_token_vec
  84    in c-decl.cc, but for GTY reasons with ObjC can't be
  85    GTY itself.  */
  86 struct c_tree_token_vec_struct {
  87   struct tree_base base;
  88   vec<c_token, va_gc> *tokens;
  89 };
  90
  91 #define C_TOKEN_VEC_TOKENS(NODE) \
  92   (((struct c_tree_token_vec_struct *) TREE_CHECK (NODE, C_TOKEN_VEC))->tokens)
  93
  94 /* The parser.  */
  95 struct c_parser;
  96
  97 /* Possibly kinds of declarator to parse.  */
  98 enum c_dtr_syn {
  99   /* A normal declarator with an identifier.  */
 100   C_DTR_NORMAL,
 101   /* An abstract declarator (maybe empty).  */
 102   C_DTR_ABSTRACT,
 103   /* A parameter declarator: may be either, but after a type name does
 104      not redeclare a typedef name as an identifier if it can
 105      alternatively be interpreted as a typedef name; see DR#009,
 106      applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
 107      following DR#249.  For example, given a typedef T, "int T" and
 108      "int *T" are valid parameter declarations redeclaring T, while
 109      "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
 110      abstract declarators rather than involving redundant parentheses;
 111      the same applies with attributes inside the parentheses before
 112      "T".  */
 113   C_DTR_PARM
 114 };
 115
 116 /* The binary operation precedence levels, where 0 is a dummy lowest level
 117    used for the bottom of the stack.  */
 118 enum c_parser_prec {
 119   PREC_NONE,
 120   PREC_LOGOR,
 121   PREC_LOGAND,
 122   PREC_BITOR,
 123   PREC_BITXOR,
 124   PREC_BITAND,
 125   PREC_EQ,
 126   PREC_REL,
 127   PREC_SHIFT,
 128   PREC_ADD,
 129   PREC_MULT,
 130   NUM_PRECS
 131 };
 132
 133 enum c_lookahead_kind {
 134   /* Always treat unknown identifiers as typenames.  */
 135   cla_prefer_type,
 136
 137   /* Could be parsing a nonabstract declarator.  Only treat an identifier
 138      as a typename if followed by another identifier or a star.  */
 139   cla_nonabstract_decl,
 140
 141   /* Never treat identifiers as typenames.  */
 142   cla_prefer_id
 143 };
 144
 145
 146 extern c_token * c_parser_peek_token (c_parser *parser);
 147 extern c_token * c_parser_peek_2nd_token (c_parser *parser);
 148 extern c_token * c_parser_peek_nth_token (c_parser *parser, unsigned int n);
 149 extern bool c_parser_require (c_parser *parser, enum cpp_ttype type,
 150                               const char *msgid,
 151                               location_t matching_location = UNKNOWN_LOCATION,
 152                               bool type_is_unique=true);
 153 extern bool c_parser_error (c_parser *parser, const char *gmsgid);
 154 extern void c_parser_consume_token (c_parser *parser);
 155 extern void c_parser_skip_until_found (c_parser *parser, enum cpp_ttype type,
 156                                        const char *msgid,
 157                                        location_t = UNKNOWN_LOCATION);
 158 extern bool c_parser_next_token_starts_declspecs (c_parser *parser);
 159 bool c_parser_next_tokens_start_declaration (c_parser *parser);
 160 bool c_token_starts_typename (c_token *token);
 161
 162 /* Abstraction to avoid defining c_parser here which messes up gengtype
 163    output wrt ObjC due to vec<c_token> routines being put in gtype-c.h
 164    but not gtype-objc.h.  */
 165 extern c_token * c_parser_tokens_buf (c_parser *parser, unsigned n);
 166 extern bool c_parser_error (c_parser *parser);
 167 extern void c_parser_set_error (c_parser *parser, bool);
 168
 169 /* A bit of a hack to have this here.  It would be better in a c-decl.h.  */
 170 extern bool old_style_parameter_scope (void);
 171
 172 /* Return true if the next token from PARSER has the indicated
 173    TYPE.  */
 174
 175 inline bool
 176 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
 177 {
 178   return c_parser_peek_token (parser)->type == type;
 179 }
 180
 181 /* Return true if the next token from PARSER does not have the
 182    indicated TYPE.  */
 183
 184 inline bool
 185 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
 186 {
 187   return !c_parser_next_token_is (parser, type);
 188 }
 189
 190 /* Return true if the next token from PARSER is the indicated
 191    KEYWORD.  */
 192
 193 inline bool
 194 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
 195 {
 196   return c_parser_peek_token (parser)->keyword == keyword;
 197 }
 198
 199 struct c_expr c_parser_string_literal (c_parser *, bool, bool);
 200 extern struct c_declarator *
 201 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
 202                      bool *seen_id);
 203 extern void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
 204                                 bool, bool, bool, bool, bool,
 205                                 enum c_lookahead_kind);
 206 extern struct c_type_name *c_parser_type_name (c_parser *, bool = false);
 207 extern bool c_maybe_parse_omp_decl (tree, tree);
 208
 209 #endif