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-2018 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(()) struct line_maps *line_table;
  27 extern GTY(()) struct line_maps *saved_line_table;
  28
  29 /* A value which will never be used to represent a real location.  */
  30 #define UNKNOWN_LOCATION ((source_location) 0)
  31
  32 /* The location for declarations in "<built-in>" */
  33 #define BUILTINS_LOCATION ((source_location) 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 (source_location);
  40 extern expanded_location expand_location (source_location);
  41
  42 /* A class capturing the bounds of a buffer, to allow for run-time
  43    bounds-checking in a checked build.  */
  44
  45 class char_span
  46 {
  47  public:
  48   char_span (const char *ptr, size_t n_elts) : m_ptr (ptr), m_n_elts (n_elts) {}
  49
  50   /* Test for a non-NULL pointer.  */
  51   operator bool() const { return m_ptr; }
  52
  53   /* Get length, not including any 0-terminator (which may not be,
  54      in fact, present).  */
  55   size_t length () const { return m_n_elts; }
  56
  57   const char *get_buffer () const { return m_ptr; }
  58
  59   char operator[] (int idx) const
  60   {
  61     gcc_assert (idx >= 0);
  62     gcc_assert ((size_t)idx < m_n_elts);
  63     return m_ptr[idx];
  64   }
  65
  66   char_span subspan (int offset, int n_elts) const
  67   {
  68     gcc_assert (offset >= 0);
  69     gcc_assert (offset < (int)m_n_elts);
  70     gcc_assert (n_elts >= 0);
  71     gcc_assert (offset + n_elts <= (int)m_n_elts);
  72     return char_span (m_ptr + offset, n_elts);
  73   }
  74
  75   char *xstrdup () const
  76   {
  77     return ::xstrndup (m_ptr, m_n_elts);
  78   }
  79
  80  private:
  81   const char *m_ptr;
  82   size_t m_n_elts;
  83 };
  84
  85 extern char_span location_get_source_line (const char *file_path, int line);
  86
  87 extern bool location_missing_trailing_newline (const char *file_path);
  88 extern expanded_location expand_location_to_spelling_point (source_location);
  89 extern source_location expansion_point_location_if_in_system_header (source_location);
  90 extern source_location expansion_point_location (source_location);
  91
  92 /* Historically GCC used location_t, while cpp used source_location.
  93    This could be removed but it hardly seems worth the effort.  */
  94 typedef source_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 struct GTY(()) string_concat
 180 {
 181   string_concat (int num, location_t *locs);
 182
 183   int m_num;
 184   location_t * GTY ((atomic)) m_locs;
 185 };
 186
 187 struct location_hash : int_hash <location_t, UNKNOWN_LOCATION> { };
 188
 189 class GTY(()) string_concat_db
 190 {
 191  public:
 192   string_concat_db ();
 193   void record_string_concatenation (int num, location_t *locs);
 194
 195   bool get_string_concatenation (location_t loc,
 196                                  int *out_num,
 197                                  location_t **out_locs);
 198
 199  private:
 200   static location_t get_key_loc (location_t loc);
 201
 202   /* For the fields to be private, we must grant access to the
 203      generated code in gtype-desc.c.  */
 204
 205   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 206   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 207   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 208                                              gt_pointer_operator op,
 209                                              void *cookie);
 210
 211   hash_map <location_hash, string_concat *> *m_table;
 212 };
 213
 214 #endif