/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 */


#include <errno.h>
#include <widec.h>
#include <stdlib.h>
#include <sys/isa_defs.h>
#include <sys/types.h>
#include "common_def.h"
#include "common_defs.h"
#include "common_han.h"
#include "uhang_utf_api.h"
#include "euc_utf_api.h"

typedef struct {
  int         _magic;
  boolean     _need_byte_swap;
} _icv_state_t;


extern hcode_type _unified_hangul_to_UCS2LE (hcode_type);

void *
_icv_open()
{
  _icv_state_t *h = (_icv_state_t *) malloc (sizeof (_icv_state_t));
  if (!h){
    errno = ENOMEM;
    return((void *)-1);
  }

  h->_magic = MAGIC_NUMBER;
#if defined(UCS_2BE)
  h->_need_byte_swap =false;
#elif defined(UCS_2LE)
  h->_need_byte_swap = true;
#endif

  return (void *)h;
}


void
_icv_close (_icv_state_t *cd)
{
  if (!cd || ((_icv_state_t *)cd)->_magic  != MAGIC_NUMBER)
    errno = EBADF;
}



size_t
_icv_iconv (_icv_state_t *cd, char** inbuf, size_t* inbufleft,
	    char** outbuf, size_t* outbufleft)
{
  size_t		ret_val = 0;
  unsigned char*	ib;
  unsigned char*	ob;
  unsigned char*	ibtail;
  unsigned char*	obtail;

  if (!cd || ((_icv_state_t *)cd)->_magic  != MAGIC_NUMBER)
    {
      errno = EBADF;
      return((size_t)-1);
    }

  if (!inbuf || !(*inbuf))
    return((size_t)0);

  ib = (unsigned char*)*inbuf;
  ob = (unsigned char*)*outbuf;
  ibtail = ib + *inbufleft;
  obtail = ob + *outbufleft;

  while (ib < ibtail)
    {
      if (*ib & 0x80)  /* Korean EUC doesn't have CS2 or CS3. */
	{
	  hcode_type unihan_code, ucs2_code;
	  int flag;

	  flag = 0;

	  if ((ibtail - ib) < 2)
	    {
	      errno = EINVAL;
	      ret_val = (size_t)-1;
	      break;
	    }


	  if(*ib<0xA1)
	    {
	      if((*(ib+1)>0x40 && *(ib+1)<0x5B) || (*(ib+1)>0x60 && *(ib+1)<0x7B) || (*(ib+1)>0x80 && *(ib+1)<0xFF))
		flag = 0;
	      else
		flag = 1;

	    }
	  else
	    {
	      if(*ib<0xC7)
		{
		  if((*(ib+1)>0x40 && *(ib+1)<0x5B) || (*(ib+1)>0x60 && *(ib+1)<0x7B) || (*(ib+1)>0x80 && *(ib+1)<0xFF))
		    flag = 0;
		  else
		    flag = 1;
		}
	      else
		{
		  if(*(ib+1)>0xA0 && *(ib+1)<0xFF)
		    flag = 0;
		  else
		    flag = 1;
		}

	    }

	  if(flag)
	    {
	      errno = EILSEQ;
	      ret_val = (size_t)-1;
	      break;
	    }

	  unihan_code.code = 0;
	  unihan_code.byte.byte3 = *ib;
	  unihan_code.byte.byte4 = *(ib + 1);

	  ucs2_code = _unified_hangul_to_UCS2LE (unihan_code);

	  if (ucs2_code.code != 0)
	    {
	      if ((obtail - ob) < 3)
		{
		  errno = E2BIG;
		  ret_val = (size_t)-1;
		  break;
		}
#if !defined(UCS_2LE) && !defined(UCS_2BE)
	      if (!cd->_bom_written){
		*ob++ = (uchar_t)0xff;
		*ob++ = (uchar_t)0xfe;

		cd->_bom_written = true;
	      }
#endif    /* !defined(UCS_2LE) && !defined(UCS_2BE) */
	      if (cd->_need_byte_swap)
		{
		  *ob++ = ucs2_code.byte.byte4;
		  *ob++ = ucs2_code.byte.byte3;
		}
	      else
		{
		  *ob++ = ucs2_code.byte.byte3;
		  *ob++ = ucs2_code.byte.byte4;
		}
	    }
	  else  /* FAILED - this means input char doesn't belong to
		 *	  input codeset. */
	    {
	      errno = EILSEQ;
	      ret_val = (size_t)-1;
	      break;
	    }
	  ib += 2;

	}
      else  /* CS0 */
	{
#if !defined(UCS_2LE) && !defined(UCS_2BE)
	  if (!cd->_bom_written)
	    {
	    if ((obtail - ob) < 3)
	      {
		errno = E2BIG;
		ret_val = (size_t) -1;
		break;
	      }
	    *ob++ = (uchar_t)0xff;
	    *ob++ = (uchar_t)0xfe;
	    cd->_bom_written = true;
	    }
	  else
#endif    /* !defined(UCS_2LE) && !defined(UCS_2BE) */
	    {
	      if ((obtail - ob) < 1)
	      {
		errno = E2BIG;
		ret_val = (size_t) -1;
		break;
	      }
	    }

	  if (cd->_need_byte_swap)
	    {
	      *ob++ = *ib++;
	      *ob++ = 0x00;
	    }
	  else
	    {
	      *ob++ = 0x00;
	      *ob++ = *ib++;
	    }
	}
    }

  *inbuf = (char*)ib;
  *inbufleft = ibtail - ib;
  *outbuf = (char*)ob;
  *outbufleft = obtail - ob;

  return(ret_val);
}