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-2020 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 extern int location_compute_display_column (expanded_location);
  42
  43 /* A class capturing the bounds of a buffer, to allow for run-time
  44    bounds-checking in a checked build.  */
  45
  46 class char_span
  47 {
  48  public:
  49   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  50
  51   /* Test for a non-NULL pointer.  */
  52   operator bool() const { return m_ptr; }
  53
  54   /* Get length, not including any 0-terminator (which may not be,
  55      in fact, present).  */
  56   size_t length () const { return m_n_elts; }
  57
  58   const char *get_buffer () const { return m_ptr; }
  59
  60   char operator[] (int idx) const
  61   {
  62     gcc_assert (idx >= 0);
  63     gcc_assert ((size_t)idx < m_n_elts);
  64     return m_ptr[idx];
  65   }
  66
  67   char_span subspan (int offset, int n_elts) const
  68   {
  69     gcc_assert (offset >= 0);
  70     gcc_assert (offset < (int)m_n_elts);
  71     gcc_assert (n_elts >= 0);
  72     gcc_assert (offset + n_elts <= (int)m_n_elts);
  73     return char_span (m_ptr + offset, n_elts);
  74   }
  75
  76   char *xstrdup () const
  77   {
  78     return ::xstrndup (m_ptr, m_n_elts);
  79   }
  80
  81  private:
  82   const char *m_ptr;
  83   size_t m_n_elts;
  84 };
  85
  86 extern char_span location_get_source_line (const char *file_path, int line);
  87
  88 extern bool location_missing_trailing_newline (const char *file_path);
  89 extern expanded_location
  90 expand_location_to_spelling_point (location_t,
  91                                    enum location_aspect aspect
  92                                      = LOCATION_ASPECT_CARET);
  93 extern location_t expansion_point_location_if_in_system_header (location_t);
  94 extern location_t expansion_point_location (location_t);
  95
  96 extern location_t input_location;
  97
  98 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
  99 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 100 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 101 #define LOCATION_LOCUS(LOC) \
 102   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 103    : (LOC))
 104 #define LOCATION_BLOCK(LOC) \
 105   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 106    : NULL))
 107 #define RESERVED_LOCATION_P(LOC) \
 108   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 109
 110 /* Return a positive value if LOCATION is the locus of a token that is
 111    located in a system header, O otherwise. It returns 1 if LOCATION
 112    is the locus of a token that is located in a system header, and 2
 113    if LOCATION is the locus of a token located in a C system header
 114    that therefore needs to be extern "C" protected in C++.
 115
 116    Note that this function returns 1 if LOCATION belongs to a token
 117    that is part of a macro replacement-list defined in a system
 118    header, but expanded in a non-system file.  */
 119
 120 static inline int
 121 in_system_header_at (location_t loc)
 122 {
 123   return linemap_location_in_system_header_p (line_table, loc);
 124 }
 125
 126 /* Return true if LOCATION is the locus of a token that
 127    comes from a macro expansion, false otherwise.  */
 128
 129 static inline bool
 130 from_macro_expansion_at (location_t loc)
 131 {
 132   return linemap_location_from_macro_expansion_p (line_table, loc);
 133 }
 134
 135 /* Return true if LOCATION is the locus of a token that comes from
 136    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 137    in its treatment of macro arguments, for which this returns false.  */
 138
 139 static inline bool
 140 from_macro_definition_at (location_t loc)
 141 {
 142   return linemap_location_from_macro_definition_p (line_table, loc);
 143 }
 144
 145 static inline location_t
 146 get_pure_location (location_t loc)
 147 {
 148   return get_pure_location (line_table, loc);
 149 }
 150
 151 /* Get the start of any range encoded within location LOC.  */
 152
 153 static inline location_t
 154 get_start (location_t loc)
 155 {
 156   return get_range_from_loc (line_table, loc).m_start;
 157 }
 158
 159 /* Get the endpoint of any range encoded within location LOC.  */
 160
 161 static inline location_t
 162 get_finish (location_t loc)
 163 {
 164   return get_range_from_loc (line_table, loc).m_finish;
 165 }
 166
 167 extern location_t make_location (location_t caret,
 168                                  location_t start, location_t finish);
 169 extern location_t make_location (location_t caret, source_range src_range);
 170
 171 void dump_line_table_statistics (void);
 172
 173 void dump_location_info (FILE *stream);
 174
 175 void diagnostics_file_cache_fini (void);
 176
 177 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 178
 179 class GTY(()) string_concat
 180 {
 181 public:
 182   string_concat (int num, location_t *locs);
 183
 184   int m_num;
 185   location_t * GTY ((atomic)) m_locs;
 186 };
 187
 188 struct location_hash : int_hash <location_t, UNKNOWN_LOCATION> { };
 189
 190 class GTY(()) string_concat_db
 191 {
 192  public:
 193   string_concat_db ();
 194   void record_string_concatenation (int num, location_t *locs);
 195
 196   bool get_string_concatenation (location_t loc,
 197                                  int *out_num,
 198                                  location_t **out_locs);
 199
 200  private:
 201   static location_t get_key_loc (location_t loc);
 202
 203   /* For the fields to be private, we must grant access to the
 204      generated code in gtype-desc.c.  */
 205
 206   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 207   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 208   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 209                                              gt_pointer_operator op,
 210                                              void *cookie);
 211
 212   hash_map <location_hash, string_concat *> *m_table;
 213 };
 214
 215 #endif