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
  89 expand_location_to_spelling_point (source_location,
  90                                    enum location_aspect aspect
  91                                      = LOCATION_ASPECT_CARET);
  92 extern source_location expansion_point_location_if_in_system_header (source_location);
  93 extern source_location expansion_point_location (source_location);
  94
  95 /* Historically GCC used location_t, while cpp used source_location.
  96    This could be removed but it hardly seems worth the effort.  */
  97 typedef source_location location_t;
  98
  99 extern location_t input_location;
 100
 101 #define LOCATION_FILE(LOC) ((expand_location (LOC)).file)
 102 #define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
 103 #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
 104 #define LOCATION_LOCUS(LOC) \
 105   ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
 106    : (LOC))
 107 #define LOCATION_BLOCK(LOC) \
 108   ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
 109    : NULL))
 110 #define RESERVED_LOCATION_P(LOC) \
 111   (LOCATION_LOCUS (LOC) < RESERVED_LOCATION_COUNT)
 112
 113 /* Return a positive value if LOCATION is the locus of a token that is
 114    located in a system header, O otherwise. It returns 1 if LOCATION
 115    is the locus of a token that is located in a system header, and 2
 116    if LOCATION is the locus of a token located in a C system header
 117    that therefore needs to be extern "C" protected in C++.
 118
 119    Note that this function returns 1 if LOCATION belongs to a token
 120    that is part of a macro replacement-list defined in a system
 121    header, but expanded in a non-system file.  */
 122
 123 static inline int
 124 in_system_header_at (location_t loc)
 125 {
 126   return linemap_location_in_system_header_p (line_table, loc);
 127 }
 128
 129 /* Return true if LOCATION is the locus of a token that
 130    comes from a macro expansion, false otherwise.  */
 131
 132 static inline bool
 133 from_macro_expansion_at (location_t loc)
 134 {
 135   return linemap_location_from_macro_expansion_p (line_table, loc);
 136 }
 137
 138 /* Return true if LOCATION is the locus of a token that comes from
 139    a macro definition, false otherwise.  This differs from from_macro_expansion_at
 140    in its treatment of macro arguments, for which this returns false.  */
 141
 142 static inline bool
 143 from_macro_definition_at (location_t loc)
 144 {
 145   return linemap_location_from_macro_definition_p (line_table, loc);
 146 }
 147
 148 static inline location_t
 149 get_pure_location (location_t loc)
 150 {
 151   return get_pure_location (line_table, loc);
 152 }
 153
 154 /* Get the start of any range encoded within location LOC.  */
 155
 156 static inline location_t
 157 get_start (location_t loc)
 158 {
 159   return get_range_from_loc (line_table, loc).m_start;
 160 }
 161
 162 /* Get the endpoint of any range encoded within location LOC.  */
 163
 164 static inline location_t
 165 get_finish (location_t loc)
 166 {
 167   return get_range_from_loc (line_table, loc).m_finish;
 168 }
 169
 170 extern location_t make_location (location_t caret,
 171                                  location_t start, location_t finish);
 172 extern location_t make_location (location_t caret, source_range src_range);
 173
 174 void dump_line_table_statistics (void);
 175
 176 void dump_location_info (FILE *stream);
 177
 178 void diagnostics_file_cache_fini (void);
 179
 180 void diagnostics_file_cache_forcibly_evict_file (const char *file_path);
 181
 182 struct GTY(()) string_concat
 183 {
 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