diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 18c4856..48c40a6 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -945,7 +945,7 @@ fname_as_string (int pretty_p)
   const char *name = "top level";
   char *namep;
   int vrb = 2, len;
-  cpp_string cstr = { 0, 0, {NULL, 0, 0} }, strname;
+  cpp_string cstr = { 0, 0 }, strname;
 
   if (!pretty_p)
     {
@@ -962,7 +962,7 @@ fname_as_string (int pretty_p)
   snprintf (namep, len, "\"%s\"", name);
   strname.text = (unsigned char *) namep;
   strname.len = len - 1;
-  strname.loc.init_raw (UNKNOWN_LOCATION, len, 1, 1, line_table);
+  //strname.loc.init_raw (UNKNOWN_LOCATION, len, 1, 1, line_table);
 
   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
     {
diff --git a/gcc/c-family/c-lex.c b/gcc/c-family/c-lex.c
index 8a722cf..20313e8 100644
--- a/gcc/c-family/c-lex.c
+++ b/gcc/c-family/c-lex.c
@@ -165,7 +165,7 @@ cb_ident (cpp_reader * ARG_UNUSED (pfile),
   if (!flag_no_ident)
     {
       /* Convert escapes in the string.  */
-      cpp_string cstr = { 0, 0, { NULL, 0, 0 } };
+      cpp_string cstr = { 0, 0 };
       if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
 	{
 	  targetm.asm_out.output_ident ((const char *) cstr.text);
@@ -1074,7 +1074,7 @@ interpret_fixed (const cpp_token *token, unsigned int flags)
 
 /* Ensure that src->loc has location data, hardcoding it to a single
    character at SRC_LOC if data is not already present.  */
-
+#if 0
 static void
 ensure_string_has_location (const cpp_string *str, source_location src_loc)
 {
@@ -1085,6 +1085,7 @@ ensure_string_has_location (const cpp_string *str, source_location src_loc)
       strloc->init_raw (src_loc, mutstr->len, 1, 1, line_table);
     }
 }
+#endif
 
 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
    UTF8STRING tokens into a tree, performing string constant
@@ -1117,9 +1118,9 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
   /* Try to avoid the overhead of creating and destroying an obstack
      for the common case of just one string.  */
   cpp_string str = tok->val.str;
-  ensure_string_has_location (&str, tok->src_loc);
+  //ensure_string_has_location (&str, tok->src_loc);
   cpp_string *strs = &str;
-  location_t str0_loc = tok->src_loc;
+  //location_t str0_loc = tok->src_loc;
 
   /* objc_at_sign_was_seen is only used when doing Objective-C string
      concatenation.  It is 'true' if we have seen an '@' before the
@@ -1164,12 +1165,12 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
       if (!concats)
 	{
 	  gcc_obstack_init (&str_ob);
-	  ensure_string_has_location (&str, str0_loc);
+	  //ensure_string_has_location (&str, str0_loc);
 	  obstack_grow (&str_ob, &str, sizeof (cpp_string));
 	}
 
       concats++;
-      ensure_string_has_location (&tok->val.str, tok->src_loc);
+      //ensure_string_has_location (&tok->val.str, tok->src_loc);
       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 
       if (objc_string)
@@ -1190,11 +1191,13 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
     warning (OPT_Wtraditional,
 	     "traditional C rejects string constant concatenation");
 
+  // FIXME: record the concatenation here???
+
   if ((translate
        ? cpp_interpret_string : cpp_interpret_string_notranslate)
       (parse_in, strs, concats + 1, &istr, type))
     {
-      value = build_string (istr.len, (const char *) istr.text, &istr.loc);
+      value = build_string (istr.len, (const char *) istr.text);//, &istr.loc);
       free (CONST_CAST (unsigned char *, istr.text));
     }
   else
@@ -1261,7 +1264,7 @@ lex_charconst (const cpp_token *token)
   unsigned int chars_seen;
   int unsignedp = 0;
 
-  ensure_string_has_location (&token->val.str, token->src_loc);
+  //ensure_string_has_location (&token->val.str, token->src_loc);
 
   result = cpp_interpret_charconst (parse_in, token,
 				    &chars_seen, &unsignedp);
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index c408bf2..17452f4 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -3878,7 +3878,7 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 
       str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
       str.len = TREE_STRING_LENGTH (string_tree);
-      str.loc.init_raw (tok->location, str.len, 1, 1, line_table);
+      //str.loc.init_raw (tok->location, str.len, 1, 1, line_table);
       count = 1;
 
       if (curr_tok_is_userdef_p)
@@ -3904,7 +3904,7 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 	  count++;
 	  str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
 	  str.len = TREE_STRING_LENGTH (string_tree);
-	  str.loc.init_raw (tok->location, str.len, 1, 1, line_table);
+	  //str.loc.init_raw (tok->location, str.len, 1, 1, line_table);
 
 	  if (curr_tok_is_userdef_p)
 	    {
@@ -3978,7 +3978,7 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
   if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
       (parse_in, strs, count, &istr, type))
     {
-      value = build_string (istr.len, (const char *)istr.text, &istr.loc);
+      value = build_string (istr.len, (const char *)istr.text);//, &istr.loc);
       free (CONST_CAST (unsigned char *, istr.text));
 
       switch (type)
diff --git a/gcc/gcc-rich-location.c b/gcc/gcc-rich-location.c
index 8ac45f9..f073406 100644
--- a/gcc/gcc-rich-location.c
+++ b/gcc/gcc-rich-location.c
@@ -75,6 +75,7 @@ gcc_rich_location::add_fixit_misspelled_id (location_t misspelled_token_loc,
   add_fixit_replace (misspelled_token_range, IDENTIFIER_POINTER (hint_id));
 }
 
+#if 0
 /* Debugging method.  Print a diagnostic showing the given fragment.  */
 
 void
@@ -103,3 +104,4 @@ cpp_string_location::debug () const
       fragment->debug (buf);
     }
 }
+#endif
diff --git a/gcc/input.c b/gcc/input.c
index 3d497dd..f2939a4 100644
--- a/gcc/input.c
+++ b/gcc/input.c
@@ -1358,6 +1358,7 @@ test_builtins ()
 
 /* Verify that locations within string literals are correctly handled.  */
 
+#if 0
 /* Determine if we should verify the packing within cpp_string_location
    instances.  If any location is above LINE_MAP_MAX_LOCATION_WITH_COLS,
    the precise packing is likely to be unpredictable: some or all of
@@ -1387,12 +1388,120 @@ range_bits_verifiable_p ()
    LINE_MAP_MAX_LOCATION_WITH_COLS, in which case don't check their
    columns.  */
 
+#endif
+
+/* Given a string S of length LINE_WIDTH, find the visual column
+   corresponding to OFFSET bytes.   */
+
+static unsigned int
+location_column_from_byte_offset (const char *s, int line_width,
+				  int offset)
+{
+  const char * c = s;
+  if (*c != '"')
+    return 0;
+
+  c++, offset--;
+  while (offset >= 0)
+    {
+      if (c - s >= line_width)
+	return 0;
+
+      switch (*c)
+	{
+	case '\\':
+	  c++;
+	  if (c - s >= line_width)
+	    return 0;
+	  switch (*c)
+	    {
+	    case '\\': case '\'': case '"': case '?':
+	    case '(': case '{': case '[': case '%':
+	    case 'a': case 'b': case 'f': case 'n':
+	    case 'r': case 't': case 'v': 
+	    case 'e': case 'E':
+	      c++, offset--;
+	      break;
+
+	    default:
+	      return 0;
+	    }
+	  break;
+
+	case '"':
+	  /* We found the end of the string too early.  */
+	  return 0;
+	  
+	default:
+	  c++, offset--;
+	  break;
+	}
+    }
+  return c - s;
+}
+
+/* FIXME.  */
+
+bool
+source_range_for_substring (location_t strloc, int idx, source_range *out)
+{
+  gcc_checking_assert (idx >= 0);
+  gcc_assert (out);
+
+  expanded_location s = expand_location_to_spelling_point (strloc);
+  int line_width;
+  const char *line = location_get_source_line (s.file, s.line, &line_width);
+  if (line == NULL)
+    return false;
+
+  line += s.column - 1 ;
+  line_width -= s.column - 1;
+
+  unsigned int column
+    = location_column_from_byte_offset (line, line_width, idx);
+
+  location_t loc
+    = linemap_position_for_loc_and_offset (line_table, strloc, column);
+
+  *out = source_range::from_location (loc);
+  return true;
+}
+
+/* FIXME.  */
+
+bool
+source_range_for_substring (location_t strloc, int start_idx, int end_idx,
+			    source_range *out)
+{
+  gcc_checking_assert (start_idx >= 0);
+  gcc_checking_assert (end_idx >= 0);
+  gcc_assert (out);
+
+  source_range start_range;
+  source_range end_range;
+
+  if (!source_range_for_substring (strloc, start_idx, &start_range))
+    return false;
+
+  if (!source_range_for_substring (strloc, end_idx, &end_range))
+    return false;
+
+  out->m_start = start_range.m_start;
+  out->m_finish = end_range.m_finish;
+  return true;
+}
+
+/* FIXME.  */
+
 static void
 assert_char_at_range (const location &loc,
-		      const cpp_string_location *strloc, int idx,
+		      location_t strloc, int idx,
 		      int expected_start_col, int expected_finish_col)
 {
-  source_range actual_range = strloc->get_range_at_index (idx);
+  source_range actual_range;
+  bool result = source_range_for_substring (strloc, idx, &actual_range);
+  ASSERT_TRUE (result);
+
   if (should_have_column_data_p (actual_range.m_start))
     {
       int actual_start_col = LOCATION_COLUMN (actual_range.m_start);
@@ -1408,10 +1517,11 @@ assert_char_at_range (const location &loc,
 /* Macro for calling assert_char_at_range, supplying SELFTEST_LOCATION for
    the effective location of any errors.  */
 
-#define ASSERT_CHAR_AT_RANGE(IDX, EXPECTED_START_COL, EXPECTED_FINISH_COL) \
-  assert_char_at_range (SELFTEST_LOCATION, strloc, (IDX),		\
+#define ASSERT_CHAR_AT_RANGE(STRLOC, IDX, EXPECTED_START_COL, EXPECTED_FINISH_COL) \
+  assert_char_at_range (SELFTEST_LOCATION, (STRLOC), (IDX),		\
 			(EXPECTED_START_COL), (EXPECTED_FINISH_COL))
 
+#if 0
 /* Locate fragment IDX within STRLOC and assert that its various fields
    equal the provided values.  */
 
@@ -1670,6 +1780,7 @@ test_complex_substring_locations (const line_table_case &case_)
 
   linemap_add (line_table, LC_LEAVE, false, NULL, 0);
 }
+#endif
 
 /* TODO: a testcase involving more than one linemap.  */
 
@@ -1880,6 +1991,7 @@ test_lexer_string_locations_simple (const line_table_case &case_)
 
   ASSERT_EQ (tok->val.str.len, 12);
 
+#if 0
   const cpp_string_location *strloc = &tok->val.str.loc;
 
   /* If any of the data might be in no-columns mode, don't
@@ -1900,6 +2012,7 @@ test_lexer_string_locations_simple (const line_table_case &case_)
       (strloc, 0,
        linemap_position_for_column (line_table, 9),
        12, 1, case_.m_default_range_bits, 1);
+#endif
 
   /* Use cpp_interpret_string to extract the quoted characters
      into "dst_string".  */
@@ -1908,14 +2021,17 @@ test_lexer_string_locations_simple (const line_table_case &case_)
 				      &dst_string, CPP_STRING);
   ASSERT_TRUE (result);
 
+#if 0
   /* Verify dst_string.  */
   strloc = &dst_string.loc;
+#endif
 
   /* Verify ranges of individual characters.  This no longer includes the
      quotes.  */
   for (int i = 0; i < 9; i++)
-    ASSERT_CHAR_AT_RANGE(i, 10 + i, 10 + i);
+    ASSERT_CHAR_AT_RANGE (tok->src_loc, i, 10 + i, 10 + i);
 
+#if 0
   if (string_packing_verifiable_p ())
     {
       /* Verify packing.  */
@@ -1926,8 +2042,11 @@ test_lexer_string_locations_simple (const line_table_case &case_)
 	   linemap_position_for_column (line_table, 10),
 	   10, 1, case_.m_default_range_bits, 1);
     }
+#endif
 }
 
+#if 0
+
 /* Lex a string literal containing a hex-escaped character.
    Verify the substring location data, before and after running
    cpp_interpret_string on it.  */
@@ -2281,6 +2400,7 @@ test_lexer_string_locations_u8 (const line_table_case &case_)
 	   10, 1, case_.m_default_range_bits, 1);
     }
 }
+#endif
 
 /* A table of interesting location_t values, giving one axis of our test
    matrix.  */
@@ -2339,16 +2459,19 @@ input_c_tests ()
 
 	  /* Run all tests for the given case within the test matrix.  */
 	  test_accessing_ordinary_linemaps (c);
+#if 0
 	  test_simple_substring_locations (c);
 	  test_complex_substring_locations (c);
+#endif
 	  test_lexer (c);
 	  test_lexer_string_locations_simple (c);
+#if 0
 	  test_lexer_string_locations_hex (c);
 	  test_lexer_string_locations_oct (c);
 	  test_lexer_string_locations_ucn4 (c);
 	  test_lexer_string_locations_ucn8 (c);
 	  test_lexer_string_locations_u8 (c);
-
+#endif
 	  num_cases_tested++;
 	}
     }
diff --git a/gcc/tree-core.h b/gcc/tree-core.h
index a5fe5be..db5b470 100644
--- a/gcc/tree-core.h
+++ b/gcc/tree-core.h
@@ -1244,12 +1244,9 @@ struct GTY(()) tree_fixed_cst {
   struct fixed_value * fixed_cst_ptr;
 };
 
-struct cpp_string_location;
-
 struct GTY(()) tree_string {
   struct tree_typed typed;
   int length;
-  cpp_string_location *loc;
   char str[1];
 };
 
diff --git a/gcc/tree.c b/gcc/tree.c
index 0c13de1..afb8435 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -2004,13 +2004,13 @@ build_string (int len, const char *str)
   TREE_SET_CODE (s, STRING_CST);
   TREE_CONSTANT (s) = 1;
   TREE_STRING_LENGTH (s) = len;
-  TREE_STRING_LOCATION (s) = NULL;
   memcpy (s->string.str, str, len);
   s->string.str[len] = '\0';
 
   return s;
 }
 
+#if 0
 /* As above, but with per-character location information.  */
 
 struct cpp_string_location_stats cpp_string_location_stats;
@@ -2031,6 +2031,7 @@ build_string (int len, const char *str, cpp_string_location *strloc)
 
   return s;
 }
+#endif
 
 
 /* Return a newly constructed COMPLEX_CST node whose value is
diff --git a/gcc/tree.h b/gcc/tree.h
index b83b9c9..1e34fd0 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1005,7 +1005,6 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
 /* In a STRING_CST */
 /* In C terms, this is sizeof, not strlen.  */
 #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
-#define TREE_STRING_LOCATION(NODE) (STRING_CST_CHECK (NODE)->string.loc)
 #define TREE_STRING_POINTER(NODE) \
   ((const char *)(STRING_CST_CHECK (NODE)->string.str))
 
@@ -3968,7 +3967,6 @@ extern tree build_minus_one_cst (tree);
 extern tree build_all_ones_cst (tree);
 extern tree build_zero_cst (tree);
 extern tree build_string (int, const char *);
-extern tree build_string (int, const char *, cpp_string_location *);
 extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
 #define build_tree_list(t, q) build_tree_list_stat (t, q MEM_STAT_INFO)
 extern tree build_tree_list_vec_stat (const vec<tree, va_gc> *MEM_STAT_DECL);
diff --git a/libcpp/charset.c b/libcpp/charset.c
index 27a94da..503b770 100644
--- a/libcpp/charset.c
+++ b/libcpp/charset.c
@@ -99,7 +99,7 @@ struct _cpp_strbuf
   uchar *text;
   size_t asize;
   size_t len;
-  cpp_string_location loc;
+  //cpp_string_location loc;
 };
 
 /* This is enough to hold any string that fits on a single 80-column
@@ -454,8 +454,8 @@ one_utf16_to_utf8 (iconv_t bigend, const uchar **inbufp, size_t *inbytesleftp,
 static inline bool
 conversion_loop (int (*const one_conversion)(iconv_t, const uchar **, size_t *,
 					     uchar **, size_t *),
-		 iconv_t cd, const uchar *from, size_t flen, struct _cpp_strbuf *to,
-		 cpp_string_location_reader *loc_reader)
+		 iconv_t cd, const uchar *from, size_t flen, struct _cpp_strbuf *to)
+//cpp_string_location_reader *loc_reader)
 {
   const uchar *inbuf;
   uchar *outbuf;
@@ -471,9 +471,10 @@ conversion_loop (int (*const one_conversion)(iconv_t, const uchar **, size_t *,
     {
       do
 	{
-	  size_t old_outbytesleft = outbytesleft;
+	  //	  size_t old_outbytesleft = outbytesleft;
 	  rval = one_conversion (cd, &inbuf, &inbytesleft,
 				 &outbuf, &outbytesleft);
+#if 0
 	  if (loc_reader)
 	    {
 	      size_t bytes_written = outbytesleft - old_outbytesleft;
@@ -481,6 +482,7 @@ conversion_loop (int (*const one_conversion)(iconv_t, const uchar **, size_t *,
 				   bytes_written,
 				   loc_reader->get_line_maps ());
 	    }
+#endif
 	}
       while (inbytesleft && !rval);
 
@@ -516,42 +518,42 @@ conversion_loop (int (*const one_conversion)(iconv_t, const uchar **, size_t *,
 /* These four use the custom conversion code above.  */
 static bool
 convert_utf8_utf16 (iconv_t cd, const uchar *from, size_t flen,
-		    struct _cpp_strbuf *to, cpp_string_location_reader *loc_reader,
-		    bool single_item ATTRIBUTE_UNUSED)
+		    struct _cpp_strbuf *to)//, cpp_string_location_reader *loc_reader,
+//bool single_item ATTRIBUTE_UNUSED)
 {
-  return conversion_loop (one_utf8_to_utf16, cd, from, flen, to, loc_reader);
+  return conversion_loop (one_utf8_to_utf16, cd, from, flen, to);//, loc_reader);
 }
 
 static bool
 convert_utf8_utf32 (iconv_t cd, const uchar *from, size_t flen,
-		    struct _cpp_strbuf *to, cpp_string_location_reader *loc_reader,
-		    bool single_item ATTRIBUTE_UNUSED)
+		    struct _cpp_strbuf *to)//, cpp_string_location_reader *loc_reader,
+//bool single_item ATTRIBUTE_UNUSED)
 {
-  return conversion_loop (one_utf8_to_utf32, cd, from, flen, to, loc_reader);
+  return conversion_loop (one_utf8_to_utf32, cd, from, flen, to);//, loc_reader);
 }
 
 static bool
 convert_utf16_utf8 (iconv_t cd, const uchar *from, size_t flen,
-		    struct _cpp_strbuf *to, cpp_string_location_reader *loc_reader,
-		    bool single_item ATTRIBUTE_UNUSED)
+		    struct _cpp_strbuf *to)//, cpp_string_location_reader *loc_reader,
+//bool single_item ATTRIBUTE_UNUSED)
 {
-  return conversion_loop (one_utf16_to_utf8, cd, from, flen, to, loc_reader);
+  return conversion_loop (one_utf16_to_utf8, cd, from, flen, to);//, loc_reader);
 }
 
 static bool
 convert_utf32_utf8 (iconv_t cd, const uchar *from, size_t flen,
-		    struct _cpp_strbuf *to, cpp_string_location_reader *loc_reader,
-		    bool single_item ATTRIBUTE_UNUSED)
+		    struct _cpp_strbuf *to)//, cpp_string_location_reader *loc_reader,
+//bool single_item ATTRIBUTE_UNUSED)
 {
-  return conversion_loop (one_utf32_to_utf8, cd, from, flen, to, loc_reader);
+  return conversion_loop (one_utf32_to_utf8, cd, from, flen, to);//, loc_reader);
 }
 
 /* Identity conversion, used when we have no alternative.  */
 static bool
 convert_no_conversion (iconv_t cd ATTRIBUTE_UNUSED,
-		       const uchar *from, size_t flen, struct _cpp_strbuf *to,
-		       cpp_string_location_reader *loc_reader,
-		       bool single_item)
+		       const uchar *from, size_t flen, struct _cpp_strbuf *to)
+//cpp_string_location_reader *loc_reader,
+//bool single_item)
 {
   if (to->len + flen > to->asize)
     {
@@ -561,10 +563,12 @@ convert_no_conversion (iconv_t cd ATTRIBUTE_UNUSED,
     }
   memcpy (to->text + to->len, from, flen);
   to->len += flen;
+#if 0
   if (single_item)
     to->loc.add_n_chars_at (1, flen, loc_reader);
   else
     to->loc.add_n_chars_at (flen, 1, loc_reader);
+#endif
   return true;
 }
 
@@ -582,9 +586,9 @@ convert_no_conversion (iconv_t cd ATTRIBUTE_UNUSED,
 
 static bool
 convert_using_iconv (iconv_t cd, const uchar *from, size_t flen,
-		     struct _cpp_strbuf *to,
-		     cpp_string_location_reader */*loc_reader*/,
-		     bool single_item ATTRIBUTE_UNUSED)
+		     struct _cpp_strbuf *to)//,
+//cpp_string_location_reader */*loc_reader*/,
+//bool single_item ATTRIBUTE_UNUSED)
 {
   ICONV_CONST char *inbuf;
   char *outbuf;
@@ -631,8 +635,8 @@ convert_using_iconv (iconv_t cd, const uchar *from, size_t flen,
 /* Arrange for the above custom conversion logic to be used automatically
    when conversion between a suitable pair of character sets is requested.  */
 
-#define APPLY_CONVERSION(CONVERTER, FROM, FLEN, TO, LOC_READER, SINGLE_ITEM) \
-  CONVERTER.func (CONVERTER.cd, FROM, FLEN, TO, LOC_READER, SINGLE_ITEM)
+#define APPLY_CONVERSION(CONVERTER, FROM, FLEN, TO) /*, LOC_READER, SINGLE_ITEM) \*/ \
+  CONVERTER.func (CONVERTER.cd, FROM, FLEN, TO)//, LOC_READER, SINGLE_ITEM)
 
 struct cpp_conversion
 {
@@ -817,9 +821,9 @@ cpp_host_to_exec_charset (cpp_reader *pfile, cppchar_t c)
   tbuf.asize = 1;
   tbuf.text = XNEWVEC (uchar, tbuf.asize);
   tbuf.len = 0;
-  tbuf.loc.init ();
+  //tbuf.loc.init ();
 
-  if (!APPLY_CONVERSION (pfile->narrow_cset_desc, sbuf, 1, &tbuf, NULL, true))
+  if (!APPLY_CONVERSION (pfile->narrow_cset_desc, sbuf, 1, &tbuf))//, NULL, true))
     {
       cpp_errno (pfile, CPP_DL_ICE, "converting to execution character set");
       return 0;
@@ -1011,9 +1015,9 @@ ucn_valid_in_identifier (cpp_reader *pfile, cppchar_t c,
 bool
 _cpp_valid_ucn (cpp_reader *pfile, const uchar **pstr,
 		const uchar *limit, int identifier_pos,
-		struct normalize_state *nst, cppchar_t *cp,
-		source_range *char_range,
-		cpp_string_location_reader *loc_reader)
+		struct normalize_state *nst, cppchar_t *cp)//,
+//source_range *char_range)//,
+//cpp_string_location_reader *loc_reader)
 {
   cppchar_t result, c;
   unsigned int length;
@@ -1049,8 +1053,10 @@ _cpp_valid_ucn (cpp_reader *pfile, const uchar **pstr,
       if (!ISXDIGIT (c))
 	break;
       str++;
+#if 0
       if (char_range)
 	char_range->m_finish = loc_reader->get_next ().m_finish;
+#endif
       result = (result << 4) + hex_value (c);
     }
   while (--length && str < limit);
@@ -1120,9 +1126,9 @@ _cpp_valid_ucn (cpp_reader *pfile, const uchar **pstr,
    An advanced pointer is returned.  Issues all relevant diagnostics.  */
 static const uchar *
 convert_ucn (cpp_reader *pfile, const uchar *from, const uchar *limit,
-	     struct _cpp_strbuf *tbuf, struct cset_converter cvt,
-	     source_range char_range,
-	     cpp_string_location_reader *loc_reader)
+	     struct _cpp_strbuf *tbuf, struct cset_converter cvt)//,
+//source_range char_range)//,
+//cpp_string_location_reader *loc_reader)
 {
   cppchar_t ucn;
   uchar buf[6];
@@ -1133,11 +1139,13 @@ convert_ucn (cpp_reader *pfile, const uchar *from, const uchar *limit,
 
   from++;  /* Skip u/U.  */
 
+#if 0
   /* The u/U is part of the spelling of this character.  */
   char_range.m_finish = loc_reader->get_next ().m_finish;
+#endif
 
   _cpp_valid_ucn (pfile, &from, limit, 0, &nst,
-		  &ucn, &char_range, loc_reader);
+		  &ucn); // &char_range, loc_reader);
 
   rval = one_cppchar_to_utf8 (ucn, &bufp, &bytesleft);
   if (rval)
@@ -1151,14 +1159,16 @@ convert_ucn (cpp_reader *pfile, const uchar *from, const uchar *limit,
       /* Set up a cpp_string_location_reader to supply a
 	 location for the single character, covering all of
 	 char_range.  */
+#if 0
       cpp_string_location_reader buf_loc_reader
 	(char_range.m_start,
 	 (((char_range.m_finish - char_range.m_start)
 	   >> loc_reader->get_bits_per_col ()) + 1),
 	 loc_reader->get_bits_per_col (),
 	 loc_reader->get_line_maps ());
-      if (!APPLY_CONVERSION (cvt, buf, 6 - bytesleft, tbuf, &buf_loc_reader,
-			     true))
+#endif
+      if (!APPLY_CONVERSION (cvt, buf, 6 - bytesleft, tbuf))//, &buf_loc_reader,
+	//true))
 	cpp_errno (pfile, CPP_DL_ERROR,
 		   "converting UCN to execution character set");
     }
@@ -1224,9 +1234,11 @@ emit_numeric_escape (cpp_reader *pfile, cppchar_t n,
    number.  You can, e.g. generate surrogate pairs this way.  */
 static const uchar *
 convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
-	     struct _cpp_strbuf *tbuf, struct cset_converter cvt,
+	     struct _cpp_strbuf *tbuf, struct cset_converter cvt)//
+#if 0
 	     source_range char_range,
 	     cpp_string_location_reader *loc_reader)
+#endif
 {
   cppchar_t c, n = 0, overflow = 0;
   int digits_found = 0;
@@ -1241,7 +1253,7 @@ convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
   from++;
 
   /* The 'x' is part of the spelling of this character.  */
-  char_range.m_finish = loc_reader->get_next ().m_finish;
+  //char_range.m_finish = loc_reader->get_next ().m_finish;
 
   while (from < limit)
     {
@@ -1249,7 +1261,7 @@ convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
       if (! hex_p (c))
 	break;
       from++;
-      char_range.m_finish = loc_reader->get_next ().m_finish;
+      //char_range.m_finish = loc_reader->get_next ().m_finish;
       overflow |= n ^ (n << 4 >> 4);
       n = (n << 4) + hex_value (c);
       digits_found = 1;
@@ -1271,8 +1283,10 @@ convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
 
   emit_numeric_escape (pfile, n, tbuf, cvt);
 
+#if 0
   tbuf->loc.add_char_at (char_range, 1,
 			 pfile->line_table);
+#endif
 
   return from;
 }
@@ -1285,9 +1299,11 @@ convert_hex (cpp_reader *pfile, const uchar *from, const uchar *limit,
    number.  */
 static const uchar *
 convert_oct (cpp_reader *pfile, const uchar *from, const uchar *limit,
-	     struct _cpp_strbuf *tbuf, struct cset_converter cvt,
+	     struct _cpp_strbuf *tbuf, struct cset_converter cvt)//
+#if 0
 	     source_range char_range,
 	     cpp_string_location_reader *loc_reader)
+#endif
 {
   size_t count = 0;
   cppchar_t c, n = 0;
@@ -1301,7 +1317,7 @@ convert_oct (cpp_reader *pfile, const uchar *from, const uchar *limit,
       if (c < '0' || c > '7')
 	break;
       from++;
-      char_range.m_finish = loc_reader->get_next ().m_finish;
+      //char_range.m_finish = loc_reader->get_next ().m_finish;
       overflow |= n ^ (n << 3 >> 3);
       n = (n << 3) + c - '0';
     }
@@ -1315,8 +1331,10 @@ convert_oct (cpp_reader *pfile, const uchar *from, const uchar *limit,
 
   emit_numeric_escape (pfile, n, tbuf, cvt);
 
+#if 0
   tbuf->loc.add_char_at (char_range, 1,
 			 pfile->line_table);
+#endif
 
   return from;
 }
@@ -1327,8 +1345,8 @@ convert_oct (cpp_reader *pfile, const uchar *from, const uchar *limit,
    pointer.  Handles all relevant diagnostics.  */
 static const uchar *
 convert_escape (cpp_reader *pfile, const uchar *from, const uchar *limit,
-		struct _cpp_strbuf *tbuf, struct cset_converter cvt,
-		cpp_string_location_reader *loc_reader)
+		struct _cpp_strbuf *tbuf, struct cset_converter cvt)//,
+//cpp_string_location_reader *loc_reader)
 {
   /* Values of \a \b \e \f \n \r \t \v respectively.  */
 #if HOST_CHARSET == HOST_CHARSET_ASCII
@@ -1342,25 +1360,27 @@ convert_escape (cpp_reader *pfile, const uchar *from, const uchar *limit,
   uchar c;
 
   /* Record the location of the backslash.  */
+#if 0
   source_range char_range = loc_reader->get_next ();
+#endif
 
   c = *from;
   switch (c)
     {
       /* UCNs, hex escapes, and octal escapes are processed separately.  */
     case 'u': case 'U':
-      return convert_ucn (pfile, from, limit, tbuf, cvt,
-			  char_range, loc_reader);
+      return convert_ucn (pfile, from, limit, tbuf, cvt);
+      //char_range, loc_reader);
 
     case 'x':
-      return convert_hex (pfile, from, limit, tbuf, cvt,
-			  char_range, loc_reader);
+      return convert_hex (pfile, from, limit, tbuf, cvt);
+      //char_range, loc_reader);
       break;
 
     case '0':  case '1':  case '2':  case '3':
     case '4':  case '5':  case '6':  case '7':
-      return convert_oct (pfile, from, limit, tbuf, cvt,
-			  char_range, loc_reader);
+      return convert_oct (pfile, from, limit, tbuf, cvt);
+      //char_range, loc_reader);
 
       /* Various letter escapes.  Get the appropriate host-charset
 	 value into C.  */
@@ -1413,7 +1433,7 @@ convert_escape (cpp_reader *pfile, const uchar *from, const uchar *limit,
     }
 
   /* Now convert what we have to the execution character set.  */
-  if (!APPLY_CONVERSION (cvt, &c, 1, tbuf, loc_reader, true))
+  if (!APPLY_CONVERSION (cvt, &c, 1, tbuf))//, loc_reader, true))
     cpp_errno (pfile, CPP_DL_ERROR,
 	       "converting escape sequence to execution character set");
 
@@ -1462,20 +1482,20 @@ cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
   tbuf.asize = MAX (OUTBUF_BLOCK_SIZE, from->len);
   tbuf.text = XNEWVEC (uchar, tbuf.asize);
   tbuf.len = 0;
-  tbuf.loc.init ();
+  //tbuf.loc.init ();
 
   for (i = 0; i < count; i++)
     {
-      cpp_string_location_reader loc_reader (&from[i].loc, pfile->line_table);
+      //cpp_string_location_reader loc_reader (&from[i].loc, pfile->line_table);
       p = from[i].text;
       if (*p == 'u')
 	{
 	  p++;
-	  loc_reader.get_next ();
+	  //loc_reader.get_next ();
 	  if (*p == '8')
 	    {
 	      p++;
-	      loc_reader.get_next ();
+	      //loc_reader.get_next ();
 	    }
 	}
       else if (*p == 'L' || *p == 'U') p++;
@@ -1495,7 +1515,7 @@ cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
 
 	  /* Raw strings are all normal characters; these can be fed
 	     directly to convert_cset.  */
-	  if (!APPLY_CONVERSION (cvt, p, limit - p, &tbuf, &loc_reader, true))
+	  if (!APPLY_CONVERSION (cvt, p, limit - p, &tbuf))//, &loc_reader, true))
 	    goto fail;
 
 	  continue;
@@ -1503,7 +1523,7 @@ cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
 
       /* Skip leading quote.  */
       p++;
-      loc_reader.get_next ();
+      //loc_reader.get_next ();
 
       limit = from[i].text + from[i].len - 1; /* Skip trailing quote.  */
 
@@ -1516,14 +1536,14 @@ cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
 	    {
 	      /* We have a run of normal characters; these can be fed
 		 directly to convert_cset.  */
-	      if (!APPLY_CONVERSION (cvt, base, p - base, &tbuf, &loc_reader,
-				     false))
+	      if (!APPLY_CONVERSION (cvt, base, p - base, &tbuf))//, &loc_reader,
+		//false))
 		goto fail;
 	    }
 	  if (p == limit)
 	    break;
 
-	  p = convert_escape (pfile, p + 1, limit, &tbuf, cvt, &loc_reader);
+	  p = convert_escape (pfile, p + 1, limit, &tbuf, cvt);//, &loc_reader);
 	}
     }
   /* NUL-terminate the 'to' buffer and translate it to a cpp_string
@@ -1532,7 +1552,7 @@ cpp_interpret_string (cpp_reader *pfile, const cpp_string *from, size_t count,
   tbuf.text = XRESIZEVEC (uchar, tbuf.text, tbuf.len);
   to->text = tbuf.text;
   to->len = tbuf.len;
-  to->loc = tbuf.loc;
+  //to->loc = tbuf.loc;
   return true;
 
  fail:
@@ -1697,7 +1717,7 @@ cppchar_t
 cpp_interpret_charconst (cpp_reader *pfile, const cpp_token *token,
 			 unsigned int *pchars_seen, int *unsignedp)
 {
-  cpp_string str = { 0, 0, {NULL, 0, 0} };
+  cpp_string str = { 0, 0 };
   bool wide = (token->type != CPP_CHAR && token->type != CPP_UTF8CHAR);
   int u8 = 2 * int(token->type == CPP_UTF8CHAR);
   cppchar_t result;
@@ -1812,16 +1832,16 @@ _cpp_convert_input (cpp_reader *pfile, const char *input_charset,
       to.text = input;
       to.asize = size;
       to.len = len;
-      to.loc.init ();
+      //to.loc.init ();
     }
   else
     {
       to.asize = MAX (65536, len);
       to.text = XNEWVEC (uchar, to.asize);
       to.len = 0;
-      to.loc.init ();
+      //to.loc.init ();
 
-      if (!APPLY_CONVERSION (input_cset, input, len, &to, NULL, false))
+      if (!APPLY_CONVERSION (input_cset, input, len, &to))//, NULL, false))
 	cpp_error (pfile, CPP_DL_ERROR,
 		   "failure to convert %s to %s",
 		   CPP_OPTION (pfile, input_charset), SOURCE_CHARSET);
@@ -1918,6 +1938,7 @@ _cpp_default_encoding (void)
    is a cpp_string_location within struct cpp_string, and the latter
    is within union cpp_token_u within struct cpp_token.  */
 
+#if 0
 void
 cpp_string_location::init ()
 {
@@ -2146,3 +2167,4 @@ cpp_string_location_reader::get_next ()
   m_loc += m_cols_per_char << m_bits_per_col;
   return result;
 }
+#endif
diff --git a/libcpp/directives.c b/libcpp/directives.c
index b44a0af..772b835 100644
--- a/libcpp/directives.c
+++ b/libcpp/directives.c
@@ -950,7 +950,7 @@ do_line (cpp_reader *pfile)
   token = cpp_get_token (pfile);
   if (token->type == CPP_STRING)
     {
-      cpp_string s = { 0, 0, { NULL, 0, 0 } };
+      cpp_string s = { 0, 0 };
       if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
 					    &s, CPP_STRING))
 	new_file = (const char *)s.text;
@@ -1007,7 +1007,7 @@ do_linemarker (cpp_reader *pfile)
   token = cpp_get_token (pfile);
   if (token->type == CPP_STRING)
     {
-      cpp_string s = { 0, 0, { NULL, 0, 0 } };
+      cpp_string s = { 0, 0 };
       if (cpp_interpret_string_notranslate (pfile, &token->val.str,
 					    1, &s, CPP_STRING))
 	new_file = (const char *)s.text;
diff --git a/libcpp/expr.c b/libcpp/expr.c
index 072af5b..deaa3c5 100644
--- a/libcpp/expr.c
+++ b/libcpp/expr.c
@@ -1228,8 +1228,10 @@ _cpp_parse_expr (cpp_reader *pfile, bool is_if)
 			      "missing binary operator before token \"%s\"",
 			      cpp_token_as_text (pfile, op.token));
 	  want_value = false;
+#if 0
 	  ((cpp_token *)op.token)->val.str.loc.init_raw (op.loc, 1, 1, 1, /* FIXME */
 							 pfile->line_table);
+#endif
 	  top->value = eval_token (pfile, op.token, op.loc);
 	  continue;
 
diff --git a/libcpp/include/cpplib.h b/libcpp/include/cpplib.h
index a6b4420..870dfe5 100644
--- a/libcpp/include/cpplib.h
+++ b/libcpp/include/cpplib.h
@@ -173,6 +173,9 @@ enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11,
 	     CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
 	     CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX1Z, CLK_CXX1Z, CLK_ASM};
 
+#if 1
+//extern source_location cpp_get_substring_location (source_location 
+#else
 /* Location of the individual chars in a cpp_string.
    Specifically, this stores a run of characters of len, starting at loc,
    with a consistent number of columns per char.
@@ -327,12 +330,12 @@ class cpp_string_location_reader {
   int m_bits_per_col;
   line_maps *m_line_table;
 };
+#endif
 
 /* Payload of a NUMBER, STRING, CHAR or COMMENT token.  */
 struct GTY(()) cpp_string {
   unsigned int len;
   const unsigned char *text;
-  cpp_string_location loc;
 };
 
 /* Flags for the cpp_token structure.  */
diff --git a/libcpp/internal.h b/libcpp/internal.h
index 0a6b472..a56c497 100644
--- a/libcpp/internal.h
+++ b/libcpp/internal.h
@@ -42,8 +42,8 @@ struct op;
 struct _cpp_strbuf;
 
 typedef bool (*convert_f) (iconv_t, const unsigned char *, size_t,
-			   struct _cpp_strbuf *,
-			   cpp_string_location_reader *loc_reader, bool);
+			   struct _cpp_strbuf *);
+//cpp_string_location_reader *loc_reader, bool);
 struct cset_converter
 {
   convert_f func;
@@ -755,9 +755,9 @@ struct normalize_state
 extern bool _cpp_valid_ucn (cpp_reader *, const unsigned char **,
 			    const unsigned char *, int,
 			    struct normalize_state *state,
-			    cppchar_t *,
-			    source_range *char_range,
-			    cpp_string_location_reader *loc_reader);
+			    cppchar_t *);
+  //source_range *char_range);//,
+  //cpp_string_location_reader *loc_reader);
 extern void _cpp_destroy_iconv (cpp_reader *);
 extern unsigned char *_cpp_convert_input (cpp_reader *, const char *,
 					  unsigned char *, size_t, size_t,
diff --git a/libcpp/lex.c b/libcpp/lex.c
index 0bbd952..25be29c 100644
--- a/libcpp/lex.c
+++ b/libcpp/lex.c
@@ -1247,7 +1247,7 @@ forms_identifier_p (cpp_reader *pfile, int first,
       cppchar_t s;
       buffer->cur += 2;
       if (_cpp_valid_ucn (pfile, &buffer->cur, buffer->rlimit, 1 + !first,
-			  state, &s, NULL, NULL))
+			  state, &s))//, NULL))//, NULL))
 	return true;
       buffer->cur -= 2;
     }
@@ -1414,7 +1414,7 @@ lex_number (cpp_reader *pfile, cpp_string *number,
      has union cpp_token_u with
        desc ("cpp_token_val_index (&%1)")))
      and this gives CPP_TOKEN_FLD_STR for numbers (and strings).  */
-  number->loc.init ();
+  //number->loc.init ();
 
   base = pfile->buffer->cur - 1;
   do
@@ -1455,7 +1455,7 @@ create_literal (cpp_reader *pfile, cpp_token *token, const uchar *base,
   token->type = type;
   token->val.str.len = len;
   token->val.str.text = dest;
-  token->val.str.loc.init_raw (token->src_loc, len, 1, 1, pfile->line_table);
+  //token->val.str.loc.init_raw (token->src_loc, len, 1, 1, pfile->line_table);
 }
 
 /* Subroutine of lex_raw_string: Append LEN chars from BASE to the buffer
diff --git a/libcpp/macro.c b/libcpp/macro.c
index 1a6c869..d003ebe 100644
--- a/libcpp/macro.c
+++ b/libcpp/macro.c
@@ -217,7 +217,7 @@ new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)
   token->type = CPP_STRING;
   token->val.str.len = len;
   token->val.str.text = text;
-  token->val.str.loc.init ();
+  //token->val.str.loc.init ();
   token->flags = 0;
   return token;
 }
