path: root/iconv/skeleton.c

/* Skeleton for a conversion module.
   Copyright (C) 1998-2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

/* This file can be included to provide definitions of several things
   many modules have in common.  It can be customized using the following
   macros:

     DEFINE_INIT	define the default initializer.  This requires the
			following symbol to be defined.

     CHARSET_NAME	string with official name of the coded character
			set (in all-caps)

     DEFINE_FINI	define the default destructor function.

     MIN_NEEDED_FROM	minimal number of bytes needed for the from-charset.
     MIN_NEEDED_TO	likewise for the to-charset.

     MAX_NEEDED_FROM	maximal number of bytes needed for the from-charset.
			This macro is optional, it defaults to MIN_NEEDED_FROM.
     MAX_NEEDED_TO	likewise for the to-charset.

     FROM_LOOP_MIN_NEEDED_FROM
     FROM_LOOP_MAX_NEEDED_FROM
			minimal/maximal number of bytes needed on input
			of one round through the FROM_LOOP.  Defaults
			to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
     FROM_LOOP_MIN_NEEDED_TO
     FROM_LOOP_MAX_NEEDED_TO
			minimal/maximal number of bytes needed on output
			of one round through the FROM_LOOP.  Defaults
			to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
     TO_LOOP_MIN_NEEDED_FROM
     TO_LOOP_MAX_NEEDED_FROM
			minimal/maximal number of bytes needed on input
			of one round through the TO_LOOP.  Defaults
			to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
     TO_LOOP_MIN_NEEDED_TO
     TO_LOOP_MAX_NEEDED_TO
			minimal/maximal number of bytes needed on output
			of one round through the TO_LOOP.  Defaults
			to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.

     FROM_DIRECTION	this macro is supposed to return a value != 0
			if we convert from the current character set,
			otherwise it return 0.

     EMIT_SHIFT_TO_INIT	this symbol is optional.  If it is defined it
			defines some code which writes out a sequence
			of bytes which bring the current state into
			the initial state.

     FROM_LOOP		name of the function implementing the conversion
			from the current character set.
     TO_LOOP		likewise for the other direction

     ONE_DIRECTION	optional.  If defined to 1, only one conversion
			direction is defined instead of two.  In this
			case, FROM_DIRECTION should be defined to 1, and
			FROM_LOOP and TO_LOOP should have the same value.

     SAVE_RESET_STATE	in case of an error we must reset the state for
			the rerun so this macro must be defined for
			stateful encodings.  It takes an argument which
			is nonzero when saving.

     RESET_INPUT_BUFFER	If the input character sets allow this the macro
			can be defined to reset the input buffer pointers
			to cover only those characters up to the error.
			Note that if the conversion has skipped over
			irreversible characters (due to
			__GCONV_IGNORE_ERRORS) there is no longer a direct
			correspondence between input and output pointers,
			and this macro is not called.

     FUNCTION_NAME	if not set the conversion function is named `gconv'.

     PREPARE_LOOP	optional code preparing the conversion loop.  Can
			contain variable definitions.
     END_LOOP		also optional, may be used to store information

     EXTRA_LOOP_ARGS	optional macro specifying extra arguments passed
			to loop function.

     STORE_REST		optional, needed only when MAX_NEEDED_FROM > 4.
			This macro stores the seen but unconverted input bytes
			in the state.

     FROM_ONEBYTE	optional.  If defined, should be the name of a
			specialized conversion function for a single byte
			from the current character set to INTERNAL.  This
			function has prototype
			   wint_t
			   FROM_ONEBYTE (struct __gconv_step *, unsigned char);
			and does a special conversion:
			- The input is a single byte.
			- The output is a single uint32_t.
			- The state before the conversion is the initial state;
			  the state after the conversion is irrelevant.
			- No transliteration.
			- __invocation_counter = 0.
			- __internal_use = 1.
			- do_flush = 0.

   Modules can use mbstate_t to store conversion state as follows:

   * Bits 2..0 of '__count' contain the number of lookahead input bytes
     stored in __value.__wchb.  Always zero if the converter never
     returns __GCONV_INCOMPLETE_INPUT.

   * Bits 31..3 of '__count' are module dependent shift state.

   * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
     converter has returned __GCONV_INCOMPLETE_INPUT, this contains
     at most 4 lookahead bytes. Converters with an mb_cur_max > 4
     (currently only UTF-8) must find a way to store their state
     in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.

   When __value contains lookahead, __count must not be zero, because
   the converter is not in the initial state then, and mbsinit() --
   defined as a (__count == 0) test -- must reflect this.
 */

#include <assert.h>
#include <iconv/gconv_int.h>
#include <string.h>
#define __need_size_t
#define __need_NULL
#include <stddef.h>

#ifndef STATIC_GCONV
# include <dlfcn.h>
#endif

#include <pointer_guard.h>
#include <stdint.h>

#ifndef DL_CALL_FCT
# define DL_CALL_FCT(fct, args) fct args
#endif

/* The direction objects.  */
#if DEFINE_INIT
# ifndef FROM_DIRECTION
#  define FROM_DIRECTION_VAL NULL
#  define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
#  define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
# endif
#else
# ifndef FROM_DIRECTION
#  error "FROM_DIRECTION must be provided if non-default init is used"
# endif
#endif

/* How many bytes are needed at most for the from-charset.  */
#ifndef MAX_NEEDED_FROM
# define MAX_NEEDED_FROM	MIN_NEEDED_FROM
#endif

/* Same for the to-charset.  */
#ifndef MAX_NEEDED_TO
# define MAX_NEEDED_TO		MIN_NEEDED_TO
#endif

/* Defaults for the per-direction min/max constants.  */
#ifndef FROM_LOOP_MIN_NEEDED_FROM
# define FROM_LOOP_MIN_NEEDED_FROM	MIN_NEEDED_FROM
#endif
#ifndef FROM_LOOP_MAX_NEEDED_FROM
# define FROM_LOOP_MAX_NEEDED_FROM	MAX_NEEDED_FROM
#endif
#ifndef FROM_LOOP_MIN_NEEDED_TO
# define FROM_LOOP_MIN_NEEDED_TO	MIN_NEEDED_TO
#endif
#ifndef FROM_LOOP_MAX_NEEDED_TO
# define FROM_LOOP_MAX_NEEDED_TO	MAX_NEEDED_TO
#endif
#ifndef TO_LOOP_MIN_NEEDED_FROM
# define TO_LOOP_MIN_NEEDED_FROM	MIN_NEEDED_TO
#endif
#ifndef TO_LOOP_MAX_NEEDED_FROM
# define TO_LOOP_MAX_NEEDED_FROM	MAX_NEEDED_TO
#endif
#ifndef TO_LOOP_MIN_NEEDED_TO
# define TO_LOOP_MIN_NEEDED_TO		MIN_NEEDED_FROM
#endif
#ifndef TO_LOOP_MAX_NEEDED_TO
# define TO_LOOP_MAX_NEEDED_TO		MAX_NEEDED_FROM
#endif


/* For conversions from a fixed width character set to another fixed width
   character set we can define RESET_INPUT_BUFFER in a very fast way.  */
#if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
# if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
     && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
     && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
     && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
/* We have to use these `if's here since the compiler cannot know that
   (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
   The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
   obviously unreachable code.  */
#  define RESET_INPUT_BUFFER \
  if (FROM_DIRECTION)							      \
    {									      \
      if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0)	      \
	*inptrp -= (outbuf - outerr)					      \
		   * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO);   \
      else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0)      \
	*inptrp -= (outbuf - outerr)					      \
		   / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM     \
		      ? : 1);						      \
      else								      \
	*inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO)	      \
		   * FROM_LOOP_MIN_NEEDED_FROM;				      \
    }									      \
  else									      \
    {									      \
      if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0)		      \
	*inptrp -= (outbuf - outerr)					      \
		   * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO);	      \
      else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0)	      \
	*inptrp -= (outbuf - outerr)					      \
		   / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
      else								      \