gcc/input.h

   1 /* Declarations for variables relating to reading the source file.
   2    Used by parsers, lexical analyzers, and error message routines.
   3    Copyright (C) 1993-2023 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_INPUT_H
  22 #define GCC_INPUT_H
  23
  24 #include "line-map.h"
  25
  26 class file_cache;
  27
  28 extern GTY(()) class line_maps *line_table;
  29 extern GTY(()) class line_maps *saved_line_table;
  30
  31 /* A value which will never be used to represent a real location.  */
  32 #define UNKNOWN_LOCATION ((location_t) 0)
  33
  34 /* The location for declarations in "<built-in>" */
  35 #define BUILTINS_LOCATION ((location_t) 1)
  36
  37 /* Returns the translated string referring to the special location.  */
  38 const char *special_fname_builtin ();
  39
  40 /* line-map.cc reserves RESERVED_LOCATION_COUNT to the user.  Ensure
  41    both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that.  */
  42 STATIC_ASSERT (BUILTINS_LOCATION < RESERVED_LOCATION_COUNT);
  43
  44 /* Hasher for 'location_t' values satisfying '!RESERVED_LOCATION_P', thus able
  45    to use 'UNKNOWN_LOCATION'/'BUILTINS_LOCATION' as spare values for
  46    'Empty'/'Deleted'.  */
  47 /* Per PR103157 "'gengtype': 'typedef' causing infinite-recursion code to be
  48    generated", don't use
  49        typedef int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION>
  50          location_hash;
  51    here.
  52
  53    It works for a single-use case, but when using a 'struct'-based variant
  54        struct location_hash
  55          : int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION> {};
  56    in more than one place, 'gengtype' generates duplicate functions (thus:
  57    "error: redefinition of 'void gt_ggc_mx(location_hash&)'" etc.).
  58    Attempting to mark that one up with GTY options, we run into a 'gengtype'
  59    "parse error: expected '{', have '<'", which probably falls into category
  60    "understanding of C++ is limited", as documented in 'gcc/doc/gty.texi'.
  61
  62    Thus, use a plain ol' '#define':
  63 */
  64 #define location_hash int_hash<location_t, UNKNOWN_LOCATION, BUILTINS_LOCATION>
  65
  66 extern bool is_location_from_builtin_token (location_t);
  67 extern expanded_location expand_location (location_t);
  68
  69 class cpp_char_column_policy;
  70
  71 extern int
  72 location_compute_display_column (file_cache &fc,
  73                                  expanded_location exploc,
  74                                  const cpp_char_column_policy &policy);
  75
  76 /* A class capturing the bounds of a buffer, to allow for run-time
  77    bounds-checking in a checked build.  */
  78
  79 class char_span
  80 {
  81  public:
  82   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  83
  84   /* Test for a non-NULL pointer.  */
  85   operator bool() const { return m_ptr; }
  86
  87   /* Get length, not including any 0-terminator (which may not be,
  88      in fact, present).  */
  89   size_t length () const { return m_n_elts; }
  90
  91   const char *get_buffer () const { return m_ptr; }
  92
  93   char operator[] (int idx) const
  94   {
  95     gcc_assert (idx >= 0);
  96     gcc_assert ((size_t)idx < m_n_elts);
  97     return m_ptr[idx];
  98   }
  99
 100   char_span subspan (int offset, int n_elts) const
 101   {
 102     gcc_assert (offset >= 0);
 103     gcc_assert (offset < (int)m_n_elts);
 104     gcc_assert (n_elts >= 0);
 105     gcc_assert (offset + n_elts <= (int)m_n_elts);
 106     return char_span (m_ptr + offset, n_elts);
 107   }
 108
 109   char *xstrdup () const
 110   {
 111     return ::xstrndup (m_ptr, m_n_elts);
 112   }
 113
 114  private:
 115   const char *m_ptr;
 116   size_t m_n_elts;
 117 };
 118
 119 extern char *
 120 get_source_text_between (file_cache &, location_t, location_t);
 121
 122 /* Forward decl of slot within file_cache, so that the definition doesn't
 123    need to be in this header.  */
 124 class file_cache_slot;
 125
 126 /* A cache of source files for use when emitting diagnostics
 127    (and in a few places in the C/C++ frontends).
 128
 129    Results are only valid until the next call to the cache, as
 130    slots can be evicted.
 131
 132    Filenames are stored by pointer, and so must outlive the cache
 133    instance.  */
 134
 135 class file_cache
 136 {
 137  public:
 138   file_cache ();
 139   ~file_cache ();
 140
 141   file_cache_slot *lookup_or_add_file (const char *file_path);
 142   void forcibly_evict_file (const char *file_path);
 143
 144   /* See comments in diagnostic.h about the input conversion context.  */
 145   struct input_context
 146   {
 147     diagnostic_input_charset_callback ccb;
 148     bool should_skip_bom;
 149   };
 150   void initialize_input_context (diagnostic_input_charset_callback ccb,
 151                                  bool should_skip_bom);
 152
 153   char_span get_source_file_content (const char *file_path);
 154   char_span get_source_line (const char *file_path, int line);
 155   bool missing_trailing_newline_p (const char *file_path);
 156
 157  private:
 158   file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count);
 159   file_cache_slot *add_file (const char *file_path);
 160   file_cache_slot *lookup_file (const char *file_path);
 161
 162  private:
 163   static const size_t num_file_slots = 16;
 164   file_cache_slot *m_file_slots;
 165   input_context in_context;
 166 };
 167
 168 extern expanded_location
 169 expand_location_to_spelling_point (location_t,
 170                                    enum location_aspect aspect
 171                                      = LOCATION_ASPECT_CARET);
 172 extern location_t expansion_point_location_if_in_system_header (location_t);
 173 extern location_t expansion_point_location (location_t);
 174
 175 extern location_t input_location;
 176
 177 extern location_t location_with_discriminator (location_t, int);
 178 extern bool has_discriminator (location_t);
 179 extern int get_discriminator_from_loc (location_t);
 180
 181 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 182 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 183 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 184 #define LOCATION_LOCUS(LOC) \
 185   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 186    : (LOC))
 187 #define LOCATION_BLOCK(LOC) \
 188   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 189    : NULL))
 190 #define RESERVED_LOCATION_P(LOC) \
 191   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 192
 193 /* Return a positive value if LOCATION is the locus of a token that is
 194    located in a system header, O otherwise. It returns 1 if LOCATION
 195    is the locus of a token that is located in a system header, and 2
 196    if LOCATION is the locus of a token located in a C system header
 197    that therefore needs to be extern "C" protected in C++.
 198
 199    Note that this function returns 1 if LOCATION belongs to a token
 200    that is part of a macro replacement-list defined in a system
 201    header, but expanded in a non-system file.  */
 202
 203 inline int
 204 in_system_header_at (location_t loc)
 205 {
 206   return linemap_location_in_system_header_p (line_table, loc);
 207 }
 208
 209 /* Return true if LOCATION is the locus of a token that
 210    comes from a macro expansion, false otherwise.  */
 211
 212 inline bool
 213 from_macro_expansion_at (location_t loc)
 214 {
 215   return linemap_location_from_macro_expansion_p (line_table, loc);
 216 }
 217
 218 /* Return true if LOCATION is the locus of a token that comes from
 219    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 220    in its treatment of macro arguments, for which this returns false.  */
 221
 222 inline bool
 223 from_macro_definition_at (location_t loc)
 224 {
 225   return linemap_location_from_macro_definition_p (line_table, loc);
 226 }
 227
 228 inline location_t
 229 get_pure_location (location_t loc)
 230 {
 231   return get_pure_location (line_table, loc);
 232 }
 233
 234 /* Get the start of any range encoded within location LOC.  */
 235
 236 inline location_t
 237 get_start (location_t loc)
 238 {
 239   return get_range_from_loc (line_table, loc).m_start;
 240 }
 241
 242 /* Get the endpoint of any range encoded within location LOC.  */
 243
 244 inline location_t
 245 get_finish (location_t loc)
 246 {
 247   return get_range_from_loc (line_table, loc).m_finish;
 248 }
 249
 250 extern location_t make_location (location_t caret,
 251                                  location_t start, location_t finish);
 252 extern location_t make_location (location_t caret, source_range src_range);
 253
 254 void dump_line_table_statistics (void);
 255
 256 void dump_location_info (FILE *stream);
 257
 258 class GTY(()) string_concat
 259 {
 260 public:
 261   string_concat (int num, location_t *locs);
 262
 263   int m_num;
 264   location_t * GTY ((atomic)) m_locs;
 265 };
 266
 267 class GTY(()) string_concat_db
 268 {
 269  public:
 270   string_concat_db ();
 271   void record_string_concatenation (int num, location_t *locs);
 272
 273   bool get_string_concatenation (location_t loc,
 274                                  int *out_num,
 275                                  location_t **out_locs);
 276
 277  private:
 278   static location_t get_key_loc (location_t loc);
 279
 280   /* For the fields to be private, we must grant access to the
 281      generated code in gtype-desc.cc.  */
 282
 283   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 284   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 285   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 286                                              gt_pointer_operator op,
 287                                              void *cookie);
 288
 289   hash_map <location_hash, string_concat *> *m_table;
 290 };
 291
 292 #endif