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-2021 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 extern GTY(()) class line_maps *line_table;
  27 extern GTY(()) class line_maps *saved_line_table;
  28
  29 /* A value which will never be used to represent a real location.  */
  30 #define UNKNOWN_LOCATION ((location_t) 0)
  31
  32 /* The location for declarations in "<built-in>" */
  33 #define BUILTINS_LOCATION ((location_t) 1)
  34
  35 /* line-map.c reserves RESERVED_LOCATION_COUNT to the user.  Ensure
  36    both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that.  */
  37 STATIC_ASSERT (BUILTINS_LOCATION < RESERVED_LOCATION_COUNT);
  38
  39 extern bool is_location_from_builtin_token (location_t);
  40 extern expanded_location expand_location (location_t);
  41
  42 class cpp_char_column_policy;
  43
  44 extern int
  45 location_compute_display_column (expanded_location exploc,
  46                                  const cpp_char_column_policy &policy);
  47
  48 /* A class capturing the bounds of a buffer, to allow for run-time
  49    bounds-checking in a checked build.  */
  50
  51 class char_span
  52 {
  53  public:
  54   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  55
  56   /* Test for a non-NULL pointer.  */
  57   operator bool() const { return m_ptr; }
  58
  59   /* Get length, not including any 0-terminator (which may not be,
  60      in fact, present).  */
  61   size_t length () const { return m_n_elts; }
  62
  63   const char *get_buffer () const { return m_ptr; }
  64
  65   char operator[] (int idx) const
  66   {
  67     gcc_assert (idx >= 0);
  68     gcc_assert ((size_t)idx < m_n_elts);
  69     return m_ptr[idx];
  70   }
  71
  72   char_span subspan (int offset, int n_elts) const
  73   {
  74     gcc_assert (offset >= 0);
  75     gcc_assert (offset < (int)m_n_elts);
  76     gcc_assert (n_elts >= 0);
  77     gcc_assert (offset + n_elts <= (int)m_n_elts);
  78     return char_span (m_ptr + offset, n_elts);
  79   }
  80
  81   char *xstrdup () const
  82   {
  83     return ::xstrndup (m_ptr, m_n_elts);
  84   }
  85
  86  private:
  87   const char *m_ptr;
  88   size_t m_n_elts;
  89 };
  90
  91 extern char_span location_get_source_line (const char *file_path, int line);
  92
  93 extern bool location_missing_trailing_newline (const char *file_path);
  94
  95 /* Forward decl of slot within file_cache, so that the definition doesn't
  96    need to be in this header.  */
  97 class file_cache_slot;
  98
  99 /* A cache of source files for use when emitting diagnostics
 100    (and in a few places in the C/C++ frontends).
 101
 102    Results are only valid until the next call to the cache, as
 103    slots can be evicted.
 104
 105    Filenames are stored by pointer, and so must outlive the cache
 106    instance.  */
 107
 108 class file_cache
 109 {
 110  public:
 111   file_cache ();
 112   ~file_cache ();
 113
 114   file_cache_slot *lookup_or_add_file (const char *file_path);
 115   void forcibly_evict_file (const char *file_path);
 116
 117   /* See comments in diagnostic.h about the input conversion context.  */
 118   struct input_context
 119   {
 120     diagnostic_input_charset_callback ccb;
 121     bool should_skip_bom;
 122   };
 123   void initialize_input_context (diagnostic_input_charset_callback ccb,
 124                                  bool should_skip_bom);
 125
 126  private:
 127   file_cache_slot *evicted_cache_tab_entry (unsigned *highest_use_count);
 128   file_cache_slot *add_file (const char *file_path);
 129   file_cache_slot *lookup_file (const char *file_path);
 130
 131  private:
 132   static const size_t num_file_slots = 16;
 133   file_cache_slot *m_file_slots;
 134   input_context in_context;
 135 };
 136
 137 extern expanded_location
 138 expand_location_to_spelling_point (location_t,
 139                                    enum location_aspect aspect
 140                                      = LOCATION_ASPECT_CARET);
 141 extern location_t expansion_point_location_if_in_system_header (location_t);
 142 extern location_t expansion_point_location (location_t);
 143
 144 extern location_t input_location;
 145
 146 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 147 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 148 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 149 #define LOCATION_LOCUS(LOC) \
 150   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 151    : (LOC))
 152 #define LOCATION_BLOCK(LOC) \
 153   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 154    : NULL))
 155 #define RESERVED_LOCATION_P(LOC) \
 156   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 157
 158 /* Return a positive value if LOCATION is the locus of a token that is
 159    located in a system header, O otherwise. It returns 1 if LOCATION
 160    is the locus of a token that is located in a system header, and 2
 161    if LOCATION is the locus of a token located in a C system header
 162    that therefore needs to be extern "C" protected in C++.
 163
 164    Note that this function returns 1 if LOCATION belongs to a token
 165    that is part of a macro replacement-list defined in a system
 166    header, but expanded in a non-system file.  */
 167
 168 static inline int
 169 in_system_header_at (location_t loc)
 170 {
 171   return linemap_location_in_system_header_p (line_table, loc);
 172 }
 173
 174 /* Return true if LOCATION is the locus of a token that
 175    comes from a macro expansion, false otherwise.  */
 176
 177 static inline bool
 178 from_macro_expansion_at (location_t loc)
 179 {
 180   return linemap_location_from_macro_expansion_p (line_table, loc);
 181 }
 182
 183 /* Return true if LOCATION is the locus of a token that comes from
 184    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 185    in its treatment of macro arguments, for which this returns false.  */
 186
 187 static inline bool
 188 from_macro_definition_at (location_t loc)
 189 {
 190   return linemap_location_from_macro_definition_p (line_table, loc);
 191 }
 192
 193 static inline location_t
 194 get_pure_location (location_t loc)
 195 {
 196   return get_pure_location (line_table, loc);
 197 }
 198
 199 /* Get the start of any range encoded within location LOC.  */
 200
 201 static inline location_t
 202 get_start (location_t loc)
 203 {
 204   return get_range_from_loc (line_table, loc).m_start;
 205 }
 206
 207 /* Get the endpoint of any range encoded within location LOC.  */
 208
 209 static inline location_t
 210 get_finish (location_t loc)
 211 {
 212   return get_range_from_loc (line_table, loc).m_finish;
 213 }
 214
 215 extern location_t make_location (location_t caret,
 216                                  location_t start, location_t finish);
 217 extern location_t make_location (location_t caret, source_range src_range);
 218
 219 void dump_line_table_statistics (void);
 220
 221 void dump_location_info (FILE *stream);
 222
 223 void diagnostics_file_cache_fini (void);
 224
 225 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 226
 227 class GTY(()) string_concat
 228 {
 229 public:
 230   string_concat (int num, location_t *locs);
 231
 232   int m_num;
 233   location_t * GTY ((atomic)) m_locs;
 234 };
 235
 236 struct location_hash : int_hash <location_t, UNKNOWN_LOCATION> { };
 237
 238 class GTY(()) string_concat_db
 239 {
 240  public:
 241   string_concat_db ();
 242   void record_string_concatenation (int num, location_t *locs);
 243
 244   bool get_string_concatenation (location_t loc,
 245                                  int *out_num,
 246                                  location_t **out_locs);
 247
 248  private:
 249   static location_t get_key_loc (location_t loc);
 250
 251   /* For the fields to be private, we must grant access to the
 252      generated code in gtype-desc.c.  */
 253
 254   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 255   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 256   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 257                                              gt_pointer_operator op,
 258                                              void *cookie);
 259
 260   hash_map <location_hash, string_concat *> *m_table;
 261 };
 262
 263 #endif