sdcc/support/cpp/gcc/c/c-parser.h

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