riscv-gnu-toolchain/gcc.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Richard Henderson <rth@gcc.gnu.org>	2010-07-26 15:53:50 -0700
committer	Richard Henderson <rth@gcc.gnu.org>	2010-07-26 15:53:50 -0700
commit	8b84c5966fddefd51475d4df0fb2f1a699ba23fe (patch)
tree	566634468015c713398a1fcd59ec66da7138545a /gcc/cse.c
parent	b57c6b13e0d950ba0771b1688cf6e57e3a5beae6 (diff)
download	gcc-8b84c5966fddefd51475d4df0fb2f1a699ba23fe.zip gcc-8b84c5966fddefd51475d4df0fb2f1a699ba23fe.tar.gz gcc-8b84c5966fddefd51475d4df0fb2f1a699ba23fe.tar.bz2

re PR target/44132 (emutls is broken under a range of circumstances.)

PR target/44132 Emulated TLS rewrite. From-SVN: r162549

Diffstat (limited to 'gcc/cse.c')

0 files changed, 0 insertions, 0 deletions

/* Data and functions related to line maps and input files. Copyright (C) 2004-2016 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "intl.h" #include "diagnostic-core.h" #include "selftest.h" #include "cpplib.h" #ifndef HAVE_ICONV #define HAVE_ICONV 0 #endif /* This is a cache used by get_next_line to store the content of a file to be searched for file lines. */ struct fcache { /* These are information used to store a line boundary. */ struct line_info { /* The line number. It starts from 1. */ size_t line_num; /* The position (byte count) of the beginning of the line, relative to the file data pointer. This starts at zero. */ size_t start_pos; /* The position (byte count) of the last byte of the line. This normally points to the '\n' character, or to one byte after the last byte of the file, if the file doesn't contain a '\n' character. */ size_t end_pos; line_info (size_t l, size_t s, size_t e) : line_num (l), start_pos (s), end_pos (e) {} line_info () :line_num (0), start_pos (0), end_pos (0) {} }; /* The number of time this file has been accessed. This is used to designate which file cache to evict from the cache array. */ unsigned use_count; const char *file_path; FILE *fp; /* This points to the content of the file that we've read so far. */ char *data; /* The size of the DATA array above.*/ size_t size; /* The number of bytes read from the underlying file so far. This must be less (or equal) than SIZE above. */ size_t nb_read; /* The index of the beginning of the current line. */ size_t line_start_idx; /* The number of the previous line read. This starts at 1. Zero means we've read no line so far. */ size_t line_num; /* This is the total number of lines of the current file. At the moment, we try to get this information from the line map subsystem. Note that this is just a hint. When using the C++ front-end, this hint is correct because the input file is then completely tokenized before parsing starts; so the line map knows the number of lines before compilation really starts. For e.g, the C front-end, it can happen that we start emitting diagnostics before the line map has seen the end of the file. */ size_t total_lines; /* Could this file be missing a trailing newline on its final line? Initially true (to cope with empty files), set to true/false as each line is read. */ bool missing_trailing_newline; /* This is a record of the beginning and end of the lines we've seen while reading the file. This is useful to avoid walking the data from the beginning when we are asked to read a line that is before LINE_START_IDX above. Note that the maximum size of this record is fcache_line_record_size, so that the memory consumption doesn't explode. We thus scale total_lines down to fcache_line_record_size. */ vec<line_info, va_heap> line_record; fcache (); ~fcache (); }; /* Current position in real source file. */ location_t input_location = UNKNOWN_LOCATION; struct line_maps *line_table; /* A stashed copy of "line_table" for use by selftest::line_table_test. This needs to be a global so that it can be a GC root, and thus prevent the stashed copy from being garbage-collected if the GC runs during a line_table_test. */ struct line_maps *saved_line_table; static fcache *fcache_tab; static const size_t fcache_tab_size = 16; static const size_t fcache_buffer_size = 4 * 1024; static const size_t fcache_line_record_size = 100; /* Expand the source location LOC into a human readable location. If LOC resolves to a builtin location, the file name of the readable location is set to the string "<built-in>". If EXPANSION_POINT_P is TRUE and LOC is virtual, then it is resolved to the expansion point of the involved macro. Otherwise, it is resolved to the spelling location of the token. When resolving to the spelling location of the token, if the resulting location is for a built-in location (that is, it has no associated line/column) in the context of a macro expansion, the returned location is the first one (while unwinding the macro location towards its expansion point) that is in real source code. */ static expanded_location expand_location_1 (source_location loc, bool expansion_point_p) { expanded_location xloc; const line_map_ordinary *map; enum location_resolution_kind lrk = LRK_MACRO_EXPANSION_POINT; tree block = NULL; if (IS_ADHOC_LOC (loc)) { block = LOCATION_BLOCK (loc); loc = LOCATION_LOCUS (loc); } memset (&xloc, 0, sizeof (xloc)); if (loc >= RESERVED_LOCATION_COUNT) { if (!expansion_point_p) { /* We want to resolve LOC to its spelling location. But if that spelling location is a reserved location that appears in the context of a macro expansion (like for a location for a built-in token), let's consider the first location (toward the expansion point) that is not reserved; that is, the first location that is in real source code. */ loc = linemap_unwind_to_first_non_reserved_loc (line_table, loc, NULL); lrk = LRK_SPELLING_LOCATION; } loc = linemap_resolve_location (line_table, loc, lrk, &map); xloc = linemap_expand_location (line_table, map, loc); } xloc.data = block; if (loc <= BUILTINS_LOCATION) xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>"); return xloc; } /* Initialize the set of cache used for files accessed by caret diagnostic. */ static void diagnostic_file_cache_init (void) { if (fcache_tab == NULL) fcache_tab = new fcache[fcache_tab_size]; } /* Free the resources used by the set of cache used for files accessed by caret diagnostic. */ void diagnostic_file_cache_fini (void) { if (fcache_tab) { delete [] (fcache_tab); fcache_tab = NULL; } } /* Return the total lines number that have been read so far by the line map (in the preprocessor) so far. For languages like C++ that entirely preprocess the input file before starting to parse, this equals the actual number of lines of the file. */ static size_t total_lines_num (const char *file_path) { size_t r = 0; source_location l = 0; if (linemap_get_file_highest_location (line_table, file_path, &l)) { gcc_assert (l >= RESERVED_LOCATION_COUNT); expanded_location xloc = expand_location (l); r = xloc.line; } return r; } /* Lookup the cache used for the content of a given file accessed by caret diagnostic. Return the found cached file, or NULL if no cached file was found. */ static fcache* lookup_file_in_cache_tab (const char *file_path) { if (file_path == NULL) return NULL; diagnostic_file_cache_init (); /* This will contain the found cached file. */ fcache *r = NULL; for (unsigned i = 0; i < fcache_tab_size; ++i) { fcache *c = &fcache_tab[i]; if (c->file_path && !strcmp (c->file_path, file_path)) { ++c->use_count; r = c; } } if (r) ++r->use_count; return r; } /* Purge any mention of FILENAME from the cache of files used for printing source code. For use in selftests when working with tempfiles. */ void diagnostics_file_cache_forcibly_evict_file (const char *file_path) { gcc_assert (file_path); fcache *r = lookup_file_in_cache_tab (file_path); if (!r) /* Not found. */ return; r->file_path = NULL; if (r->fp) fclose (r->fp); r->fp = NULL; r->nb_read = 0; r->line_start_idx = 0; r->line_num = 0; r->line_record.truncate (0); r->use_count = 0; r->total_lines = 0; r->missing_trailing_newline = true; } /* Return the file cache that has been less used, recently, or the first empty one. If HIGHEST_USE_COUNT is non-null, *HIGHEST_USE_COUNT is set to the highest use count of the entries in the cache table. */ static fcache* evicted_cache_tab_entry (unsigned *highest_use_count) { diagnostic_file_cache_init (); fcache *to_evict = &fcache_tab[0]; unsigned huc = to_evict->use_count; for (unsigned i = 1; i < fcache_tab_size; ++i) { fcache *c = &fcache_tab[i]; bool c_is_empty = (c->file_path == NULL); if (c->use_count < to_evict->use_count || (to_evict->file_path && c_is_empty)) /* We evict C because it's either an entry with a lower use count or one that is empty. */ to_evict = c; if (huc < c->use_count) huc = c->use_count; if (c_is_empty) /* We've reached the end of the cache; subsequent elements are all empty. */ break; } if (highest_use_count) *highest_use_count = huc; return to_evict; } /* Create the cache used for the content of a given file to be accessed by caret diagnostic. This cache is added to an array of cache and can be retrieved by lookup_file_in_cache_tab. This function returns the created cache. Note that only the last fcache_tab_size files are cached. */ static fcache* add_file_to_cache_tab (const char *file_path) { FILE *fp = fopen (file_path, "r"); if (fp == NULL) return NULL; unsigned highest_use_count = 0; fcache *r = evicted_cache_tab_entry (&highest_use_count); r->file_path = file_path; if (r->fp) fclose (r->fp); r->fp = fp; r->nb_read = 0; r->line_start_idx = 0; r->line_num = 0; r->line_record.truncate (0); /* Ensure that this cache entry doesn't get evicted next time add_file_to_cache_tab is called. */ r->use_count = ++highest_use_count; r->total_lines = total_lines_num (file_path); r->missing_trailing_newline = true; return r; } /* Lookup the cache used for the content of a given file accessed by caret diagnostic. If no cached file was found, create a new cache for this file, add it to the array of cached file and return it. */ static fcache* lookup_or_add_file_to_cache_tab (const char *file_path) { fcache *r = lookup_file_in_cache_tab (file_path); if (r == NULL) r = add_file_to_cache_tab (file_path); return r; } /* Default constructor for a cache of file used by caret diagnostic. */ fcache::fcache () : use_count (0), file_path (NULL), fp (NULL), data (0), size (0), nb_read (0), line_start_idx (0), line_num (0), total_lines (0), missing_trailing_newline (true) { line_record.create (0); } /* Destructor for a cache of file used by caret diagnostic. */ fcache::~fcache () { if (fp) { fclose (fp); fp = NULL; } if (data) { XDELETEVEC (data); data = 0; } line_record.release (); } /* Returns TRUE iff the cache would need to be filled with data coming from the file. That is, either the cache is empty or full or the current line is empty. Note that if the cache is full, it would need to be extended and filled again. */ static bool needs_read (fcache *c) { return (c->nb_read == 0 || c->nb_read == c->size || (c->line_start_idx >= c->nb_read - 1)); } /* Return TRUE iff the cache is full and thus needs to be extended. */ static bool needs_grow (fcache *c) { return c->nb_read == c->size; } /* Grow the cache if it needs to be extended. */ static void maybe_grow (fcache *c) { if (!needs_grow (c)) return; size_t size = c->size == 0 ? fcache_buffer_size : c->size * 2; c->data = XRESIZEVEC (char, c->data, size); c->size = size; } /* Read more data into the cache. Extends the cache if need be. Returns TRUE iff new data could be read. */ static bool read_data (fcache *c) { if (feof (c->fp) || ferror (c->fp)) return false; maybe_grow (c); char * from = c->data + c->nb_read; size_t to_read = c->size - c->nb_read; size_t nb_read = fread (from, 1, to_read, c->fp); if (ferror (c->fp)) return false; c->nb_read += nb_read; return !!nb_read; } /* Read new data iff the cache needs to be filled with more data coming from the file FP. Return TRUE iff the cache was filled with mode data. */ static bool maybe_read_data (fcache *c) { if (!needs_read (c)) return false; return read_data (c); } /* Read a new line from file FP, using C as a cache for the data coming from the file. Upon successful completion, *LINE is set to the beginning of the line found. *LINE points directly in the line cache and is only valid until the next call of get_next_line. *LINE_LEN is set to the length of the line. Note that the line does not contain any terminal delimiter. This function returns true if some data was read or process from the cache, false otherwise. Note that subsequent calls to get_next_line might make the content of *LINE invalid. */ static bool get_next_line (fcache *c, char **line, ssize_t *line_len) { /* Fill the cache with data to process. */ maybe_read_data (c); size_t remaining_size = c->nb_read - c->line_start_idx; if (remaining_size == 0) /* There is no more data to process. */ return false; char *line_start = c->data + c->line_start_idx; char *next_line_start = NULL; size_t len = 0; char *line_end = (char *) memchr (line_start, '\n', remaining_size); if (line_end == NULL) { /* We haven't found the end-of-line delimiter in the cache. Fill the cache with more data from the file and look for the '\n'. */ while (maybe_read_data (c)) { line_start = c->data + c->line_start_idx; remaining_size = c->nb_read - c->line_start_idx; line_end = (char *) memchr (line_start, '\n', remaining_size); if (line_end != NULL) { next_line_start = line_end + 1; break; } } if (line_end == NULL) { /* We've loadded all the file into the cache and still no '\n'. Let's say the line ends up at one byte passed the end of the file. This is to stay consistent with the case of when the line ends up with a '\n' and line_end points to that terminal '\n'. That consistency is useful below in the len calculation. */ line_end = c->data + c->nb_read ; c->missing_trailing_newline = true; } else c->missing_trailing_newline = false; } else { next_line_start = line_end + 1; c->missing_trailing_newline = false; } if (ferror (c->fp)) return false; /* At this point, we've found the end of the of line. It either points to the '\n' or to one byte after the last byte of the file. */ gcc_assert (line_end != NULL); len = line_end - line_start; if (c->line_start_idx < c->nb_read) *line = line_start; ++c->line_num; /* Before we update our line record, make sure the hint about the total number of lines of the file is correct. If it's not, then we give up recording line boundaries from now on. */ bool update_line_record = true; if (c->line_num > c->total_lines) update_line_record = false; /* Now update our line record so that re-reading lines from the before c->line_start_idx is faster. */ if (update_line_record && c->line_record.length () < fcache_line_record_size) { /* If the file lines fits in the line record, we just record all its lines ...*/ if (c->total_lines <= fcache_line_record_size && c->line_num > c->line_record.length ()) c->line_record.safe_push (fcache::line_info (c->line_num, c->line_start_idx, line_end - c->data)); else if (c->total_lines > fcache_line_record_size) { /* ... otherwise, we just scale total_lines down to (fcache_line_record_size lines. */ size_t n = (c->line_num * fcache_line_record_size) / c->total_lines; if (c->line_record.length () == 0 || n >= c->line_record.length ()) c->line_record.safe_push (fcache::line_info (c->line_num, c->line_start_idx, line_end - c->data)); } } /* Update c->line_start_idx so that it points to the next line to be read. */ if (next_line_start) c->line_start_idx = next_line_start - c->data; else /* We didn't find any terminal '\n'. Let's consider that the end of line is the end of the data in the cache. The next invocation of get_next_line will either read more data from the underlying file or return false early because we've reached the end of the file. */ c->line_start_idx = c->nb_read; *line_len = len; return true; } /* Consume the next bytes coming from the cache (or from its underlying file if there are remaining unread bytes in the file) until we reach the next end-of-line (or end-of-file). There is no copying from the cache involved. Return TRUE upon successful completion. */ static bool goto_next_line (fcache *cache) { char *l; ssize_t len; return get_next_line (cache, &l, &len); } /* Read an arbitrary line number LINE_NUM from the file cached in C. If the line was read successfully, *LINE points to the beginning of the line in the file cache and *LINE_LEN is the length of the line. *LINE is not nul-terminated, but may contain zero bytes. *LINE is only valid until the next call of read_line_num. This function returns bool if a line was read. */ static bool read_line_num (fcache *c, size_t line_num, char **line, ssize_t *line_len) { gcc_assert (line_num > 0); if (line_num <= c->line_num) { /* We've been asked to read lines that are before c->line_num. So lets use our line record (if it's not empty) to try to avoid re-reading the file from the beginning again. */ if (c->line_record.is_empty ()) { c->line_start_idx = 0; c->line_num = 0; } else { fcache::line_info *i = NULL; if (c->total_lines <= fcache_line_record_size) { /* In languages where the input file is not totally preprocessed up front, the c->total_lines hint can be smaller than the number of lines of the file. In that case, only the first c->total_lines have been recorded. Otherwise, the first c->total_lines we've read have their start/end recorded here. */ i = (line_num <= c->total_lines) ? &c->line_record[line_num - 1] : &c->line_record[c->total_lines - 1]; gcc_assert (i->line_num <= line_num); } else { /* So the file had more lines than our line record size. Thus the number of lines we've recorded has been scaled down to fcache_line_reacord_size. Let's pick the start/end of the recorded line that is closest to line_num. */ size_t n = (line_num <= c->total_lines) ? line_num * fcache_line_record_size / c->total_lines : c ->line_record.length () - 1; if (n < c->line_record.length ()) { i = &c->line_record[n]; gcc_assert (i->line_num <= line_num); } } if (i && i->line_num == line_num) { /* We have the start/end of the line. */ *line = c->data + i->start_pos; *line_len = i->end_pos - i->start_pos; return true; } if (i) { c->line_start_idx = i->start_pos; c->line_num = i->line_num - 1; } else { c->line_start_idx = 0; c->line_num = 0; } } } /* Let's walk from line c->line_num up to line_num - 1, without copying any line. */ while (c->line_num < line_num - 1) if (!goto_next_line (c)) return false; /* The line we want is the next one. Let's read and copy it back to the caller. */ return get_next_line (c, line, line_len); } /* Return the physical source line that corresponds to FILE_PATH/LINE. The line is not nul-terminated. The returned pointer is only valid until the next call of location_get_source_line. Note that the line can contain several null characters, so LINE_LEN, if non-null, points to the actual length of the line. If the function fails, NULL is returned. */ const char * location_get_source_line (const char *file_path, int line, int *line_len) { char *buffer = NULL; ssize_t len; if (line == 0) return NULL; fcache *c = lookup_or_add_file_to_cache_tab (file_path); if (c == NULL) return NULL; bool read = read_line_num (c, line, &buffer, &len); if (read && line_len) *line_len = len; return read ? buffer : NULL; } /* Determine if FILE_PATH missing a trailing newline on its final line. Only valid to call once all of the file has been loaded, by requesting a line number beyond the end of the file. */ bool location_missing_trailing_newline (const char *file_path) { fcache *c = lookup_or_add_file_to_cache_tab (file_path); if (c == NULL) return false; return c->missing_trailing_newline; } /* Test if the location originates from the spelling location of a builtin-tokens. That is, return TRUE if LOC is a (possibly virtual) location of a built-in token that appears in the expansion list of a macro. Please note that this function also works on tokens that result from built-in tokens. For instance, the function would return true if passed a token "4" that is the result of the expansion of the built-in __LINE__ macro. */ bool is_location_from_builtin_token (source_location loc) { const line_map_ordinary *map = NULL; loc = linemap_resolve_location (line_table, loc, LRK_SPELLING_LOCATION, &map); return loc == BUILTINS_LOCATION; } /* Expand the source location LOC into a human readable location. If LOC is virtual, it resolves to the expansion point of the involved macro. If LOC resolves to a builtin location, the file name of the readable location is set to the string "<built-in>". */ expanded_location expand_location (source_location loc) { return expand_location_1 (loc, /*expansion_point_p=*/true); } /* Expand the source location LOC into a human readable location. If LOC is virtual, it resolves to the expansion location of the relevant macro. If LOC resolves to a builtin location, the file name of the readable location is set to the string "<built-in>". */ expanded_location expand_location_to_spelling_point (source_location loc) { return expand_location_1 (loc, /*expansion_point_p=*/false); } /* The rich_location class within libcpp requires a way to expand source_location instances, and relies on the client code providing a symbol named linemap_client_expand_location_to_spelling_point to do this. This is the implementation for libcommon.a (all host binaries), which simply calls into expand_location_to_spelling_point. */ expanded_location linemap_client_expand_location_to_spelling_point (source_location loc) { return expand_location_to_spelling_point (loc); } /* If LOCATION is in a system header and if it is a virtual location for a token coming from the expansion of a macro, unwind it to the location of the expansion point of the macro. Otherwise, just return LOCATION. This is used for instance when we want to emit diagnostics about a token that may be located in a macro that is itself defined in a system header, for example, for the NULL macro. In such a case, if LOCATION were passed directly to diagnostic functions such as warning_at, the diagnostic would be suppressed (unless -Wsystem-headers). */ source_location expansion_point_location_if_in_system_header (source_location location) { if (in_system_header_at (location)) location = linemap_resolve_location (line_table, location, LRK_MACRO_EXPANSION_POINT, NULL); return location; } /* If LOCATION is a virtual location for a token coming from the expansion of a macro, unwind to the location of the expansion point of the macro. */ source_location expansion_point_location (source_location location) { return linemap_resolve_location (line_table, location, LRK_MACRO_EXPANSION_POINT, NULL); } /* Construct a location with caret at CARET, ranging from START to finish e.g. 11111111112 12345678901234567890 522 523 return foo + bar; ~~~~^~~~~ 524 The location's caret is at the "+", line 523 column 15, but starts earlier, at the "f" of "foo" at column 11. The finish is at the "r" of "bar" at column 19. */ location_t make_location (location_t caret, location_t start, location_t finish) { location_t pure_loc = get_pure_location (caret); source_range src_range; src_range.m_start = get_start (start); src_range.m_finish = get_finish (finish); location_t combined_loc = COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, NULL); return combined_loc; } #define ONE_K 1024 #define ONE_M (ONE_K * ONE_K) /* Display a number as an integer multiple of either: - 1024, if said integer is >= to 10 K (in base 2) - 1024 * 1024, if said integer is >= 10 M in (base 2) */ #define SCALE(x) ((unsigned long) ((x) < 10 * ONE_K \ ? (x) \ : ((x) < 10 * ONE_M \ ? (x) / ONE_K \ : (x) / ONE_M))) /* For a given integer, display either: - the character 'k', if the number is higher than 10 K (in base 2) but strictly lower than 10 M (in base 2) - the character 'M' if the number is higher than 10 M (in base2) - the charcter ' ' if the number is strictly lower than 10 K */ #define STAT_LABEL(x) ((x) < 10 * ONE_K ? ' ' : ((x) < 10 * ONE_M ? 'k' : 'M')) /* Display an integer amount as multiple of 1K or 1M (in base 2). Display the correct unit (either k, M, or ' ') after the amout, as well. */ #define FORMAT_AMOUNT(size) SCALE (size), STAT_LABEL (size) /* Dump statistics to stderr about the memory usage of the line_table set of line maps. This also displays some statistics about macro expansion. */ void dump_line_table_statistics (void) { struct linemap_stats s; long total_used_map_size, macro_maps_size, total_allocated_map_size; memset (&s, 0, sizeof (s)); linemap_get_statistics (line_table, &s); macro_maps_size = s.macro_maps_used_size + s.macro_maps_locations_size; total_allocated_map_size = s.ordinary_maps_allocated_size + s.macro_maps_allocated_size + s.macro_maps_locations_size; total_used_map_size = s.ordinary_maps_used_size + s.macro_maps_used_size + s.macro_maps_locations_size; fprintf (stderr, "Number of expanded macros: %5ld\n", s.num_expanded_macros); if (s.num_expanded_macros != 0) fprintf (stderr, "Average number of tokens per macro expansion: %5ld\n", s.num_macro_tokens / s.num_expanded_macros); fprintf (stderr, "\nLine Table allocations during the " "compilation process\n"); fprintf (stderr, "Number of ordinary maps used: %5ld%c\n", SCALE (s.num_ordinary_maps_used), STAT_LABEL (s.num_ordinary_maps_used)); fprintf (stderr, "Ordinary map used size: %5ld%c\n", SCALE (s.ordinary_maps_used_size), STAT_LABEL (s.ordinary_maps_used_size)); fprintf (stderr, "Number of ordinary maps allocated: %5ld%c\n", SCALE (s.num_ordinary_maps_allocated), STAT_LABEL (s.num_ordinary_maps_allocated)); fprintf (stderr, "Ordinary maps allocated size: %5ld%c\n", SCALE (s.ordinary_maps_allocated_size), STAT_LABEL (s.ordinary_maps_allocated_size)); fprintf (stderr, "Number of macro maps used: %5ld%c\n", SCALE (s.num_macro_maps_used), STAT_LABEL (s.num_macro_maps_used)); fprintf (stderr, "Macro maps used size: %5ld%c\n", SCALE (s.macro_maps_used_size), STAT_LABEL (s.macro_maps_used_size)); fprintf (stderr, "Macro maps locations size: %5ld%c\n", SCALE (s.macro_maps_locations_size), STAT_LABEL (s.macro_maps_locations_size)); fprintf (stderr, "Macro maps size: %5ld%c\n", SCALE (macro_maps_size), STAT_LABEL (macro_maps_size)); fprintf (stderr, "Duplicated maps locations size: %5ld%c\n", SCALE (s.duplicated_macro_maps_locations_size), STAT_LABEL (s.duplicated_macro_maps_locations_size)); fprintf (stderr, "Total allocated maps size: %5ld%c\n", SCALE (total_allocated_map_size), STAT_LABEL (total_allocated_map_size)); fprintf (stderr, "Total used maps size: %5ld%c\n", SCALE (total_used_map_size), STAT_LABEL (total_used_map_size)); fprintf (stderr, "Ad-hoc table size: %5ld%c\n", SCALE (s.adhoc_table_size), STAT_LABEL (s.adhoc_table_size)); fprintf (stderr, "Ad-hoc table entries used: %5ld\n", s.adhoc_table_entries_used); fprintf (stderr, "optimized_ranges: %i\n", line_table->num_optimized_ranges); fprintf (stderr, "unoptimized_ranges: %i\n", line_table->num_unoptimized_ranges); fprintf (stderr, "\n"); } /* Get location one beyond the final location in ordinary map IDX. */ static source_location get_end_location (struct line_maps *set, unsigned int idx) { if (idx == LINEMAPS_ORDINARY_USED (set) - 1) return set->highest_location; struct line_map *next_map = LINEMAPS_ORDINARY_MAP_AT (set, idx + 1); return MAP_START_LOCATION (next_map); } /* Helper function for write_digit_row. */ static void write_digit (FILE *stream, int digit) { fputc ('0' + (digit % 10), stream); } /* Helper function for dump_location_info. Write a row of numbers to STREAM, numbering a source line, giving the units, tens, hundreds etc of the column number. */ static void write_digit_row (FILE *stream, int indent, const line_map_ordinary *map, source_location loc, int max_col, int divisor) { fprintf (stream, "%*c", indent, ' '); fprintf (stream, "|"); for (int column = 1; column < max_col; column++) { source_location column_loc = loc + (column << map->m_range_bits); write_digit (stream, column_loc / divisor); } fprintf (stream, "\n"); } /* Write a half-closed (START) / half-open (END) interval of source_location to STREAM. */ static void dump_location_range (FILE *stream, source_location start, source_location end) { fprintf (stream, " source_location interval: %u <= loc < %u\n", start, end); } /* Write a labelled description of a half-closed (START) / half-open (END) interval of source_location to STREAM. */ static void dump_labelled_location_range (FILE *stream, const char *name, source_location start, source_location end) { fprintf (stream, "%s\n", name); dump_location_range (stream, start, end); fprintf (stream, "\n"); } /* Write a visualization of the locations in the line_table to STREAM. */ void dump_location_info (FILE *stream) { /* Visualize the reserved locations. */ dump_labelled_location_range (stream, "RESERVED LOCATIONS", 0, RESERVED_LOCATION_COUNT); /* Visualize the ordinary line_map instances, rendering the sources. */ for (unsigned int idx = 0; idx < LINEMAPS_ORDINARY_USED (line_table); idx++) { source_location end_location = get_end_location (line_table, idx); /* half-closed: doesn't include this one. */ const line_map_ordinary *map = LINEMAPS_ORDINARY_MAP_AT (line_table, idx); fprintf (stream, "ORDINARY MAP: %i\n", idx); dump_location_range (stream, MAP_START_LOCATION (map), end_location); fprintf (stream, " file: %s\n", ORDINARY_MAP_FILE_NAME (map)); fprintf (stream, " starting at line: %i\n", ORDINARY_MAP_STARTING_LINE_NUMBER (map)); fprintf (stream, " column and range bits: %i\n", map->m_column_and_range_bits); fprintf (stream, " column bits: %i\n", map->m_column_and_range_bits - map->m_range_bits); fprintf (stream, " range bits: %i\n", map->m_range_bits); /* Render the span of source lines that this "map" covers. */ for (source_location loc = MAP_START_LOCATION (map); loc < end_location; loc += (1 << map->m_range_bits) ) { gcc_assert (pure_location_p (line_table, loc) ); expanded_location exploc = linemap_expand_location (line_table, map, loc); if (0 == exploc.column) { /* Beginning of a new source line: draw the line. */ int line_size; const char *line_text = location_get_source_line (exploc.file, exploc.line, &line_size); if (!line_text) break; fprintf (stream, "%s:%3i|loc:%5i|%.*s\n", exploc.file, exploc.line, loc, line_size, line_text); /* "loc" is at column 0, which means "the whole line". Render the locations *within* the line, by underlining it, showing the source_location numeric values at each column. */ int max_col = (1 << map->m_column_and_range_bits) - 1; if (max_col > line_size) max_col = line_size + 1; int indent = 14 + strlen (exploc.file); /* Thousands. */ if (end_location > 999) write_digit_row (stream, indent, map, loc, max_col, 1000); /* Hundreds. */ if (end_location > 99) write_digit_row (stream, indent, map, loc, max_col, 100); /* Tens. */ write_digit_row (stream, indent, map, loc, max_col, 10); /* Units. */ write_digit_row (stream, indent, map, loc, max_col, 1); } } fprintf (stream, "\n"); } /* Visualize unallocated values. */ dump_labelled_location_range (stream, "UNALLOCATED LOCATIONS", line_table->highest_location, LINEMAPS_MACRO_LOWEST_LOCATION (line_table)); /* Visualize the macro line_map instances, rendering the sources. */ for (unsigned int i = 0; i < LINEMAPS_MACRO_USED (line_table); i++) { /* Each macro map that is allocated owns source_location values that are *lower* that the one before them. Hence it's meaningful to view them either in order of ascending source locations, or in order of ascending macro map index. */ const bool ascending_source_locations = true; unsigned int idx = (ascending_source_locations ? (LINEMAPS_MACRO_USED (line_table) - (i + 1)) : i); const line_map_macro *map = LINEMAPS_MACRO_MAP_AT (line_table, idx); fprintf (stream, "MACRO %i: %s (%u tokens)\n", idx, linemap_map_get_macro_name (map), MACRO_MAP_NUM_MACRO_TOKENS (map)); dump_location_range (stream, map->start_location, (map->start_location + MACRO_MAP_NUM_MACRO_TOKENS (map))); inform (MACRO_MAP_EXPANSION_POINT_LOCATION (map), "expansion point is location %i", MACRO_MAP_EXPANSION_POINT_LOCATION (map)); fprintf (stream, " map->start_location: %u\n", map->start_location); fprintf (stream, " macro_locations:\n"); for (unsigned int i = 0; i < MACRO_MAP_NUM_MACRO_TOKENS (map); i++) { source_location x = MACRO_MAP_LOCATIONS (map)[2 * i]; source_location y = MACRO_MAP_LOCATIONS (map)[(2 * i) + 1]; /* linemap_add_macro_token encodes token numbers in an expansion by putting them after MAP_START_LOCATION. */ /* I'm typically seeing 4 uninitialized entries at the end of 0xafafafaf. This appears to be due to macro.c:replace_args adding 2 extra args for padding tokens; presumably there may be a leading and/or trailing padding token injected, each for 2 more location slots. This would explain there being up to 4 source_locations slots that may be uninitialized. */ fprintf (stream, " %u: %u, %u\n", i, x, y); if (x == y) { if (x < MAP_START_LOCATION (map)) inform (x, "token %u has x-location == y-location == %u", i, x); else fprintf (stream, "x-location == y-location == %u encodes token # %u\n", x, x - MAP_START_LOCATION (map)); } else { inform (x, "token %u has x-location == %u", i, x); inform (x, "token %u has y-location == %u", i, y); } } fprintf (stream, "\n"); } /* It appears that MAX_SOURCE_LOCATION itself is never assigned to a macro map, presumably due to an off-by-one error somewhere between the logic in linemap_enter_macro and LINEMAPS_MACRO_LOWEST_LOCATION. */ dump_labelled_location_range (stream, "MAX_SOURCE_LOCATION", MAX_SOURCE_LOCATION, MAX_SOURCE_LOCATION + 1); /* Visualize ad-hoc values. */ dump_labelled_location_range (stream, "AD-HOC LOCATIONS", MAX_SOURCE_LOCATION + 1, UINT_MAX); } /* string_concat's constructor. */ string_concat::string_concat (int num, location_t *locs) : m_num (num) { m_locs = ggc_vec_alloc <location_t> (num); for (int i = 0; i < num; i++) m_locs[i] = locs[i]; } /* string_concat_db's constructor. */ string_concat_db::string_concat_db () { m_table = hash_map <location_hash, string_concat *>::create_ggc (64); } /* Record that a string concatenation occurred, covering NUM string literal tokens. LOCS is an array of size NUM, containing the locations of the tokens. A copy of LOCS is taken. */ void string_concat_db::record_string_concatenation (int num, location_t *locs) { gcc_assert (num > 1); gcc_assert (locs); location_t key_loc = get_key_loc (locs[0]); string_concat *concat = new (ggc_alloc <string_concat> ()) string_concat (num, locs); m_table->put (key_loc, concat); } /* Determine if LOC was the location of the the initial token of a concatenation of string literal tokens. If so, *OUT_NUM is written to with the number of tokens, and *OUT_LOCS with the location of an array of locations of the tokens, and return true. *OUT_LOCS is a borrowed pointer to storage owned by the string_concat_db. Otherwise, return false. */ bool string_concat_db::get_string_concatenation (location_t loc, int *out_num, location_t **out_locs) { gcc_assert (out_num); gcc_assert (out_locs); location_t key_loc = get_key_loc (loc); string_concat **concat = m_table->get (key_loc); if (!concat) return false; *out_num = (*concat)->m_num; *out_locs =(*concat)->m_locs; return true; } /* Internal function. Canonicalize LOC into a form suitable for use as a key within the database, stripping away macro expansion, ad-hoc information, and range information, using the location of the start of LOC within an ordinary linemap. */ location_t string_concat_db::get_key_loc (location_t loc) { loc = linemap_resolve_location (line_table, loc, LRK_SPELLING_LOCATION, NULL); loc = get_range_from_loc (line_table, loc).m_start; return loc; } /* Helper class for use within get_substring_ranges_for_loc. An vec of cpp_string with responsibility for releasing all of the str->text for each str in the vector. */ class auto_cpp_string_vec : public auto_vec <cpp_string> { public: auto_cpp_string_vec (int alloc) : auto_vec <cpp_string> (alloc) {} ~auto_cpp_string_vec () { /* Clean up the copies within this vec. */ int i; cpp_string *str; FOR_EACH_VEC_ELT (*this, i, str) free (const_cast <unsigned char *> (str->text)); } }; /* Attempt to populate RANGES with source location information on the individual characters within the string literal found at STRLOC. If CONCATS is non-NULL, then any string literals that the token at STRLOC was concatenated with are also added to RANGES. Return NULL if successful, or an error message if any errors occurred (in which case RANGES may be only partially populated and should not be used). This is implemented by re-parsing the relevant source line(s). */ static const char * get_substring_ranges_for_loc (cpp_reader *pfile, string_concat_db *concats, location_t strloc, enum cpp_ttype type, cpp_substring_ranges &ranges) { gcc_assert (pfile); if (strloc == UNKNOWN_LOCATION) return "unknown location"; /* If string concatenation has occurred at STRLOC, get the locations of all of the literal tokens making up the compound string. Otherwise, just use STRLOC. */ int num_locs = 1; location_t *strlocs = &strloc; if (concats) concats->get_string_concatenation (strloc, &num_locs, &strlocs); auto_cpp_string_vec strs (num_locs); auto_vec <cpp_string_location_reader> loc_readers (num_locs); for (int i = 0; i < num_locs; i++) { /* Get range of strloc. We will use it to locate the start and finish of the literal token within the line. */ source_range src_range = get_range_from_loc (line_table, strlocs[i]); if (src_range.m_start >= LINEMAPS_MACRO_LOWEST_LOCATION (line_table)) /* If the string is within a macro expansion, we can't get at the end location. */ return "macro expansion"; if (src_range.m_start >= LINE_MAP_MAX_LOCATION_WITH_COLS) /* If so, we can't reliably determine where the token started within its line. */ return "range starts after LINE_MAP_MAX_LOCATION_WITH_COLS"; if (src_range.m_finish >= LINE_MAP_MAX_LOCATION_WITH_COLS) /* If so, we can't reliably determine where the token finished within its line. */ return "range ends after LINE_MAP_MAX_LOCATION_WITH_COLS"; expanded_location start = expand_location_to_spelling_point (src_range.m_start); expanded_location finish = expand_location_to_spelling_point (src_range.m_finish); if (start.file != finish.file) return "range endpoints are in different files"; if (start.line != finish.line) return "range endpoints are on different lines"; if (start.column > finish.column) return "range endpoints are reversed"; int line_width; const char *line = location_get_source_line (start.file, start.line, &line_width); if (line == NULL) return "unable to read source line"; /* Determine the location of the literal (including quotes and leading prefix chars, such as the 'u' in a u"" token). */ const char *literal = line + start.column - 1; int literal_length = finish.column - start.column + 1; gcc_assert (line_width >= (start.column - 1 + literal_length)); cpp_string from; from.len = literal_length; /* Make a copy of the literal, to avoid having to rely on the lifetime of the copy of the line within the cache. This will be released by the auto_cpp_string_vec dtor. */ from.text = XDUPVEC (unsigned char, literal, literal_length); strs.safe_push (from); /* For very long lines, a new linemap could have started halfway through the token. Ensure that the loc_reader uses the linemap of the *end* of the token for its start location. */ const line_map_ordinary *final_ord_map; linemap_resolve_location (line_table, src_range.m_finish, LRK_MACRO_EXPANSION_POINT, &final_ord_map); location_t start_loc = linemap_position_for_line_and_column (line_table, final_ord_map, start.line, start.column); cpp_string_location_reader loc_reader (start_loc, line_table); loc_readers.safe_push (loc_reader); } /* Rerun cpp_interpret_string, or rather, a modified version of it. */ const char *err = cpp_interpret_string_ranges (pfile, strs.address (), loc_readers.address (), num_locs, &ranges, type); if (err) return err; /* Success: "ranges" should now contain information on the string. */ return NULL; } /* Attempt to populate *OUT_LOC with source location information on the given characters within the string literal found at STRLOC. CARET_IDX, START_IDX, and END_IDX refer to offsets within the execution character set. For example, given CARET_IDX = 4, START_IDX = 3, END_IDX = 7 and string literal "012345\n789" *OUT_LOC is written to with: "012345\n789" ~^~~~~ If CONCATS is non-NULL, then any string literals that the token at STRLOC was concatenated with are also considered. This is implemented by re-parsing the relevant source line(s). Return NULL if successful, or an error message if any errors occurred. Error messages are intended for GCC developers (to help debugging) rather than for end-users. */ const char * get_source_location_for_substring (cpp_reader *pfile, string_concat_db *concats, location_t strloc, enum cpp_ttype type, int caret_idx, int start_idx, int end_idx, source_location *out_loc) { gcc_checking_assert (caret_idx >= 0); gcc_checking_assert (start_idx >= 0); gcc_checking_assert (end_idx >= 0); gcc_assert (out_loc); cpp_substring_ranges ranges; const char *err = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges); if (err) return err; if (caret_idx >= ranges.get_num_ranges ()) return "caret_idx out of range"; if (start_idx >= ranges.get_num_ranges ()) return "start_idx out of range"; if (end_idx >= ranges.get_num_ranges ()) return "end_idx out of range"; *out_loc = make_location (ranges.get_range (caret_idx).m_start, ranges.get_range (start_idx).m_start, ranges.get_range (end_idx).m_finish); return NULL; } #if CHECKING_P namespace selftest { /* Selftests of location handling. */ /* Attempt to populate *OUT_RANGE with source location information on the given character within the string literal found at STRLOC. CHAR_IDX refers to an offset within the execution character set. If CONCATS is non-NULL, then any string literals that the token at STRLOC was concatenated with are also considered. This is implemented by re-parsing the relevant source line(s). Return NULL if successful, or an error message if any errors occurred. Error messages are intended for GCC developers (to help debugging) rather than for end-users. */ static const char * get_source_range_for_char (cpp_reader *pfile, string_concat_db *concats, location_t strloc, enum cpp_ttype type, int char_idx, source_range *out_range) { gcc_checking_assert (char_idx >= 0); gcc_assert (out_range); cpp_substring_ranges ranges; const char *err = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges); if (err) return err; if (char_idx >= ranges.get_num_ranges ()) return "char_idx out of range"; *out_range = ranges.get_range (char_idx); return NULL; } /* As get_source_range_for_char, but write to *OUT the number of ranges that are available. */ static const char * get_num_source_ranges_for_substring (cpp_reader *pfile, string_concat_db *concats, location_t strloc, enum cpp_ttype type, int *out) { gcc_assert (out); cpp_substring_ranges ranges; const char *err = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges); if (err) return err; *out = ranges.get_num_ranges (); return NULL; } /* Selftests of location handling. */ /* Helper function for verifying location data: when location_t values are > LINE_MAP_MAX_LOCATION_WITH_COLS, they are treated as having column 0. */ static bool should_have_column_data_p (location_t loc) { if (IS_ADHOC_LOC (loc)) loc = get_location_from_adhoc_loc (line_table, loc); if (loc > LINE_MAP_MAX_LOCATION_WITH_COLS) return false; return true; } /* Selftest for should_have_column_data_p. */ static void test_should_have_column_data_p () { ASSERT_TRUE (should_have_column_data_p (RESERVED_LOCATION_COUNT)); ASSERT_TRUE (should_have_column_data_p (LINE_MAP_MAX_LOCATION_WITH_COLS)); ASSERT_FALSE (should_have_column_data_p (LINE_MAP_MAX_LOCATION_WITH_COLS + 1)); } /* Verify the result of LOCATION_FILE/LOCATION_LINE/LOCATION_COLUMN on LOC. */ static void assert_loceq (const char *exp_filename, int exp_linenum, int exp_colnum, location_t loc) { ASSERT_STREQ (exp_filename, LOCATION_FILE (loc)); ASSERT_EQ (exp_linenum, LOCATION_LINE (loc)); /* If location_t values are sufficiently high, then column numbers will be unavailable and LOCATION_COLUMN (loc) will be 0. When close to the threshold, column numbers *may* be present: if the final linemap before the threshold contains a line that straddles the threshold, locations in that line have column information. */ if (should_have_column_data_p (loc)) ASSERT_EQ (exp_colnum, LOCATION_COLUMN (loc)); } /* Various selftests involve constructing a line table and one or more line maps within it. For maximum test coverage we want to run these tests with a variety of situations: - line_table->default_range_bits: some frontends use a non-zero value and others use zero - the fallback modes within line-map.c: there are various threshold values for source_location/location_t beyond line-map.c changes behavior (disabling of the range-packing optimization, disabling of column-tracking). We can exercise these by starting the line_table at interesting values at or near these thresholds. The following struct describes a particular case within our test matrix. */ struct line_table_case { line_table_case (int default_range_bits, int base_location) : m_default_range_bits (default_range_bits), m_base_location (base_location) {} int m_default_range_bits; int m_base_location; }; /* Constructor. Store the old value of line_table, and create a new one, using sane defaults. */ line_table_test::line_table_test () { gcc_assert (saved_line_table == NULL); saved_line_table = line_table; line_table = ggc_alloc<line_maps> (); linemap_init (line_table, BUILTINS_LOCATION); gcc_assert (saved_line_table->reallocator); line_table->reallocator = saved_line_table->reallocator; gcc_assert (saved_line_table->round_alloc_size); line_table->round_alloc_size = saved_line_table->round_alloc_size; line_table->default_range_bits = 0; } /* Constructor. Store the old value of line_table, and create a new one, using the sitation described in CASE_. */ line_table_test::line_table_test (const line_table_case &case_) { gcc_assert (saved_line_table == NULL); saved_line_table = line_table; line_table = ggc_alloc<line_maps> (); linemap_init (line_table, BUILTINS_LOCATION); gcc_assert (saved_line_table->reallocator); line_table->reallocator = saved_line_table->reallocator; gcc_assert (saved_line_table->round_alloc_size); line_table->round_alloc_size = saved_line_table->round_alloc_size; line_table->default_range_bits = case_.m_default_range_bits; if (case_.m_base_location) { line_table->highest_location = case_.m_base_location; line_table->highest_line = case_.m_base_location; } } /* Destructor. Restore the old value of line_table. */ line_table_test::~line_table_test () { gcc_assert (saved_line_table != NULL); line_table = saved_line_table; saved_line_table = NULL; } /* Verify basic operation of ordinary linemaps. */ static void test_accessing_ordinary_linemaps (const line_table_case &case_) { line_table_test ltt (case_); /* Build a simple linemap describing some locations. */ linemap_add (line_table, LC_ENTER, false, "foo.c", 0); linemap_line_start (line_table, 1, 100); location_t loc_a = linemap_position_for_column (line_table, 1); location_t loc_b = linemap_position_for_column (line_table, 23); linemap_line_start (line_table, 2, 100); location_t loc_c = linemap_position_for_column (line_table, 1); location_t loc_d = linemap_position_for_column (line_table, 17); /* Example of a very long line. */ linemap_line_start (line_table, 3, 2000); location_t loc_e = linemap_position_for_column (line_table, 700); linemap_add (line_table, LC_LEAVE, false, NULL, 0); /* Multiple files. */ linemap_add (line_table, LC_ENTER, false, "bar.c", 0); linemap_line_start (line_table, 1, 200); location_t loc_f = linemap_position_for_column (line_table, 150); linemap_add (line_table, LC_LEAVE, false, NULL, 0); /* Verify that we can recover the location info. */ assert_loceq ("foo.c", 1, 1, loc_a); assert_loceq ("foo.c", 1, 23, loc_b); assert_loceq ("foo.c", 2, 1, loc_c); assert_loceq ("foo.c", 2, 17, loc_d); assert_loceq ("foo.c", 3, 700, loc_e); assert_loceq ("bar.c", 1, 150, loc_f); ASSERT_FALSE (is_location_from_builtin_token (loc_a)); ASSERT_TRUE (pure_location_p (line_table, loc_a)); /* Verify using make_location to build a range, and extracting data back from it. */ location_t range_c_b_d = make_location (loc_c, loc_b, loc_d); ASSERT_FALSE (pure_location_p (line_table, range_c_b_d)); ASSERT_EQ (loc_c, get_location_from_adhoc_loc (line_table, range_c_b_d)); source_range src_range = get_range_from_loc (line_table, range_c_b_d); ASSERT_EQ (loc_b, src_range.m_start); ASSERT_EQ (loc_d, src_range.m_finish); } /* Verify various properties of UNKNOWN_LOCATION. */ static void test_unknown_location () { ASSERT_EQ (NULL, LOCATION_FILE (UNKNOWN_LOCATION)); ASSERT_EQ (0, LOCATION_LINE (UNKNOWN_LOCATION)); ASSERT_EQ (0, LOCATION_COLUMN (UNKNOWN_LOCATION)); } /* Verify various properties of BUILTINS_LOCATION. */ static void test_builtins () { assert_loceq (_("<built-in>"), 0, 0, BUILTINS_LOCATION); ASSERT_PRED1 (is_location_from_builtin_token, BUILTINS_LOCATION); } /* Regression test for make_location. Ensure that we use pure locations for the start/finish of the range, rather than storing a packed or ad-hoc range as the start/finish. */ static void test_make_location_nonpure_range_endpoints (const line_table_case &case_) { /* Issue seen with testsuite/c-c++-common/Wlogical-not-parentheses-2.c with C++ frontend. ....................0000000001111111111222. ....................1234567890123456789012. */ const char *content = " r += !aaa == bbb;\n"; temp_source_file tmp (SELFTEST_LOCATION, ".C", content); line_table_test ltt (case_); linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 1); const location_t c11 = linemap_position_for_column (line_table, 11); const location_t c12 = linemap_position_for_column (line_table, 12); const location_t c13 = linemap_position_for_column (line_table, 13); const location_t c14 = linemap_position_for_column (line_table, 14); const location_t c21 = linemap_position_for_column (line_table, 21); if (c21 > LINE_MAP_MAX_LOCATION_WITH_COLS) return; /* Use column 13 for the caret location, arbitrarily, to verify that we handle start != caret. */ const location_t aaa = make_location (c13, c12, c14); ASSERT_EQ (c13, get_pure_location (aaa)); ASSERT_EQ (c12, get_start (aaa)); ASSERT_FALSE (IS_ADHOC_LOC (get_start (aaa))); ASSERT_EQ (c14, get_finish (aaa)); ASSERT_FALSE (IS_ADHOC_LOC (get_finish (aaa))); /* Make a location using a location with a range as the start-point. */ const location_t not_aaa = make_location (c11, aaa, c14); ASSERT_EQ (c11, get_pure_location (not_aaa)); /* It should use the start location of the range, not store the range itself. */ ASSERT_EQ (c12, get_start (not_aaa)); ASSERT_FALSE (IS_ADHOC_LOC (get_start (not_aaa))); ASSERT_EQ (c14, get_finish (not_aaa)); ASSERT_FALSE (IS_ADHOC_LOC (get_finish (not_aaa))); /* Similarly, make a location with a range as the end-point. */ const location_t aaa_eq_bbb = make_location (c12, c12, c21); ASSERT_EQ (c12, get_pure_location (aaa_eq_bbb)); ASSERT_EQ (c12, get_start (aaa_eq_bbb)); ASSERT_FALSE (IS_ADHOC_LOC (get_start (aaa_eq_bbb))); ASSERT_EQ (c21, get_finish (aaa_eq_bbb)); ASSERT_FALSE (IS_ADHOC_LOC (get_finish (aaa_eq_bbb))); const location_t not_aaa_eq_bbb = make_location (c11, c12, aaa_eq_bbb); /* It should use the finish location of the range, not store the range itself. */ ASSERT_EQ (c11, get_pure_location (not_aaa_eq_bbb)); ASSERT_EQ (c12, get_start (not_aaa_eq_bbb)); ASSERT_FALSE (IS_ADHOC_LOC (get_start (not_aaa_eq_bbb))); ASSERT_EQ (c21, get_finish (not_aaa_eq_bbb)); ASSERT_FALSE (IS_ADHOC_LOC (get_finish (not_aaa_eq_bbb))); } /* Verify reading of input files (e.g. for caret-based diagnostics). */ static void test_reading_source_line () { /* Create a tempfile and write some text to it. */ temp_source_file tmp (SELFTEST_LOCATION, ".txt", "01234567890123456789\n" "This is the test text\n" "This is the 3rd line"); /* Read back a specific line from the tempfile. */ int line_size; const char *source_line = location_get_source_line (tmp.get_filename (), 3, &line_size); ASSERT_TRUE (source_line != NULL); ASSERT_EQ (20, line_size); ASSERT_TRUE (!strncmp ("This is the 3rd line", source_line, line_size)); source_line = location_get_source_line (tmp.get_filename (), 2, &line_size); ASSERT_TRUE (source_line != NULL); ASSERT_EQ (21, line_size); ASSERT_TRUE (!strncmp ("This is the test text", source_line, line_size)); source_line = location_get_source_line (tmp.get_filename (), 4, &line_size); ASSERT_TRUE (source_line == NULL); } /* Tests of lexing. */ /* Verify that token TOK from PARSER has cpp_token_as_text equal to EXPECTED_TEXT. */ #define ASSERT_TOKEN_AS_TEXT_EQ(PARSER, TOK, EXPECTED_TEXT) \ SELFTEST_BEGIN_STMT \ unsigned char *actual_txt = cpp_token_as_text ((PARSER), (TOK)); \ ASSERT_STREQ ((EXPECTED_TEXT), (const char *)actual_txt); \ SELFTEST_END_STMT /* Verify that TOK's src_loc is within EXP_FILENAME at EXP_LINENUM, and ranges from EXP_START_COL to EXP_FINISH_COL. Use LOC as the effective location of the selftest. */ static void assert_token_loc_eq (const location &loc, const cpp_token *tok, const char *exp_filename, int exp_linenum, int exp_start_col, int exp_finish_col) { location_t tok_loc = tok->src_loc; ASSERT_STREQ_AT (loc, exp_filename, LOCATION_FILE (tok_loc)); ASSERT_EQ_AT (loc, exp_linenum, LOCATION_LINE (tok_loc)); /* If location_t values are sufficiently high, then column numbers will be unavailable. */ if (!should_have_column_data_p (tok_loc)) return; ASSERT_EQ_AT (loc, exp_start_col, LOCATION_COLUMN (tok_loc)); source_range tok_range = get_range_from_loc (line_table, tok_loc); ASSERT_EQ_AT (loc, exp_start_col, LOCATION_COLUMN (tok_range.m_start)); ASSERT_EQ_AT (loc, exp_finish_col, LOCATION_COLUMN (tok_range.m_finish)); } /* Use assert_token_loc_eq to verify the TOK->src_loc, using SELFTEST_LOCATION as the effective location of the selftest. */ #define ASSERT_TOKEN_LOC_EQ(TOK, EXP_FILENAME, EXP_LINENUM, \ EXP_START_COL, EXP_FINISH_COL) \ assert_token_loc_eq (SELFTEST_LOCATION, (TOK), (EXP_FILENAME), \ (EXP_LINENUM), (EXP_START_COL), (EXP_FINISH_COL)) /* Test of lexing a file using libcpp, verifying tokens and their location information. */ static void test_lexer (const line_table_case &case_) { /* Create a tempfile and write some text to it. */ const char *content = /*00000000011111111112222222222333333.3333444444444.455555555556 12345678901234567890123456789012345.6789012345678.901234567890. */ ("test_name /* c-style comment */\n" " \"test literal\"\n" " // test c++-style comment\n" " 42\n"); temp_source_file tmp (SELFTEST_LOCATION, ".txt", content); line_table_test ltt (case_); cpp_reader *parser = cpp_create_reader (CLK_GNUC89, NULL, line_table); const char *fname = cpp_read_main_file (parser, tmp.get_filename ()); ASSERT_NE (fname, NULL); /* Verify that we get the expected tokens back, with the correct location information. */ location_t loc; const cpp_token *tok; tok = cpp_get_token_with_location (parser, &loc); ASSERT_NE (tok, NULL); ASSERT_EQ (tok->type, CPP_NAME); ASSERT_TOKEN_AS_TEXT_EQ (parser, tok, "test_name"); ASSERT_TOKEN_LOC_EQ (tok, tmp.get_filename (), 1, 1, 9); tok = cpp_get_token_with_location (parser, &loc); ASSERT_NE (tok, NULL); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (parser, tok, "\"test literal\""); ASSERT_TOKEN_LOC_EQ (tok, tmp.get_filename (), 2, 35, 48); tok = cpp_get_token_with_location (parser, &loc); ASSERT_NE (tok, NULL); ASSERT_EQ (tok->type, CPP_NUMBER); ASSERT_TOKEN_AS_TEXT_EQ (parser, tok, "42"); ASSERT_TOKEN_LOC_EQ (tok, tmp.get_filename (), 4, 4, 5); tok = cpp_get_token_with_location (parser, &loc); ASSERT_NE (tok, NULL); ASSERT_EQ (tok->type, CPP_EOF); cpp_finish (parser, NULL); cpp_destroy (parser); } /* Forward decls. */ struct lexer_test; class lexer_test_options; /* A class for specifying options of a lexer_test. The "apply" vfunc is called during the lexer_test constructor. */ class lexer_test_options { public: virtual void apply (lexer_test &) = 0; }; /* A struct for writing lexer tests. */ struct lexer_test { lexer_test (const line_table_case &case_, const char *content, lexer_test_options *options); ~lexer_test (); const cpp_token *get_token (); temp_source_file m_tempfile; line_table_test m_ltt; cpp_reader *m_parser; string_concat_db m_concats; }; /* Use an EBCDIC encoding for the execution charset, specifically IBM1047-encoded (aka "EBCDIC 1047", or "Code page 1047"). This exercises iconv integration within libcpp. Not every build of iconv supports the given charset, so we need to flag this error and handle it gracefully. */ class ebcdic_execution_charset : public lexer_test_options { public: ebcdic_execution_charset () : m_num_iconv_errors (0) { gcc_assert (s_singleton == NULL); s_singleton = this; } ~ebcdic_execution_charset () { gcc_assert (s_singleton == this); s_singleton = NULL; } void apply (lexer_test &test) FINAL OVERRIDE { cpp_options *cpp_opts = cpp_get_options (test.m_parser); cpp_opts->narrow_charset = "IBM1047"; cpp_callbacks *callbacks = cpp_get_callbacks (test.m_parser); callbacks->error = on_error; } static bool on_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level ATTRIBUTE_UNUSED, int reason ATTRIBUTE_UNUSED, rich_location *richloc ATTRIBUTE_UNUSED, const char *msgid, va_list *ap ATTRIBUTE_UNUSED) ATTRIBUTE_FPTR_PRINTF(5,0) { gcc_assert (s_singleton); /* Detect and record errors emitted by libcpp/charset.c:init_iconv_desc when the local iconv build doesn't support the conversion. */ if (strstr (msgid, "not supported by iconv")) { s_singleton->m_num_iconv_errors++; return true; } /* Otherwise, we have an unexpected error. */ abort (); } bool iconv_errors_occurred_p () const { return m_num_iconv_errors > 0; } private: static ebcdic_execution_charset *s_singleton; int m_num_iconv_errors; }; ebcdic_execution_charset *ebcdic_execution_charset::s_singleton; /* Constructor. Override line_table with a new instance based on CASE_, and write CONTENT to a tempfile. Create a cpp_reader, and use it to start parsing the tempfile. */ lexer_test::lexer_test (const line_table_case &case_, const char *content, lexer_test_options *options) : /* Create a tempfile and write the text to it. */ m_tempfile (SELFTEST_LOCATION, ".c", content), m_ltt (case_), m_parser (cpp_create_reader (CLK_GNUC99, NULL, line_table)), m_concats () { if (options) options->apply (*this); cpp_init_iconv (m_parser); /* Parse the file. */ const char *fname = cpp_read_main_file (m_parser, m_tempfile.get_filename ()); ASSERT_NE (fname, NULL); } /* Destructor. Verify that the next token in m_parser is EOF. */ lexer_test::~lexer_test () { location_t loc; const cpp_token *tok; tok = cpp_get_token_with_location (m_parser, &loc); ASSERT_NE (tok, NULL); ASSERT_EQ (tok->type, CPP_EOF); cpp_finish (m_parser, NULL); cpp_destroy (m_parser); } /* Get the next token from m_parser. */ const cpp_token * lexer_test::get_token () { location_t loc; const cpp_token *tok; tok = cpp_get_token_with_location (m_parser, &loc); ASSERT_NE (tok, NULL); return tok; } /* Verify that locations within string literals are correctly handled. */ /* Verify get_source_range_for_substring for token(s) at STRLOC, using the string concatenation database for TEST. Assert that the character at index IDX is on EXPECTED_LINE, and that it begins at column EXPECTED_START_COL and ends at EXPECTED_FINISH_COL (unless the locations are beyond LINE_MAP_MAX_LOCATION_WITH_COLS, in which case don't check their columns). */ static void assert_char_at_range (const location &loc, lexer_test& test, location_t strloc, enum cpp_ttype type, int idx, int expected_line, int expected_start_col, int expected_finish_col) { cpp_reader *pfile = test.m_parser; string_concat_db *concats = &test.m_concats; source_range actual_range; const char *err = get_source_range_for_char (pfile, concats, strloc, type, idx, &actual_range); if (should_have_column_data_p (strloc)) ASSERT_EQ_AT (loc, NULL, err); else { ASSERT_STREQ_AT (loc, "range starts after LINE_MAP_MAX_LOCATION_WITH_COLS", err); return; } int actual_start_line = LOCATION_LINE (actual_range.m_start); ASSERT_EQ_AT (loc, expected_line, actual_start_line); int actual_finish_line = LOCATION_LINE (actual_range.m_finish); ASSERT_EQ_AT (loc, expected_line, actual_finish_line); if (should_have_column_data_p (actual_range.m_start)) { int actual_start_col = LOCATION_COLUMN (actual_range.m_start); ASSERT_EQ_AT (loc, expected_start_col, actual_start_col); } if (should_have_column_data_p (actual_range.m_finish)) { int actual_finish_col = LOCATION_COLUMN (actual_range.m_finish); ASSERT_EQ_AT (loc, expected_finish_col, actual_finish_col); } } /* Macro for calling assert_char_at_range, supplying SELFTEST_LOCATION for the effective location of any errors. */ #define ASSERT_CHAR_AT_RANGE(LEXER_TEST, STRLOC, TYPE, IDX, EXPECTED_LINE, \ EXPECTED_START_COL, EXPECTED_FINISH_COL) \ assert_char_at_range (SELFTEST_LOCATION, (LEXER_TEST), (STRLOC), (TYPE), \ (IDX), (EXPECTED_LINE), (EXPECTED_START_COL), \ (EXPECTED_FINISH_COL)) /* Verify get_num_source_ranges_for_substring for token(s) at STRLOC, using the string concatenation database for TEST. Assert that the token(s) at STRLOC contain EXPECTED_NUM_RANGES. */ static void assert_num_substring_ranges (const location &loc, lexer_test& test, location_t strloc, enum cpp_ttype type, int expected_num_ranges) { cpp_reader *pfile = test.m_parser; string_concat_db *concats = &test.m_concats; int actual_num_ranges = -1; const char *err = get_num_source_ranges_for_substring (pfile, concats, strloc, type, &actual_num_ranges); if (should_have_column_data_p (strloc)) ASSERT_EQ_AT (loc, NULL, err); else { ASSERT_STREQ_AT (loc, "range starts after LINE_MAP_MAX_LOCATION_WITH_COLS", err); return; } ASSERT_EQ_AT (loc, expected_num_ranges, actual_num_ranges); } /* Macro for calling assert_num_substring_ranges, supplying SELFTEST_LOCATION for the effective location of any errors. */ #define ASSERT_NUM_SUBSTRING_RANGES(LEXER_TEST, STRLOC, TYPE, \ EXPECTED_NUM_RANGES) \ assert_num_substring_ranges (SELFTEST_LOCATION, (LEXER_TEST), (STRLOC), \ (TYPE), (EXPECTED_NUM_RANGES)) /* Verify that get_num_source_ranges_for_substring for token(s) at STRLOC returns an error (using the string concatenation database for TEST). */ static void assert_has_no_substring_ranges (const location &loc, lexer_test& test, location_t strloc, enum cpp_ttype type, const char *expected_err) { cpp_reader *pfile = test.m_parser; string_concat_db *concats = &test.m_concats; cpp_substring_ranges ranges; const char *actual_err = get_substring_ranges_for_loc (pfile, concats, strloc, type, ranges); if (should_have_column_data_p (strloc)) ASSERT_STREQ_AT (loc, expected_err, actual_err); else ASSERT_STREQ_AT (loc, "range starts after LINE_MAP_MAX_LOCATION_WITH_COLS", actual_err); } #define ASSERT_HAS_NO_SUBSTRING_RANGES(LEXER_TEST, STRLOC, TYPE, ERR) \ assert_has_no_substring_ranges (SELFTEST_LOCATION, (LEXER_TEST), \ (STRLOC), (TYPE), (ERR)) /* Lex a simple string literal. Verify the substring location data, before and after running cpp_interpret_string on it. */ static void test_lexer_string_locations_simple (const line_table_case &case_) { /* Digits 0-9 (with 0 at column 10), the simple way. ....................000000000.11111111112.2222222223333333333 ....................123456789.01234567890.1234567890123456789 We add a trailing comment to ensure that we correctly locate the end of the string literal token. */ const char *content = " \"0123456789\" /* not a string */\n"; lexer_test test (case_, content, NULL); /* Verify that we get the expected token back, with the correct location information. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (test.m_parser, tok, "\"0123456789\""); ASSERT_TOKEN_LOC_EQ (tok, test.m_tempfile.get_filename (), 1, 9, 20); /* At this point in lexing, the quote characters are treated as part of the string (they are stripped off by cpp_interpret_string). */ ASSERT_EQ (tok->val.str.len, 12); /* Verify that cpp_interpret_string works. */ cpp_string dst_string; const enum cpp_ttype type = CPP_STRING; bool result = cpp_interpret_string (test.m_parser, &tok->val.str, 1, &dst_string, type); ASSERT_TRUE (result); ASSERT_STREQ ("0123456789", (const char *)dst_string.text); free (const_cast <unsigned char *> (dst_string.text)); /* Verify ranges of individual characters. This no longer includes the opening quote, but does include the closing quote. */ for (int i = 0; i <= 10; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, i, 1, 10 + i, 10 + i); ASSERT_NUM_SUBSTRING_RANGES (test, tok->src_loc, type, 11); } /* As test_lexer_string_locations_simple, but use an EBCDIC execution encoding. */ static void test_lexer_string_locations_ebcdic (const line_table_case &case_) { /* EBCDIC support requires iconv. */ if (!HAVE_ICONV) return; /* Digits 0-9 (with 0 at column 10), the simple way. ....................000000000.11111111112.2222222223333333333 ....................123456789.01234567890.1234567890123456789 We add a trailing comment to ensure that we correctly locate the end of the string literal token. */ const char *content = " \"0123456789\" /* not a string */\n"; ebcdic_execution_charset use_ebcdic; lexer_test test (case_, content, &use_ebcdic); /* Verify that we get the expected token back, with the correct location information. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (test.m_parser, tok, "\"0123456789\""); ASSERT_TOKEN_LOC_EQ (tok, test.m_tempfile.get_filename (), 1, 9, 20); /* At this point in lexing, the quote characters are treated as part of the string (they are stripped off by cpp_interpret_string). */ ASSERT_EQ (tok->val.str.len, 12); /* The remainder of the test requires an iconv implementation that can convert from UTF-8 to the EBCDIC encoding requested above. */ if (use_ebcdic.iconv_errors_occurred_p ()) return; /* Verify that cpp_interpret_string works. */ cpp_string dst_string; const enum cpp_ttype type = CPP_STRING; bool result = cpp_interpret_string (test.m_parser, &tok->val.str, 1, &dst_string, type); ASSERT_TRUE (result); /* We should now have EBCDIC-encoded text, specifically IBM1047-encoded (aka "EBCDIC 1047", or "Code page 1047"). The digits 0-9 are encoded as 240-249 i.e. 0xf0-0xf9. */ ASSERT_STREQ ("\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9", (const char *)dst_string.text); free (const_cast <unsigned char *> (dst_string.text)); /* Verify that we don't attempt to record substring location information for such cases. */ ASSERT_HAS_NO_SUBSTRING_RANGES (test, tok->src_loc, type, "execution character set != source character set"); } /* Lex a string literal containing a hex-escaped character. Verify the substring location data, before and after running cpp_interpret_string on it. */ static void test_lexer_string_locations_hex (const line_table_case &case_) { /* Digits 0-9, expressing digit 5 in ASCII as "\x35" and with a space in place of digit 6, to terminate the escaped hex code. ....................000000000.111111.11112222. ....................123456789.012345.67890123. */ const char *content = " \"01234\\x35 789\"\n"; lexer_test test (case_, content, NULL); /* Verify that we get the expected token back, with the correct location information. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (test.m_parser, tok, "\"01234\\x35 789\""); ASSERT_TOKEN_LOC_EQ (tok, test.m_tempfile.get_filename (), 1, 9, 23); /* At this point in lexing, the quote characters are treated as part of the string (they are stripped off by cpp_interpret_string). */ ASSERT_EQ (tok->val.str.len, 15); /* Verify that cpp_interpret_string works. */ cpp_string dst_string; const enum cpp_ttype type = CPP_STRING; bool result = cpp_interpret_string (test.m_parser, &tok->val.str, 1, &dst_string, type); ASSERT_TRUE (result); ASSERT_STREQ ("012345 789", (const char *)dst_string.text); free (const_cast <unsigned char *> (dst_string.text)); /* Verify ranges of individual characters. This no longer includes the opening quote, but does include the closing quote. */ for (int i = 0; i <= 4; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, i, 1, 10 + i, 10 + i); ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, 5, 1, 15, 18); for (int i = 6; i <= 10; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, i, 1, 13 + i, 13 + i); ASSERT_NUM_SUBSTRING_RANGES (test, tok->src_loc, type, 11); } /* Lex a string literal containing an octal-escaped character. Verify the substring location data after running cpp_interpret_string on it. */ static void test_lexer_string_locations_oct (const line_table_case &case_) { /* Digits 0-9, expressing digit 5 in ASCII as "\065" and with a space in place of digit 6, to terminate the escaped octal code. ....................000000000.111111.11112222.2222223333333333444 ....................123456789.012345.67890123.4567890123456789012 */ const char *content = " \"01234\\065 789\" /* not a string */\n"; lexer_test test (case_, content, NULL); /* Verify that we get the expected token back, with the correct location information. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (test.m_parser, tok, "\"01234\\065 789\""); /* Verify that cpp_interpret_string works. */ cpp_string dst_string; const enum cpp_ttype type = CPP_STRING; bool result = cpp_interpret_string (test.m_parser, &tok->val.str, 1, &dst_string, type); ASSERT_TRUE (result); ASSERT_STREQ ("012345 789", (const char *)dst_string.text); free (const_cast <unsigned char *> (dst_string.text)); /* Verify ranges of individual characters. This no longer includes the opening quote, but does include the closing quote. */ for (int i = 0; i < 5; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, i, 1, 10 + i, 10 + i); ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, 5, 1, 15, 18); for (int i = 6; i <= 10; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, type, i, 1, 13 + i, 13 + i); ASSERT_NUM_SUBSTRING_RANGES (test, tok->src_loc, type, 11); } /* Test of string literal containing letter escapes. */ static void test_lexer_string_locations_letter_escape_1 (const line_table_case &case_) { /* The string "\tfoo\\\nbar" i.e. tab, "foo", backslash, newline, bar. .....................000000000.1.11111.1.1.11222.22222223333333 .....................123456789.0.12345.6.7.89012.34567890123456. */ const char *content = (" \"\\tfoo\\\\\\nbar\" /* non-str */\n"); lexer_test test (case_, content, NULL); /* Verify that we get the expected tokens back. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING); ASSERT_TOKEN_AS_TEXT_EQ (test.m_parser, tok, "\"\\tfoo\\\\\\nbar\""); /* Verify ranges of individual characters. */ /* "\t". */ ASSERT_CHAR_AT_RANGE (test, tok->src_loc, CPP_STRING, 0, 1, 10, 11); /* "foo". */ for (int i = 1; i <= 3; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, CPP_STRING, i, 1, 11 + i, 11 + i); /* "\\" and "\n". */ ASSERT_CHAR_AT_RANGE (test, tok->src_loc, CPP_STRING, 4, 1, 15, 16); ASSERT_CHAR_AT_RANGE (test, tok->src_loc, CPP_STRING, 5, 1, 17, 18); /* "bar" and closing quote for nul-terminator. */ for (int i = 6; i <= 9; i++) ASSERT_CHAR_AT_RANGE (test, tok->src_loc, CPP_STRING, i, 1, 13 + i, 13 + i); ASSERT_NUM_SUBSTRING_RANGES (test, tok->src_loc, CPP_STRING, 10); } /* Another test of a string literal containing a letter escape. Based on string seen in printf ("%-%\n"); in gcc.dg/format/c90-printf-1.c. */ static void test_lexer_string_locations_letter_escape_2 (const line_table_case &case_) { /* .....................000000000.1111.11.1111.22222222223. .....................123456789.0123.45.6789.01234567890. */ const char *content = (" \"%-%\\n\" /* non-str */\n"); lexer_test test (case_, content, NULL); /* Verify that we get the expected tokens back. */ const cpp_token *tok = test.get_token (); ASSERT_EQ (tok->type, CPP_STRING);


context:
space:
mode: