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-2019 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 ((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 /* 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
  89 expand_location_to_spelling_point (location_t,
  90                                    enum location_aspect aspect
  91                                      = LOCATION_ASPECT_CARET);
  92 extern location_t expansion_point_location_if_in_system_header (location_t);
  93 extern location_t expansion_point_location (location_t);
  94
  95 extern location_t input_location;
  96
  97 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
  98 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
  99 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 100 #define LOCATION_LOCUS(LOC) \
 101   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 102    : (LOC))
 103 #define LOCATION_BLOCK(LOC) \
 104   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 105    : NULL))
 106 #define RESERVED_LOCATION_P(LOC) \
 107   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 108
 109 /* Return a positive value if LOCATION is the locus of a token that is
 110    located in a system header, O otherwise. It returns 1 if LOCATION
 111    is the locus of a token that is located in a system header, and 2
 112    if LOCATION is the locus of a token located in a C system header
 113    that therefore needs to be extern "C" protected in C++.
 114
 115    Note that this function returns 1 if LOCATION belongs to a token
 116    that is part of a macro replacement-list defined in a system
 117    header, but expanded in a non-system file.  */
 118
 119 static inline int
 120 in_system_header_at (location_t loc)
 121 {
 122   return linemap_location_in_system_header_p (line_table, loc);
 123 }
 124
 125 /* Return true if LOCATION is the locus of a token that
 126    comes from a macro expansion, false otherwise.  */
 127
 128 static inline bool
 129 from_macro_expansion_at (location_t loc)
 130 {
 131   return linemap_location_from_macro_expansion_p (line_table, loc);
 132 }
 133
 134 /* Return true if LOCATION is the locus of a token that comes from
 135    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 136    in its treatment of macro arguments, for which this returns false.  */
 137
 138 static inline bool
 139 from_macro_definition_at (location_t loc)
 140 {
 141   return linemap_location_from_macro_definition_p (line_table, loc);
 142 }
 143
 144 static inline location_t
 145 get_pure_location (location_t loc)
 146 {
 147   return get_pure_location (line_table, loc);
 148 }
 149
 150 /* Get the start of any range encoded within location LOC.  */
 151
 152 static inline location_t
 153 get_start (location_t loc)
 154 {
 155   return get_range_from_loc (line_table, loc).m_start;
 156 }
 157
 158 /* Get the endpoint of any range encoded within location LOC.  */
 159
 160 static inline location_t
 161 get_finish (location_t loc)
 162 {
 163   return get_range_from_loc (line_table, loc).m_finish;
 164 }
 165
 166 extern location_t make_location (location_t caret,
 167                                  location_t start, location_t finish);
 168 extern location_t make_location (location_t caret, source_range src_range);
 169
 170 void dump_line_table_statistics (void);
 171
 172 void dump_location_info (FILE *stream);
 173
 174 void diagnostics_file_cache_fini (void);
 175
 176 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 177
 178 struct GTY(()) string_concat
 179 {
 180   string_concat (int num, location_t *locs);
 181
 182   int m_num;
 183   location_t * GTY ((atomic)) m_locs;
 184 };
 185
 186 struct location_hash : int_hash <location_t, UNKNOWN_LOCATION> { };
 187
 188 class GTY(()) string_concat_db
 189 {
 190  public:
 191   string_concat_db ();
 192   void record_string_concatenation (int num, location_t *locs);
 193
 194   bool get_string_concatenation (location_t loc,
 195                                  int *out_num,
 196                                  location_t **out_locs);
 197
 198  private:
 199   static location_t get_key_loc (location_t loc);
 200
 201   /* For the fields to be private, we must grant access to the
 202      generated code in gtype-desc.c.  */
 203
 204   friend void ::gt_ggc_mx_string_concat_db (void *x_p);
 205   friend void ::gt_pch_nx_string_concat_db (void *x_p);
 206   friend void ::gt_pch_p_16string_concat_db (void *this_obj, void *x_p,
 207                                              gt_pointer_operator op,
 208                                              void *cookie);
 209
 210   hash_map <location_hash, string_concat *> *m_table;
 211 };
 212
 213 #endif