/*  Codepage translation to Unicode, and UTF-8 support

 *

 *  The translation is based on codepage mapping files that are distributed

 *  by the Unicode consortium, see ftp://ftp.unicode.org/Public/MAPPINGS/.

 *

 *  Character sets with a maximum of 256 codes are translated via a lookup

 *  table (these are Single-Byte Character Sets). Character sets like Shift-JIS

 *  with single-byte characters and multi-byte characters (introduced by a

 *  leader byte) are split into two tables: the 256-entry lookup table for

 *  the single-byte characters and an extended table for the multi-byte

 *  characters. The extended table is allocated dynamically; the lookup table

 *  is allocated statically, so loading SBCS tables cannot fail (if the tables

 *  themselves are valid, of course).

 *

 *  Copyright (c) ITB CompuPhase, 2004-2006

 *

 *  This software is provided "as-is", without any express or implied warranty.

 *  In no event will the authors be held liable for any damages arising from

 *  the use of this software.

 *

 *  Permission is granted to anyone to use this software for any purpose,

 *  including commercial applications, and to alter it and redistribute it

 *  freely, subject to the following restrictions:

 *

 *  1.  The origin of this software must not be misrepresented; you must not

 *      claim that you wrote the original software. If you use this software in

 *      a product, an acknowledgment in the product documentation would be

 *      appreciated but is not required.

 *  2.  Altered source versions must be plainly marked as such, and must not be

 *      misrepresented as being the original software.

 *  3.  This notice may not be removed or altered from any source distribution.

 *

 *  Version: $Id$

 */

#include <assert.h>

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include "sc.h"

#if !defined TRUE

  #define FALSE         0

  #define TRUE          1

#endif

#if !defined _MAX_PATH

  #define _MAX_PATH     250

#endif

#if !defined DIRSEP_CHAR

  #if defined LINUX || defined __FreeBSD__ || defined __OpenBSD__

    #define DIRSEP_CHAR '/'

  #elif defined macintosh

    #define DIRSEP_CHAR ':'

  #else

    #define DIRSEP_CHAR '\\'

  #endif

#endif

#if !defined ELEMENTS

  #define ELEMENTS(array)       (sizeof(array) / sizeof(array[0]))

#endif

#if !defined NO_CODEPAGE

#if !defined MAXCODEPAGE

  #define MAXCODEPAGE   12      /* typically "cp" + 4 digits + ".txt" */

#endif

#define INVALID         0xffffu /* 0xffff and 0xfffe are invalid Unicode characters */

#define LEADBYTE        0xfffeu

struct wordpair {

  unsigned short index;

  wchar_t code;

};

static char cprootpath[_MAX_PATH] = { DIRSEP_CHAR, '\0' };

static wchar_t bytetable[256];

static struct wordpair *wordtable = NULL;

static unsigned wordtablesize = 0;

static unsigned wordtabletop = 0;

/* read in a line delimited by '\r' or '\n'; do NOT store the '\r' or '\n' into

 * the string and ignore empty lines

 * returns 1 for success and 0 for failure

 */

static int cp_readline(FILE *fp,char *string,size_t size)

{

  size_t count=0;

  int c;

  assert(size>1);

  while ((c=fgetc(fp))!=EOF && count<size-1) {

    if (c=='\r' || c=='\n') {

      if (count>0)  /* '\r' or '\n' ends a string */

        break;

      /* if count==0, the line started with a '\r' or '\n', or perhaps line

       * ends in the file are '\r\n' and we read and stopped on the '\r' of

       * the preceding line

       */

    } else {

      string[count++]=(char)c;

    } /* if */

  } /* while */

  string[count]='\0';

  return count>0;

}

/* cp_path() sets the directory where all codepage files must be found (if

 * the parameter to cp_set() specifies a full path, that is used instead).

 * The path is specified into two parts: root and directory; the full path

 * for the codepage direcory is just the concatenation of the two, with a

 * directory separator in between. The directory is given in two parts,

 * because often a program already retrieves its "home" directory and the

 * codepages are most conveniently stored in a subdirectory of this home

 * directory.

 */

SC_FUNC int cp_path(const char *root, const char *directory)

{

  size_t len1,len2;

  int add_slash1,add_slash2;

  len1= (root!=NULL) ? strlen(root) : 0;

  add_slash1= (len1==0 || root[len1-1]!=DIRSEP_CHAR);

  len2= (directory!=NULL) ? strlen(directory) : 0;

  add_slash2= (len2>0 && root[len2-1]!=DIRSEP_CHAR);

  if (len1+add_slash1+len2+add_slash2>=(_MAX_PATH-MAXCODEPAGE))

    return FALSE;       /* full filename may not fit */

  if (root!=NULL)

    strcpy(cprootpath,root);

  if (add_slash1) {

    assert(len1==0 || cprootpath[len1]=='\0');

    cprootpath[len1]=DIRSEP_CHAR;

    cprootpath[len1+1]='\0';

  } /* if */

  if (directory!=NULL)

    strcat(cprootpath,directory);

  if (add_slash2) {

    assert(cprootpath[len1+add_slash1+len2]=='\0');

    cprootpath[len1+add_slash1+len2]=DIRSEP_CHAR;

    cprootpath[len1+add_slash1+len2+1]='\0';

  } /* if */

  cp_set(NULL);         /* start with a "linear" table (no translation) */

  return TRUE;

}

/* cp_set() loads a codepage from a file. The name parameter may be a

 * filename (including a full path) or it may be a partial codepage name.

 * If the name parameter is NULL, the codepage is cleared to be a "linear"

 * table (no translation).

 * The following files are attempted to open (where <name> specifies the

 * value of the parameter):

 *    <name>

 *    <cprootpath>/<name>

 *    <cprootpath>/<name>.txt

 *    <cprootpath>/cp<name>

 *    <cprootpath>/cp<name>.txt

 */

SC_FUNC int cp_set(const char *name)

{

  char filename[_MAX_PATH];

  FILE *fp=NULL;

  unsigned index;

  /* for name==NULL, set up an identity table */

  if (name==NULL || *name=='\0') {

    if (wordtable!=NULL) {

      free(wordtable);

      wordtable=NULL;

      wordtablesize=0;

      wordtabletop=0;

    } /* if */

    for (index=0; index<ELEMENTS(bytetable); index++)

      bytetable[index]=(wchar_t)index;

    return TRUE;

  } /* if */

  /* try to open the file as-is */

  if (strchr(name,DIRSEP_CHAR)!=NULL)

    fp=fopen(name,"rt");

  if (fp==NULL) {

    /* try opening the file in the "root path" for codepages */

    if (strlen(name)>MAXCODEPAGE)

      return 0;

    assert(strlen(name)+strlen(cprootpath)<_MAX_PATH);

    strcpy(filename,cprootpath);

    strcat(filename,name);

    fp=fopen(filename,"rt");

  } /* if */

  if (fp==NULL) {

    /* try opening the file in the "root path" for codepages, with a ".txt" extension */

    if (strlen(name)+4>=MAXCODEPAGE)

      return 0;

    assert(strlen(filename)+4<_MAX_PATH);

    strcat(filename,".txt");

    fp=fopen(filename,"rt");

  } /* if */

  if (fp==NULL) {

    /* try opening the file in the "root path" for codepages, with "cp" prefixed before the name */

    if (strlen(name)+2>MAXCODEPAGE)

      return 0;

    assert(2+strlen(name)+strlen(cprootpath)<_MAX_PATH);

    strcpy(filename,cprootpath);

    strcat(filename,"cp");

    strcat(filename,name);

    fp=fopen(filename,"rt");

  } /* if */

  if (fp==NULL) {

    /* try opening the file in the "root path" for codepages, with "cp" prefixed an ".txt" appended */

    if (strlen(name)+2+4>MAXCODEPAGE)

      return 0;

    assert(strlen(filename)+4<_MAX_PATH);

    strcat(filename,".txt");

    fp=fopen(filename,"rt");

  } /* if */

  if (fp==NULL)

    return FALSE;       /* all failed */

  /* clear the tables */

  for (index=0; index<ELEMENTS(bytetable); index++)

    bytetable[index]=INVALID;   /* special code meaning "not found" */

  assert(wordtablesize==0 && wordtabletop==0 && wordtable==NULL

         || wordtablesize>0 && wordtable!=NULL);

  if (wordtable!=NULL) {

    free(wordtable);

    wordtable=NULL;

    wordtablesize=0;

    wordtabletop=0;

  } /* if */

  /* read in the table */

  while (cp_readline(fp,filename,sizeof filename)) {

    char *ptr;

    if ((ptr=strchr(filename,'#'))!=NULL)

      *ptr='\0';                /* strip of comment */

    for (ptr=filename; *ptr>0 && *ptr<' '; ptr++)

      /* nothing */;            /* skip leading whitespace */

    if (*ptr!='\0') {

      /* content on line */

      unsigned code=LEADBYTE;

      int num=sscanf(ptr,"%i %i",&index,&code);

      /* if sscanf() returns 1 and the index is in range 0..255, then the

       * code is a DBCS lead byte; if sscanf() returns 2 and index>=256, this

       * is a double byte pair (lead byte + follower)

       */

      if (num>=1 && index<256) {

        bytetable[index]=(wchar_t)code;

      } else if (num==2 && index>=256 && index<LEADBYTE) {

        /* store the DBCS character in wordtable */

        if (wordtabletop>=wordtablesize) {

          /* grow the list */

          int newsize;

          struct wordpair *newblock;

          newsize= (wordtablesize==0) ? 128 : 2*wordtablesize;

          newblock=(struct wordpair *)malloc(newsize*sizeof(*wordtable));

          if (newblock!=NULL) {

            memcpy(newblock,wordtable,wordtabletop*sizeof(*wordtable));

            free(wordtable);

            wordtable=newblock;

            wordtablesize=newsize;

          } /* if */

        } /* if */

        if (wordtabletop<wordtablesize) {

          /* insert at sorted position */

          int pos=wordtabletop;

          assert(wordtable!=NULL);

          while (pos>0 && (unsigned)wordtable[pos-1].index>index) {

            wordtable[pos]=wordtable[pos-1];

            pos--;

          } /* while */

          wordtable[pos].index=(unsigned short)index;

          wordtable[pos].code=(wchar_t)code;

        } /* if */

      } /* if */

    } /* if */

  } /* while */

  fclose(fp);

  return TRUE;

}

SC_FUNC cell cp_translate(const unsigned char *string,const unsigned char **endptr)

{

  wchar_t result;

  result=bytetable[*string++];

  /* check whether this is a leader code */

  if ((unsigned)result==LEADBYTE && wordtable!=NULL) {

    /* look up the code via binary search */

    int low,high,mid;

    unsigned short index=(unsigned short)(((*(string-1)) << 8) | *string);

    string++;

    assert(wordtabletop>0);

    low=0;

    high=wordtabletop-1;

    while (low<high) {

      mid=(low+high)/2;

      assert(low<=mid && mid<high);

      if (index>wordtable[mid].index)

        low=mid+1;

      else

        high=mid;

    } /* while */

    assert(low==high);

    if (wordtable[low].index==index)

      result=wordtable[low].code;

  } /* if */

  if (endptr!=NULL)

    *endptr=string;

  return (cell)result;

}

#endif  /* NO_CODEPAGE */

#if !defined NO_UTF8

SC_FUNC cell get_utf8_char(const unsigned char *string,const unsigned char **endptr)

{

  int follow=0;

  long lowmark=0;

  unsigned char ch;

  cell result=0;

  if (endptr!=NULL)

    *endptr=string;

  for ( ;; ) {

    ch=*string++;

    if (follow>0 && (ch & 0xc0)==0x80) {

      /* leader code is active, combine with earlier code */

      result=(result << 6) | (ch & 0x3f);

      if (--follow==0) {

        /* encoding a character in more bytes than is strictly needed,

         * is not really valid UTF-8; we are strict here to increase

         * the chance of heuristic dectection of non-UTF-8 text

         * (JAVA writes zero bytes as a 2-byte code UTF-8, which is invalid)

         */

        if (result<lowmark)

          return -1;

        /* the code positions 0xd800--0xdfff and 0xfffe & 0xffff do not

         * exist in UCS-4 (and hence, they do not exist in Unicode)

         */

        if (result>=0xd800 && result<=0xdfff || result==0xfffe || result==0xffff)

          return -1;

      } /* if */

      break;

    } else if (follow==0 && (ch & 0x80)==0x80) {

      /* UTF-8 leader code */

      if ((ch & 0xe0)==0xc0) {

        /* 110xxxxx 10xxxxxx */

        follow=1;

        lowmark=0x80L;

        result=ch & 0x1f;

      } else if ((ch & 0xf0)==0xe0) {

        /* 1110xxxx 10xxxxxx 10xxxxxx (16 bits, BMP plane) */

        follow=2;

        lowmark=0x800L;

        result=ch & 0x0f;

      } else if ((ch & 0xf8)==0xf0) {

        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */

        follow=3;

        lowmark=0x10000L;

        result=ch & 0x07;

      } else if ((ch & 0xfc)==0xf8) {

        /* 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx */

        follow=4;

        lowmark=0x200000L;

        result=ch & 0x03;

      } else if ((ch & 0xfe)==0xfc) {

        /* 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx (32 bits) */

        follow=5;

        lowmark=0x4000000L;

        result=ch & 0x01;

      } else {

        /* this is invalid UTF-8 */

        return -1;

      } /* if */

    } else if (follow==0 && (ch & 0x80)==0x00) {

      /* 0xxxxxxx (US-ASCII) */

      result=ch;

      break;

    } else {

      /* this is invalid UTF-8 */

      return -1;

    } /* if */

  } /* for */

  if (endptr!=NULL)

    *endptr=string;

  return result;

}

#endif

SC_FUNC int scan_utf8(FILE *fp,const char *filename)

{

  #if defined NO_UTF8

    return 0;

  #else

    void *resetpos=pc_getpossrc(fp);

    int utf8=TRUE;

    int firstchar=TRUE,bom_found=FALSE;

    const unsigned char *ptr;

    while (utf8 && pc_readsrc(fp,pline,sLINEMAX)!=NULL) {

      ptr=pline;

      if (firstchar) {

        /* check whether the very first character on the very first line

         * starts with a BYTE order mark

         */

        cell c=get_utf8_char(ptr,&ptr);

        bom_found= (c==0xfeff);

        utf8= (c>=0);

        firstchar=FALSE;

      } /* if */

      while (utf8 && *ptr!='\0')

        utf8= (get_utf8_char(ptr,&ptr)>=0);

    } /* while */

    pc_resetsrc(fp,resetpos);

    if (bom_found) {

      unsigned char bom[3];

      if (!utf8)

        error(77,filename);     /* malformed UTF-8 encoding */

      pc_readsrc(fp,bom,3);

      assert(bom[0]==0xef && bom[1]==0xbb && bom[2]==0xbf);

    } /* if */

    return utf8;

  #endif  /* NO_UTF8 */

}