// Copyright (c) 1994 James Clark

// See the file COPYING for copying permission.

#include "splib.h"

#ifdef SP_MULTI_BYTE

#include "UTF8CodingSystem.h"

#include "constant.h"

#ifdef SP_NAMESPACE

namespace SP_NAMESPACE {

#endif

enum {

  // cmaskN is mask for first byte to test for N byte sequence

  cmask1 = 0x80,

  cmask2 = 0xe0,

  cmask3 = 0xf0,

  cmask4 = 0xf8,

  cmask5 = 0xfc,

  cmask6 = 0xfe,

  // cvalN is value of masked first byte of N byte sequence

  cval1 = 0x00,

  cval2 = 0xc0,

  cval3 = 0xe0,

  cval4 = 0xf0,

  cval5 = 0xf8,

  cval6 = 0xfc,

  // vmaskN is mask to get value from first byte in N byte sequence

  vmask2 = 0x1f,

  vmask3 = 0xf,

  vmask4 = 0x7,

  vmask5 = 0x3,

  vmask6 = 0x1,

  // minN is minimum legal resulting value for N byte sequence

  min2 = 0x80,

  min3 = 0x800,

  min4 = 0x10000,

  min5 = 0x200000,

  min6 = 0x4000000,

  max6 = 0x7fffffff

};

class UTF8Decoder : public Decoder {

public:

  UTF8Decoder();

  size_t decode(Char *, const char *, size_t, const char **);

  Boolean convertOffset(unsigned long &offset) const;

private:

  // value for encoding error

  enum { invalid = 0xfffd };

  Boolean recovering_;

  PackedBoolean hadFirstChar_;

  PackedBoolean hadByteOrderMark_;

};

class UTF8Encoder : public Encoder {

public:

  UTF8Encoder();

  void output(const Char *, size_t, OutputByteStream *);

};

Decoder *UTF8CodingSystem::makeDecoder() const

{

  return new UTF8Decoder;

}

Encoder *UTF8CodingSystem::makeEncoder() const

{

  return new UTF8Encoder;

}

UTF8Decoder::UTF8Decoder()

: recovering_(0), hadFirstChar_(0), hadByteOrderMark_(0)

{

}

size_t UTF8Decoder::decode(Char *to, const char *s,

			  size_t slen, const char **result)

{

  // Check for byte-order mark

  if (!hadFirstChar_ && slen >= 3) {

    hadFirstChar_ = 1;

    if ((unsigned char)s[0] == 0xEF &&

        (unsigned char)s[1] == 0xBB &&

        (unsigned char)s[2] == 0xBF) {

      s += 3;

      slen -= 3;

      hadByteOrderMark_ = 1;

    }

  }

  Char *start = to;

  const unsigned char *us = (const unsigned char *)s;

  if (recovering_) {

    recovering_ = 0;

    goto recover;

  }

  while (slen > 0) {

    unsigned c0;

    c0 = us[0];

    if ((c0 & cmask1) == cval1) {

      *to++ = c0;

      us++;

      slen--;

    }

    else if ((c0 & cmask2) == cval2) {

      if (slen < 2)

	goto done;

      unsigned c1 = us[1] ^ 0x80;

      if (c1 & 0xc0)

	goto error;

      unsigned c = ((c0 & vmask2) << 6) | c1;

      if (c < min2)

	c = invalid;

      *to++ = c;

      slen -= 2;

      us += 2;

    }

    else if ((c0 & cmask3) == cval3) {

      if (slen < 3)

	goto done;

      unsigned c1 = us[1] ^ 0x80;

      unsigned c2 = us[2] ^ 0x80;

      if ((c1 | c2) & 0xc0)

	goto error;

      unsigned c = ((((c0 & vmask3) << 6) | c1) << 6) | c2;

      if (c < min3)

	c = invalid;

      *to++ = c;

      slen -= 3;

      us += 3;

    }

    else if ((c0 & cmask4) == cval4) {

      if (slen < 4)

	goto done;

      unsigned c1 = us[1] ^ 0x80;

      unsigned c2 = us[2] ^ 0x80;

      unsigned c3 = us[3] ^ 0x80;

      if ((c1 | c2 | c3) & 0xc0)

	goto error;

      if (charMax < min5 - 1)

	*to++ = invalid;

      else {

	unsigned long c = ((((c0 & vmask4) << 6) | c1) << 6) | c2;

	c = (c << 6) | c3;

	if (c < min4)

	  c = invalid;

	*to++ = c;

      }

      slen -= 4;

      us += 4;

    }

    else if ((c0 & cmask5) == cval5) {

      if (slen < 5)

	goto done;

      unsigned c1 = us[1] ^ 0x80;

      unsigned c2 = us[2] ^ 0x80;

      unsigned c3 = us[3] ^ 0x80;

      unsigned c4 = us[4] ^ 0x80;

      if ((c1 | c2 | c3 | c4) & 0xc0)

	goto error;

      if (charMax < min6 - 1)

	*to++ = invalid;

      else {

	unsigned long c = ((((c0 & vmask5) << 6) | c1) << 6) | c2;

	c = (((c << 6) | c3) << 6) | c4;

	if (c < min5)

	  c = invalid;

	*to++ = c;

      }

      slen -= 5;

      us += 5;

    }

    else if ((c0 & cmask6) == cval6) {

      if (slen < 6)

	goto done;

      unsigned c1 = us[1] ^ 0x80;

      unsigned c2 = us[2] ^ 0x80;

      unsigned c3 = us[3] ^ 0x80;

      unsigned c4 = us[4] ^ 0x80;

      unsigned c5 = us[5] ^ 0x80;

      if ((c1 | c2 | c3 | c4 | c5) & 0xc0)

	goto error;

      if (charMax < max6)

	*to++ = invalid;

      else {

	unsigned long c = ((((c0 & vmask6) << 6) | c1) << 6) | c2;

	c = (((((c << 6) | c3) << 6) | c4) << 6) | c5;

	if (c < min6)

	  c = invalid;

	*to++ = c;

      }

      slen -= 6;

      us += 6;

    }

    else {

    error:

      us++;

      slen--;

      *to++ = invalid;

    recover:

      for (;;) {

	if (slen == 0) {

	  recovering_ = 1;

	  goto done;

	}

	if ((*us & 0xc0) != 0x80)

	  break;

	us++;

	slen--;

      }

    }

  }

 done:

  *result = (char *)us;

  return to - start;

}

Boolean UTF8Decoder::convertOffset(unsigned long &n) const

{

  if (hadByteOrderMark_)

    n += 3;

  return true;

}

UTF8Encoder::UTF8Encoder()

{

}

void UTF8Encoder::output(const Char *s, size_t n, OutputByteStream *sb)

{

  for (; n > 0; s++, n--) {

    Char c = *s;

    if (c < min2)

      sb->sputc((unsigned char)c);

    else if (c < min3) {

      sb->sputc((c >> 6) | cval2);

      sb->sputc((c & 0x3f) | 0x80);

    }

    else if (c < min4) {

      sb->sputc((c >> 12) | cval3);

      sb->sputc(((c >> 6) & 0x3f) | 0x80);

      sb->sputc((c & 0x3f) | 0x80);

    }

    else if (c < min5) {

      sb->sputc((c >> 18) | cval4);

      sb->sputc(((c >> 12) & 0x3f) | 0x80);

      sb->sputc(((c >> 6) & 0x3f) | 0x80);

      sb->sputc((c & 0x3f) | 0x80);

    }

    else if (c < min6) {

      sb->sputc((c >> 24) | cval5);

      sb->sputc(((c >> 18) & 0x3f) | 0x80);

      sb->sputc(((c >> 12) & 0x3f) | 0x80);

      sb->sputc(((c >> 6) & 0x3f) | 0x80);

      sb->sputc((c & 0x3f) | 0x80);

    }

    else if (c <= max6) {

      sb->sputc((c >> 30) | cval6);

      sb->sputc(((c >> 24) & 0x3f) | 0x80);

      sb->sputc(((c >> 18) & 0x3f) | 0x80);

      sb->sputc(((c >> 12) & 0x3f) | 0x80);

      sb->sputc(((c >> 6) & 0x3f) | 0x80);

      sb->sputc((c & 0x3f) | 0x80);

    }

  }

}

#ifdef SP_NAMESPACE

}

#endif

#else /* not SP_MULTI_BYTE */

#ifndef __GNUG__

static char non_empty_translation_unit;	// sigh

#endif

#endif /* not SP_MULTI_BYTE */