CbC/CbC_gcc: gcc/input.c comparison

comparison gcc/input.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Data and functions related to line maps and input files.
-Copyright (C) 2004-2017 Free Software Foundation, Inc.
+Copyright (C) 2004-2018 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
 /* 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.
+so the returned value's length has the actual length of the line.
-If the function fails, NULL is returned.  */
+If the function fails, a NULL char_span is returned.  */
-const char *
+char_span
-location_get_source_line (const char *file_path, int line,
+location_get_source_line (const char *file_path, int line)
-			  int *line_len)
 {
 char *buffer = NULL;
 ssize_t len;
 if (line == 0)
-return NULL;
+return char_span (NULL, 0);
 fcache *c = lookup_or_add_file_to_cache_tab (file_path);
 if (c == NULL)
-return NULL;
+return char_span (NULL, 0);
 bool read = read_line_num (c, line, &buffer, &len);
+if (!read)
-if (read && line_len)
+return char_span (NULL, 0);
-*line_len = len;
+return char_span (buffer, 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.  */
 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)
+expand_location_to_spelling_point (source_location loc,
-{
+				   enum location_aspect aspect)
-return expand_location_1 (loc, /*expansion_point_p=*/false,
+{
-			    LOCATION_ASPECT_CARET);
+return expand_location_1 (loc, /*expansion_point_p=*/false, aspect);
 }
 /* The rich_location class within libcpp requires a way to expand
 source_location instances, and relies on the client code
 providing a symbol named
 	  gcc_assert (pure_location_p (line_table, loc) );
 	  expanded_location exploc
 	    = linemap_expand_location (line_table, map, loc);
-	  if (0 == exploc.column)
+	  if (exploc.column == 0)
 	    {
 	      /* Beginning of a new source line: draw the line.  */
-	      int line_size;
+	      char_span line_text = location_get_source_line (exploc.file,
-	      const char *line_text = location_get_source_line (exploc.file,
+							      exploc.line);
-								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);
+		       (int)line_text.length (), line_text.get_buffer ());
 	      /* "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;
+	      size_t max_col = (1 << map->m_column_and_range_bits) - 1;
-	      if (max_col > line_size)
+	      if (max_col > line_text.length ())
-		max_col = line_size + 1;
+		max_col = line_text.length () + 1;
 	      int indent = 14 + strlen (exploc.file);
 	      /* Thousands.  */
 	      if (end_location > 999)
 /* 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.  */
+	  /* If the string token was within a macro expansion, then we can
-	return "macro expansion";
+	     cope with it for the simple case where we have a single token.
+	     Otherwise, bail out.  */
-if (src_range.m_start >= LINE_MAP_MAX_LOCATION_WITH_COLS)
+	  if (src_range.m_start != src_range.m_finish)
-	/* If so, we can't reliably determine where the token started within
+	    return "macro expansion";
-	   its line.  */
+	}
-	return "range starts after LINE_MAP_MAX_LOCATION_WITH_COLS";
+else
+	{
-if (src_range.m_finish >= LINE_MAP_MAX_LOCATION_WITH_COLS)
+	  if (src_range.m_start >= LINE_MAP_MAX_LOCATION_WITH_COLS)
-	/* If so, we can't reliably determine where the token finished within
+	    /* If so, we can't reliably determine where the token started within
-	   its line.  */
+	       its line.  */
-	return "range ends after LINE_MAP_MAX_LOCATION_WITH_COLS";
+	    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);
+	= expand_location_to_spelling_point (src_range.m_start,
+					     LOCATION_ASPECT_START);
 expanded_location finish
-	= expand_location_to_spelling_point (src_range.m_finish);
+	= expand_location_to_spelling_point (src_range.m_finish,
+					     LOCATION_ASPECT_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;
+char_span line = location_get_source_line (start.file, start.line);
-const char *line = location_get_source_line (start.file, start.line,
+if (!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;
+size_t literal_length = finish.column - start.column + 1;
-int literal_length = finish.column - start.column + 1;
 /* Ensure that we don't crash if we got the wrong location.  */
-if (line_width < (start.column - 1 + literal_length))
+if (line.length () < (start.column - 1 + literal_length))
 	return "line is not wide enough";
+char_span literal = line.subspan (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);
+from.text = (unsigned char *)literal.xstrdup ();
 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 *start_ord_map;
+linemap_resolve_location (line_table, src_range.m_start,
+				LRK_SPELLING_LOCATION, &start_ord_map);
 const line_map_ordinary *final_ord_map;
 linemap_resolve_location (line_table, src_range.m_finish,
-				LRK_MACRO_EXPANSION_POINT, &final_ord_map);
+				LRK_SPELLING_LOCATION, &final_ord_map);
+/* Bulletproofing.  We ought to only have different ordinary maps
+	 for start vs finish due to line-length jumps.  */
+if (start_ord_map != final_ord_map
+	  && start_ord_map->to_file != final_ord_map->to_file)
+	  return "start and finish are spelled in different ordinary maps";
 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);
 *out = ranges.get_num_ranges ();
 return NULL;
 }
 /* Selftests of location handling.  */
+/* Verify that compare() on linenum_type handles comparisons over the full
+range of the type.  */
+static void
+test_linenum_comparisons ()
+{
+linenum_type min_line (0);
+linenum_type max_line (0xffffffff);
+ASSERT_EQ (0, compare (min_line, min_line));
+ASSERT_EQ (0, compare (max_line, max_line));
+ASSERT_GT (compare (max_line, min_line), 0);
+ASSERT_LT (compare (min_line, max_line), 0);
+}
 /* Helper function for verifying location data: when location_t
 values are > LINE_MAP_MAX_LOCATION_WITH_COLS, they are treated
 as having column 0.  */
 			"01234567890123456789\n"
 			"This is the test text\n"
 			"This is the 3rd line");
 /* Read back a specific line from the tempfile.  */
-int line_size;
+char_span source_line = location_get_source_line (tmp.get_filename (), 3);
-const char *source_line = location_get_source_line (tmp.get_filename (),
+ASSERT_TRUE (source_line);
-						      3, &line_size);
+ASSERT_TRUE (source_line.get_buffer () != NULL);
-ASSERT_TRUE (source_line != NULL);
+ASSERT_EQ (20, source_line.length ());
-ASSERT_EQ (20, line_size);
 ASSERT_TRUE (!strncmp ("This is the 3rd line",
-			 source_line, line_size));
+			 source_line.get_buffer (), source_line.length ()));
-source_line = location_get_source_line (tmp.get_filename (),
+source_line = location_get_source_line (tmp.get_filename (), 2);
-					  2, &line_size);
+ASSERT_TRUE (source_line);
-ASSERT_TRUE (source_line != NULL);
+ASSERT_TRUE (source_line.get_buffer () != NULL);
-ASSERT_EQ (21, line_size);
+ASSERT_EQ (21, source_line.length ());
 ASSERT_TRUE (!strncmp ("This is the test text",
-			 source_line, line_size));
+			 source_line.get_buffer (), source_line.length ()));
-source_line = location_get_source_line (tmp.get_filename (),
+source_line = location_get_source_line (tmp.get_filename (), 4);
-					  4, &line_size);
+ASSERT_FALSE (source_line);
-ASSERT_TRUE (source_line == NULL);
+ASSERT_TRUE (source_line.get_buffer () == NULL);
 }
 /* Tests of lexing.  */
 /* Verify that token TOK from PARSER has cpp_token_as_text
 {
 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;
+callbacks->diagnostic = on_diagnostic;
 }
-static bool on_error (cpp_reader *pfile ATTRIBUTE_UNUSED,
+static bool on_diagnostic (cpp_reader *pfile ATTRIBUTE_UNUSED,
-			int level ATTRIBUTE_UNUSED,
+			     enum cpp_diagnostic_level level ATTRIBUTE_UNUSED,
-			int reason ATTRIBUTE_UNUSED,
+			     enum cpp_warning_reason reason ATTRIBUTE_UNUSED,
-			rich_location *richloc ATTRIBUTE_UNUSED,
+			     rich_location *richloc ATTRIBUTE_UNUSED,
-			const char *msgid, va_list *ap ATTRIBUTE_UNUSED)
+			     const char *msgid, va_list *ap ATTRIBUTE_UNUSED)
 ATTRIBUTE_FPTR_PRINTF(5,0)
 {
 gcc_assert (s_singleton);
 /* Avoid exgettext from picking this up, it is translated in libcpp.  */
 const char *msg = "conversion from %s to %s not supported by iconv";
 int m_num_iconv_errors;
 };
 ebcdic_execution_charset *ebcdic_execution_charset::s_singleton;
-/* A lexer_test_options subclass that records a list of error
+/* A lexer_test_options subclass that records a list of diagnostic
 messages emitted by the lexer.  */
-class lexer_error_sink : public lexer_test_options
+class lexer_diagnostic_sink : public lexer_test_options
 {
 public:
-lexer_error_sink ()
+lexer_diagnostic_sink ()
 {
 gcc_assert (s_singleton == NULL);
 s_singleton = this;
 }
-~lexer_error_sink ()
+~lexer_diagnostic_sink ()
 {
 gcc_assert (s_singleton == this);
 s_singleton = NULL;
 int i;
 char *str;
-FOR_EACH_VEC_ELT (m_errors, i, str)
+FOR_EACH_VEC_ELT (m_diagnostics, i, str)
 free (str);
 }
 void apply (lexer_test &test) FINAL OVERRIDE
 {
 cpp_callbacks *callbacks = cpp_get_callbacks (test.m_parser);
-callbacks->error = on_error;
+callbacks->diagnostic = on_diagnostic;
 }
-static bool on_error (cpp_reader *pfile ATTRIBUTE_UNUSED,
+static bool on_diagnostic (cpp_reader *pfile ATTRIBUTE_UNUSED,
-			int level ATTRIBUTE_UNUSED,
+			     enum cpp_diagnostic_level level ATTRIBUTE_UNUSED,
-			int reason ATTRIBUTE_UNUSED,
+			     enum cpp_warning_reason reason ATTRIBUTE_UNUSED,
-			rich_location *richloc ATTRIBUTE_UNUSED,
+			     rich_location *richloc ATTRIBUTE_UNUSED,
-			const char *msgid, va_list *ap)
+			     const char *msgid, va_list *ap)
 ATTRIBUTE_FPTR_PRINTF(5,0)
 {
 char *msg = xvasprintf (msgid, *ap);
-s_singleton->m_errors.safe_push (msg);
+s_singleton->m_diagnostics.safe_push (msg);
 return true;
 }
-auto_vec<char *> m_errors;
+auto_vec<char *> m_diagnostics;
 private:
-static lexer_error_sink *s_singleton;
+static lexer_diagnostic_sink *s_singleton;
 };
-lexer_error_sink *lexer_error_sink::s_singleton;
+lexer_diagnostic_sink *lexer_diagnostic_sink::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.  */
 static void
 test_lexer_string_locations_raw_string_unterminated (const line_table_case &case_)
 {
 const char *content = "R\"ouch()ouCh\" /* etc */";
-lexer_error_sink errors;
+lexer_diagnostic_sink diagnostics;
-lexer_test test (case_, content, &errors);
+lexer_test test (case_, content, &diagnostics);
 test.m_implicitly_expect_EOF = false;
 /* Attempt to parse the raw string.  */
 const cpp_token *tok = test.get_token ();
 ASSERT_EQ (tok->type, CPP_EOF);
-ASSERT_EQ (1, errors.m_errors.length ());
+ASSERT_EQ (1, diagnostics.m_diagnostics.length ());
 /* We expect the message "unterminated raw string"
 in the "cpplib" translation domain.
 It's not clear that dgettext is available on all supported hosts,
 so this assertion is commented-out for now.
 ASSERT_STREQ (dgettext ("cpplib", "unterminated raw string"),
-errors.m_errors[0]);
+diagnostics.m_diagnostics[0]);
 */
 }
 /* Test of lexing char constants.  */
 /* Run all of the selftests within this file.  */
 void
 input_c_tests ()
 {
+test_linenum_comparisons ();
 test_should_have_column_data_p ();
 test_unknown_location ();
 test_builtins ();
 for_each_line_table_case (test_make_location_nonpure_range_endpoints);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/input.c @ 131:84e7813d76e9