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