source: trunk/libs/newlib/src/newlib/libc/iconv/ces/table.c @ 444

/*
 * Copyright (c) 2003-2004, Artem B. Bityuckiy
 * Copyright (c) 1999,2000, Konstantin Chuguev. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "cesbi.h"

#if defined (ICONV_TO_UCS_CES_TABLE) \
 || defined (ICONV_FROM_UCS_CES_TABLE)
 
#include <_ansi.h>
#include <reent.h>
#include <newlib.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/iconvnls.h>
#include "../lib/endian.h"
#include "../lib/local.h"
#include "../lib/ucsconv.h"
#include "../ccs/ccs.h"

/*
 * Table-based CES converter is implemented here.  Table-based CES converter
 * deals with encodings with "null" CES, like KOI8-R. In this case it is
 * possible to implement one generic algorithm which works with different
 * CCS tables.
 *
 * Table-based CES converter deals with CCS tables placed into iconv/ccs
 * subdirectory. First, converter tries to find needed CCS table among
 * linked-in tables. If not found, it tries to load it from external file
 * (only if corespondent capability was enabled in Newlib configuration). 
 *
 * 16 bit encodings are assumed to be Big Endian.
 */

static ucs2_t
find_code_size (ucs2_t code, const __uint16_t *tblp);

static __inline ucs2_t
find_code_speed (ucs2_t code, const __uint16_t *tblp);

static __inline ucs2_t
find_code_speed_8bit (ucs2_t code, const unsigned char *tblp);

#ifdef _ICONV_ENABLE_EXTERNAL_CCS
static const iconv_ccs_desc_t *
load_file (struct _reent *rptr, const char *name, int direction);
#endif

/*
 * Interface data and functions implementation.
 */
static size_t
table_close (struct _reent *rptr,
                    void *data)
{
  const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;

  if (ccsp->type == TABLE_EXTERNAL)
    _free_r (rptr, (void *)ccsp->tbl);

  _free_r( rptr, (void *)ccsp);
  return 0;
}

#if defined (ICONV_FROM_UCS_CES_TABLE)
static void *
table_init_from_ucs (struct _reent *rptr,
                            const char *encoding)
{
  int i;
  const iconv_ccs_t *biccsp = NULL;
  iconv_ccs_desc_t *ccsp;
  
  for (i = 0; _iconv_ccs[i] != NULL; i++)
    if (strcmp (_iconv_ccs[i]->name, encoding) == 0)
      {
        biccsp = _iconv_ccs[i]; 
        break;
      }

  if (biccsp != NULL)
    {
      if (biccsp->from_ucs == NULL
          || (ccsp = (iconv_ccs_desc_t *)
                     _malloc_r (rptr, sizeof (iconv_ccs_desc_t))) == NULL)
        return NULL;

      ccsp->type = TABLE_BUILTIN;
      ccsp->bits = biccsp->bits;
      ccsp->optimization = biccsp->from_ucs_type;
      ccsp->tbl = biccsp->from_ucs;
      
      return (void *)ccsp;
    }
    
#ifdef _ICONV_ENABLE_EXTERNAL_CCS
  return (void *)load_file (rptr, encoding, 1);
#else
  return NULL;
#endif
}

static size_t
table_convert_from_ucs (void *data,
                               ucs4_t in,
                               unsigned char **outbuf,
                               size_t *outbytesleft)
{
  const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;
  ucs2_t code;

  if (in > 0xFFFF || in == INVALC)
    return (size_t)ICONV_CES_INVALID_CHARACTER;

  if (ccsp->bits == TABLE_8BIT)
    {
      code = find_code_speed_8bit ((ucs2_t)in,
                                  (const unsigned char *)ccsp->tbl);
      if (code == INVALC)
        return (size_t)ICONV_CES_INVALID_CHARACTER;
      **outbuf = (unsigned char)code;
      *outbuf += 1;
      *outbytesleft -= 1;
      return 1; 
    }
  else if (ccsp->optimization == TABLE_SPEED_OPTIMIZED)
    code = find_code_speed ((ucs2_t)in, ccsp->tbl);
  else
    code = find_code_size ((ucs2_t)in, ccsp->tbl);

  if (code == INVALC)
    return (size_t)ICONV_CES_INVALID_CHARACTER;

  if (*outbytesleft < 2)
    return (size_t)ICONV_CES_NOSPACE;
  
  /* We can't store whole word since **outbuf may be not 2-byte aligned */
  **outbuf = (unsigned char)((ucs2_t)code >> 8);
  *(*outbuf + 1) = (unsigned char)code;
  *outbuf += 2;
  *outbytesleft -= 2;
  return 2; 
}
#endif /* ICONV_FROM_UCS_CES_TABLE */

#if defined (ICONV_TO_UCS_CES_TABLE)
static void *
table_init_to_ucs (struct _reent *rptr,
                          const char *encoding)
{
  int i;
  const iconv_ccs_t *biccsp = NULL;
  iconv_ccs_desc_t *ccsp;
  
  for (i = 0; _iconv_ccs[i] != NULL; i++)
    if (strcmp (_iconv_ccs[i]->name, encoding) == 0)
      {
        biccsp = _iconv_ccs[i]; 
        break;
      }

  if (biccsp != NULL)
    {
      if (biccsp->to_ucs == NULL
          || (ccsp = (iconv_ccs_desc_t *)
                     _malloc_r (rptr, sizeof (iconv_ccs_desc_t))) == NULL)
        return NULL;

      ccsp->type = TABLE_BUILTIN;
      ccsp->bits = biccsp->bits;
      ccsp->optimization = biccsp->to_ucs_type;
      ccsp->tbl = biccsp->to_ucs;
      
      return (void *)ccsp;
    }
  
#ifdef _ICONV_ENABLE_EXTERNAL_CCS
  return (void *)load_file (rptr, encoding, 0);
#else
  return NULL;
#endif
}

static ucs4_t
table_convert_to_ucs (void *data,
                             const unsigned char **inbuf,
                             size_t *inbytesleft)
{
  const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;
  ucs2_t ucs;
  
  if (ccsp->bits == TABLE_8BIT)
    {
      if (*inbytesleft < 1)
        return (ucs4_t)ICONV_CES_BAD_SEQUENCE;
  
      ucs = (ucs2_t)ccsp->tbl[**inbuf];
      
      if (ucs == INVALC)
        return (ucs4_t)ICONV_CES_INVALID_CHARACTER;
         
      *inbytesleft -= 1;
      *inbuf += 1;
      return (ucs4_t)ucs; 
    }

  if (*inbytesleft < 2)
    return (ucs4_t)ICONV_CES_BAD_SEQUENCE;

  if (ccsp->optimization == TABLE_SIZE_OPTIMIZED)
    ucs = find_code_size((ucs2_t)**inbuf << 8 | (ucs2_t)*(*inbuf + 1),
                         ccsp->tbl);
  else
    ucs = find_code_speed((ucs2_t)**inbuf << 8 | (ucs2_t)*(*inbuf + 1),
                          ccsp->tbl);

  if (ucs == INVALC)
    return (ucs4_t)ICONV_CES_INVALID_CHARACTER;

  *inbuf += 2;
  *inbytesleft -= 2;
  return (ucs4_t)ucs; 
}
#endif /* ICONV_TO_UCS_CES_TABLE */

static int
table_get_mb_cur_max (void *data)
{
  return ((iconv_ccs_desc_t *)data)->bits/8;
}


#if defined (ICONV_TO_UCS_CES_TABLE)
const iconv_to_ucs_ces_handlers_t
_iconv_to_ucs_ces_handlers_table = 
{
  table_init_to_ucs,
  table_close,
  table_get_mb_cur_max,
  NULL,
  NULL,
  NULL,
  table_convert_to_ucs
};
#endif /* ICONV_FROM_UCS_CES_TABLE */

#if defined (ICONV_FROM_UCS_CES_TABLE)
const iconv_from_ucs_ces_handlers_t
_iconv_from_ucs_ces_handlers_table =
{
  table_init_from_ucs,
  table_close,
  table_get_mb_cur_max,
  NULL,
  NULL,
  NULL,
  table_convert_from_ucs
};
#endif /* ICONV_TO_UCS_CES_TABLE */

/*
 * Supplementary functions.
 */

/*
 * find_code_speed - find code in 16 bit speed-optimized table.
 *
 * PARAMETERS:
 *     ucs2_t code - code whose mapping to find.
 *     const __uint16_t *tblp - table pointer.
 *
 * RETURN:
 *     Code that corresponds to 'code'.
 */
static __inline ucs2_t
find_code_speed (ucs2_t code,
                        const __uint16_t *tblp)
{
  int idx = tblp[code >> 8];

  if (idx == INVBLK)
    return (ucs2_t)INVALC;

  return (ucs2_t)tblp[(code & 0x00FF) + idx];
}

/*
 * find_code_speed_8bit - find code in 8 bit speed-optimized table.
 *
 * PARAMETERS:
 *     ucs2_t code - code whose mapping to find.
 *     const __uint16_t *tblp - table pointer.
 *
 * RETURN:
 *     Code that corresponds to 'code'.
 */
static __inline ucs2_t
find_code_speed_8bit (ucs2_t code,
                             const unsigned char *tblp)
{
  int idx;
  unsigned char ccs;

  if (code == ((ucs2_t *)tblp)[0])
    return (ucs2_t)0xFF;
 
  idx = ((ucs2_t *)tblp)[1 + (code >> 8)];
  
  if (idx == INVBLK)
    return (ucs2_t)INVALC;

  ccs = tblp[(code & 0x00FF) + idx];

  return ccs == 0xFF ? (ucs2_t)INVALC : (ucs2_t)ccs;
}

/* Left range boundary */
#define RANGE_LEFT(n)     (tblp[FIRST_RANGE_INDEX + (n)*3 + 0])
/* Right range boundary */
#define RANGE_RIGHT(n)    (tblp[FIRST_RANGE_INDEX + (n)*3 + 1])
/* Range offset */
#define RANGE_INDEX(n)    (tblp[FIRST_RANGE_INDEX + (n)*3 + 2])
/* Un-ranged offset */
#define UNRANGED_INDEX(n) (tblp[FIRST_UNRANGED_INDEX_INDEX] + (n)*2)

/*
 * find_code_size - find code in 16 bit size-optimized table.
 *
 * PARAMETERS:
 *     ucs2_t code - code whose mapping to find.
 *     const __uint16_t *tblp - table pointer.
 *
 * RETURN:
 *     Code that corresponds to 'code'.
 */
static ucs2_t
find_code_size (ucs2_t code,
                       const __uint16_t *tblp)
{
  int first, last, cur, center;

  if (tblp[RANGES_NUM_INDEX] > 0)
    {
      first = 0;
      last = tblp[RANGES_NUM_INDEX] - 1;
 
      do
        {
          center = (last - first)/2;
          cur = center + first;
          
          if (code > RANGE_RIGHT (cur))
            first = cur;
          else if (code < RANGE_LEFT (cur))
            last = cur;
          else
            return (ucs2_t)tblp[RANGE_INDEX (cur) + code - RANGE_LEFT (cur)];
        } while (center > 0);

        if (last - first == 1)
          {
            if (code >= RANGE_LEFT (first) && code <= RANGE_RIGHT (first))
              return (ucs2_t)tblp[RANGE_INDEX (first)
                                  + code - RANGE_LEFT (first)];
            if (code >= RANGE_LEFT (last) && code <= RANGE_RIGHT (last))
              return (ucs2_t)tblp[RANGE_INDEX (last)
                                  + code - RANGE_LEFT (last)];
          }
    }
  
  if (tblp[UNRANGED_NUM_INDEX] > 0)
    {
      first = 0;
      last = tblp[UNRANGED_NUM_INDEX] - 1;
 
      do
        {
          int c;

          center = (last - first)/2;
          cur = center + first;
          c = tblp[UNRANGED_INDEX (cur)];
 
          if (code > c)
            first = cur;
          else if (code < c)
            last = cur;
          else
            return (ucs2_t)tblp[UNRANGED_INDEX (cur) + 1];
        } while (center > 0);

        if (last - first == 1)
          {
            if (code == tblp[UNRANGED_INDEX (first)])
              return (ucs2_t)tblp[UNRANGED_INDEX (first) + 1];
            if (code == tblp[UNRANGED_INDEX (last)])
              return (ucs2_t)tblp[UNRANGED_INDEX (last) + 1];
          }
    }

  return (ucs2_t)INVALC;
}

#ifdef _ICONV_ENABLE_EXTERNAL_CCS

#define _16BIT_ELT(offset) \
    ICONV_BETOHS(*((__uint16_t *)(buf + (offset))))
#define _32BIT_ELT(offset) \
    ICONV_BETOHL(*((__uint32_t *)(buf + (offset))))

/*
 * load_file - load conversion table from external file and initialize
 *             iconv_ccs_desc_t object.
 *
 * PARAMETERS:
 *    struct _reent *rptr - reent structure of current thread/process.
 *    const char *name - encoding name.
 *    int direction - conversion direction.
 *
 * DESCRIPTION:
 *    Loads conversion table of appropriate endianess from external file
 *    and initializes 'iconv_ccs_desc_t' table description structure.
 *    If 'direction' is 0 - load "To UCS" table, else load "From UCS"
 *    table.
 *
 * RETURN:
 *    iconv_ccs_desc_t * pointer is success, NULL if failure.
 */
static const iconv_ccs_desc_t *
load_file (struct _reent *rptr,
                  const char *name,
                  int direction)
{
  int fd;
  const unsigned char *buf;
  int tbllen, hdrlen;
  off_t off;
  const char *fname;
  iconv_ccs_desc_t *ccsp = NULL;
  int nmlen = strlen(name);
  /* Since CCS table name length can vary - it is aligned (by adding extra
   * bytes to it's end) to 4-byte boundary. */
  int alignment = nmlen & 3 ? 4 - (nmlen & 3) : 0;
  
  nmlen = strlen(name);
  
  hdrlen = nmlen + EXTTABLE_HEADER_LEN + alignment;

  if ((fname = _iconv_nls_construct_filename (rptr, name, ICONV_SUBDIR,
                                              ICONV_DATA_EXT)) == NULL)
    return NULL;
  
  if ((fd = _open_r (rptr, fname, O_RDONLY, S_IRUSR)) == -1)
    goto error1;
  
  if ((buf = (const unsigned char *)_malloc_r (rptr, hdrlen)) == NULL)
    goto error2;

  if (_read_r (rptr, fd, (void *)buf, hdrlen) != hdrlen)
    goto error3;

  if (_16BIT_ELT (EXTTABLE_VERSION_OFF) != TABLE_VERSION_1
      || _32BIT_ELT (EXTTABLE_CCSNAME_LEN_OFF) != nmlen
      || strncmp (buf + EXTTABLE_CCSNAME_OFF, name, nmlen) != 0)
    goto error3; /* Bad file */

  if ((ccsp = (iconv_ccs_desc_t *)
           _calloc_r (rptr, 1, sizeof (iconv_ccs_desc_t))) == NULL)
    goto error3;
  
  ccsp->bits = _16BIT_ELT (EXTTABLE_BITS_OFF);
  ccsp->type = TABLE_EXTERNAL;

  /* Add 4-byte alignment to name length */
  nmlen += alignment;

  if (ccsp->bits == TABLE_8BIT)
    {
      if (direction == 0) /* Load "To UCS" table */
        {
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_LEN_OFF);
        }
      else /* Load "From UCS" table */
        {
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_LEN_OFF);
        }
    }
  else if (ccsp->bits == TABLE_16BIT)
    {
      if (direction == 0) /* Load "To UCS" table */
        {
#ifdef TABLE_USE_SIZE_OPTIMIZATION
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SIZE_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SIZE_LEN_OFF);
#else
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_LEN_OFF);
#endif
        }
      else /* Load "From UCS" table */
        {
#ifdef TABLE_USE_SIZE_OPTIMIZATION
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SIZE_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SIZE_LEN_OFF);
#else
          off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_OFF);
          tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_LEN_OFF);
#endif
        }
#ifdef TABLE_USE_SIZE_OPTIMIZATION
      ccsp->optimization = TABLE_SIZE_OPTIMIZED; 
#else
      ccsp->optimization = TABLE_SPEED_OPTIMIZED;
#endif
    }
  else
    goto error4; /* Bad file */

  if (off == EXTTABLE_NO_TABLE)
    goto error4; /* No correspondent table in file */

  if ((ccsp->tbl = (ucs2_t *)_malloc_r (rptr, tbllen)) == NULL)
    goto error4;

  if (_lseek_r (rptr, fd, off, SEEK_SET) == (off_t)-1
      || _read_r (rptr, fd, (void *)ccsp->tbl, tbllen) != tbllen)
    goto error5;

  goto normal_exit;

error5:
  _free_r (rptr, (void *)ccsp->tbl);
  ccsp->tbl = NULL;
error4:
  _free_r (rptr, (void *)ccsp);
  ccsp = NULL;
error3:
normal_exit:
  _free_r (rptr, (void *)buf);
error2:
  if (_close_r (rptr, fd) == -1)
    {
      if (ccsp != NULL)
        {
          if (ccsp->tbl != NULL)
            _free_r (rptr, (void *)ccsp->tbl);
          _free_r (rptr, (void *)ccsp);
        }
      ccsp = NULL;
    }
error1:
  _free_r (rptr, (void *)fname);
  return ccsp;
}
#endif

#endif /* ICONV_TO_UCS_CES_TABLE || ICONV_FROM_UCS_CES_TABLE */