Remove unused internal function bytes_from_utf8_loc

Commit e4d3d0c removed all the calls to
this function.

Author: khwilliamson

embed.fnc

@@ -791,14 +791,9 @@ Adp	|int	|bytes_cmp_utf8 |NN const U8 *b 			\
 				|STRLEN blen				\
 				|NN const U8 *u 			\
 				|STRLEN ulen
-AMdp	|U8 *	|bytes_from_utf8|NN const U8 *s 			\
+Adp	|U8 *	|bytes_from_utf8|NN const U8 *s 			\
 				|NN STRLEN *lenp			\
 				|NN bool *is_utf8p
-CTdp	|U8 *	|bytes_from_utf8_loc					\
-				|NN const U8 *s 			\
-				|NN STRLEN *lenp			\
-				|NN bool *is_utf8p			\
-				|NULLOK const U8 **first_unconverted
 Adp	|U8 *	|bytes_to_utf8	|NN const U8 *s 			\
 				|NN STRLEN *lenp
 AOdp	|SSize_t|call_argv	|NN const char *sub_name		\

embed.h

@@ -156,7 +156,7 @@
 # define block_gimme()                          Perl_block_gimme(aTHX)
 # define block_start(a)                         Perl_block_start(aTHX_ a)
 # define bytes_cmp_utf8(a,b,c,d)                Perl_bytes_cmp_utf8(aTHX_ a,b,c,d)
-# define bytes_from_utf8_loc                    Perl_bytes_from_utf8_loc
+# define bytes_from_utf8(a,b,c)                 Perl_bytes_from_utf8(aTHX_ a,b,c)
 # define bytes_to_utf8(a,b)                     Perl_bytes_to_utf8(aTHX_ a,b)
 # define call_argv(a,b,c)                       Perl_call_argv(aTHX_ a,b,c)
 # define call_atexit(a,b)                       Perl_call_atexit(aTHX_ a,b)

proto.h

@@ -2592,71 +2592,15 @@ after-call value of C<*lenp> from it.
 
 =cut
 
-There is a macro that avoids this function call, but this is retained for
-anyone who calls it with the Perl_ prefix */
+*/
 
 U8 *
 Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p)
 {
     PERL_ARGS_ASSERT_BYTES_FROM_UTF8;
     PERL_UNUSED_CONTEXT;
 
-    return bytes_from_utf8_loc(s, lenp, is_utf8p, NULL);
-}
-
-/*
-=for apidoc bytes_from_utf8_loc
-
-Like C<L<perlapi/bytes_from_utf8>()>, but takes an extra parameter, a pointer
-to where to store the location of the first character in C<"s"> that cannot be
-converted to non-UTF8.
-
-If that parameter is C<NULL>, this function behaves identically to
-C<bytes_from_utf8>.
-
-Otherwise if C<*is_utf8p> is 0 on input, the function behaves identically to
-C<bytes_from_utf8>, except it also sets C<*first_non_downgradable> to C<NULL>.
-
-Otherwise, the function returns a newly created C<NUL>-terminated string
-containing the non-UTF8 equivalent of the convertible first portion of
-C<"s">.  C<*lenp> is set to its length, not including the terminating C<NUL>.
-If the entire input string was converted, C<*is_utf8p> is set to a FALSE value,
-and C<*first_non_downgradable> is set to C<NULL>.
-
-Otherwise, C<*first_non_downgradable> is set to point to the first byte of the
-first character in the original string that wasn't converted.  C<*is_utf8p> is
-unchanged.  Note that the new string may have length 0.
-
-Another way to look at it is, if C<*first_non_downgradable> is non-C<NULL> and
-C<*is_utf8p> is TRUE, this function starts at the beginning of C<"s"> and
-converts as many characters in it as possible stopping at the first one it
-finds that can't be converted to non-UTF-8.  C<*first_non_downgradable> is
-set to point to that.  The function returns the portion that could be converted
-in a newly created C<NUL>-terminated string, and C<*lenp> is set to its length,
-not including the terminating C<NUL>.  If the very first character in the
-original could not be converted, C<*lenp> will be 0, and the new string will
-contain just a single C<NUL>.  If the entire input string was converted,
-C<*is_utf8p> is set to FALSE and C<*first_non_downgradable> is set to C<NULL>.
-
-Upon successful return, the number of variants in the converted portion of the
-string can be computed by having saved the value of C<*lenp> before the call,
-and subtracting the after-call value of C<*lenp> from it.
-
-=cut
-
-
-*/
-
-U8 *
-Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8** first_unconverted)
-{
-    PERL_ARGS_ASSERT_BYTES_FROM_UTF8_LOC;
-
     if (! *is_utf8p) {
-        if (first_unconverted) {
-            *first_unconverted = NULL;
-        }
-
         return (U8 *) s;
     }
 
@@ -2685,14 +2629,8 @@ Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8** f
             /* Then it is multi-byte encoded.  If the code point is above 0xFF,
              * have to stop now */
             if (UNLIKELY (! UTF8_IS_NEXT_CHAR_DOWNGRADEABLE(s - 1, send))) {
-                if (first_unconverted) {
-                    *first_unconverted = s - 1;
-                    goto finish_and_return;
-                }
-                else {
                     Safefree(converted_start);
                     return (U8 *) s0;
-                }
             }
 
             c = EIGHT_BIT_UTF8_TO_NATIVE(c, *s);
@@ -2703,11 +2641,7 @@ Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8** f
 
     /* Here, converted the whole of the input */
     *is_utf8p = FALSE;
-    if (first_unconverted) {
-        *first_unconverted = NULL;
-    }
 
-  finish_and_return:
     *d = '\0';
     *lenp = d - converted_start;
 

utf8.c

@@ -1298,8 +1298,6 @@ point's representation.
 #define SHARP_S_SKIP 2
 
 #define is_utf8_char_buf(buf, buf_end) isUTF8_CHAR(buf, buf_end)
-#define bytes_from_utf8(s, lenp, is_utf8p)                                  \
-                            bytes_from_utf8_loc(s, lenp, is_utf8p, 0)
 
 /* Do not use; should be deprecated.  Use isUTF8_CHAR() instead; this is
  * retained solely for backwards compatibility */