/* shindou8_no_ucs2.c - Don Yang (uguu.org)

   02/19/07
                                                                           */

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

static FILE *infile;
static unsigned char *tmp, *buffer,
            /*   01       3    5       7 */
   *const_str = " \xef\xbc\x81I\xa1\xaa!";
static int u, a,
           state,
           buffer_size, read_size,
           i, i0, last_char_offset,
           c,
           utf8_kana,
           sjis_kana,
           eucjp_kana,
           encoding,
   ke38081 = 0xe38081, ke3827f = 0xe3827f, kefbc81 = 0xefbc81,
   kefbda1 = 0xefbda1,
   k33089 = 33089, k33438 = 33438,
   k41378 = 41378,
   k128 = 128, k160 = 160, k192 = 192, k224 = 224,
   k240 = 240, k248 = 248, k255 = 255;

static void Output(void *data, size_t size)
{
   fwrite(data, size, 1, stdout);
}

static void ExtendBuffer(void)
{
   if( read_size - buffer_size )
   {
      read_size +=
         fread(buffer + read_size, 1, buffer_size - read_size, infile);
   }
   else
   {
      tmp = buffer;
      buffer = malloc((buffer_size *= 2) + 3);
      memcpy(buffer, tmp, read_size);
      free(tmp);
   }
}

static void NextByte(void)
{
   c = (c << 8) | buffer[i++];
}

static void NextUTF8Char(void)
{
   c = 0;
   if( (buffer[i] & k224) - k192 )
   {
      if( (buffer[i] & k240) - k224 )
      {
         if( (buffer[i] & k248) - k240 )
         {
            NextByte();
         }
         else
         {
            if( (buffer[i + 1] & k192) - k128 ||
                (buffer[i + 2] & k192) - k128 ||
                (buffer[i + 2] & k192) - k128 )
            {
               c--;
            }
            else
            {
               NextByte();
               NextByte();
               NextByte();
               NextByte();
            }
         }
      }
      else
      {
         if( (buffer[i + 1] & k192) - k128 ||
             (buffer[i + 2] & k192) - k128 )
         {
            c--;
         }
         else
         {
            NextByte();
            NextByte();
            NextByte();
         }
      }
   }
   else
   {
      if( (buffer[i + 1] & k192) - k128 )
      {
         c--;
      }
      else
      {
         NextByte();
         NextByte();
      }
   }
}

static void NextSJISChar(void)
{
   c = 0;
   if( (buffer[i] > k128 && buffer[i] < k160) ||
       (buffer[i] >= k224 && buffer[i] < k240) )
   {
      if( buffer[i + 1] < 64 || buffer[i + 1] > k255-3 )
      {
         c--;
      }
      else
      {
         NextByte();
         NextByte();
      }
   }
   else
   {
      NextByte();
   }
}

static void NextEUCJPChar(void)
{
   c = 0;
   if( (buffer[i] > k160 && buffer[i] < k160+9) ||
       buffer[i] == 173 ||
       (buffer[i] > 175 && buffer[i] < k240+5) ||
       (buffer[i] > k255-7 && buffer[i] < k255-2) )
   {
      if( buffer[i + 1] <= k160 || buffer[i + 1] >= k255 )
      {
         c--;
      }
      else
      {
         NextByte();
         NextByte();
      }
   }
   else
   {
      NextByte();
   }
}

static void DetectFileEncoding(void)
{
   read_size =
   utf8_kana =
   sjis_kana =
   eucjp_kana = 0;
   encoding = 7;
   for(; !feof(infile) && encoding & (encoding - 1);)
   {
      ExtendBuffer();

      if( buffer[0] + 1 - k240 ||
          buffer[1] + 5 - k192 || buffer[2] + 1 - k192 )
      {
         for(i = 0; i < read_size - 3 && encoding & 1;)
         {
            NextUTF8Char();
            if( c < 0 )
               encoding &= ~1;
            else if( (c > ke38081+k255 && c < ke3827f-k192+1) ||
                     (c > ke3827f && c < ke3827f+21) )
               utf8_kana++;
         }

         for(i = 0; i < read_size - 1 && encoding & 2;)
         {
            NextSJISChar();
            if( c < 0 )
               encoding &= ~2;
            else if( c > k33438 && c < k33438+84 )
               sjis_kana++;
         }

         for(i = 0; i < read_size - 1 && encoding & 4;)
         {
            NextEUCJPChar();
            if( c < 0 )
               encoding &= ~4;
            else if( c > 42144 && c < 42228 )
               eucjp_kana++;
         }
      }
      else
      {
         encoding = 1;
      }
   }

   if( !(encoding & 1) ) utf8_kana = 0;
   if( !(encoding & 2) ) sjis_kana = 0;
   if( !(encoding & 4) ) eucjp_kana = 0;

   encoding =
      utf8_kana < sjis_kana
         ?  sjis_kana < eucjp_kana ? 4 : 2
         :  utf8_kana < eucjp_kana ? 4 :
            encoding & 1 ? 1 : 2;
}

static int IsAlpha(void)
{
   return
      (c > 96 && c < k128-5) ||
      (c > 64 && c < 91) ||
      (c > 47 && c < 58) ||
      c == 45 || c == 95 ||
      c == 32 || c == 9;
}

static int IsExclaimationPunct(void)
{
   return
      c == 33 ||
      (encoding & 1 && c == kefbc81) ||
      (encoding & 2 && c == k33089+8) ||
      (encoding & 4 && c == k41378+8);
}

static int IsEOSPunct(void)
{
   return
      c == 46 || c == 63 ||
      (encoding & 1 &&
       (c == kefbc81+30 || c == kefbc81+13 || c == ke38081+1 ||
        c == kefbda1)) ||
      (encoding & 2 &&
       (c == k33089+7 || c == k33089+3 || c == k33089+1)) ||
      (encoding & 4 &&
       (c == k41378+7 || c == k41378+3 || c == k41378+1)) ||
      IsExclaimationPunct();
}

static int IsPunct(void)
{
   return
      c == 44 || c == 10 ||
      (encoding & 1 &&
       (c == kefbc81+11 || c == ke38081 || c == kefbda1+3)) ||
      (encoding & 2 &&
       (c == k33089+2 || c == k33089)) ||
      (encoding & 4 &&
       (c == k41378+2 || c == k41378)) ||
      IsEOSPunct();
}

static void ToUpperChar(void)
{
   buffer[u] -= buffer[u] > 96 && buffer[u] < k128-5 ? 32 : 0;
   u++;
}

static void ToUpperUTF8(void)
{
   for(u = i0; u < i;)
   {
      if( (buffer[u] & k248) - k240 )
      {
         if( (buffer[u] & k240) - k224 )
         {
            if( (buffer[u] & k224) - k192 )
               ToUpperChar();
            else
               u += 2;
         }
         else
         {
            u += 3;
         }
      }
      else
      {
         u += 4;
      }
   }
}

static void ToUpperJIS(void)
{
   for(u = i0; u < i;)
   {
      if( (buffer[u] > k128 && buffer[i] < k160) ||
          (buffer[u] >= k224 && buffer[i] < k240) )
         u++;
      else
         ToUpperChar();
   }
}

static void WriteExclamationMark(void)
{
   Output(const_str +
          (c > k255
            ?  encoding & 1 ? 1 :
               encoding & 2 ? 3 : 5
            :  7),
          (c > k255
            ?  encoding & 1 ? 3 : 2
            :  1));
}

static void Flush(void)
{
   if( i0 - last_char_offset )
      Output(buffer + i0, last_char_offset - i0);
   if( IsExclaimationPunct() )
   {
      WriteExclamationMark();
      WriteExclamationMark();
   }
   else if( IsPunct() && c - 10 )
   {
      WriteExclamationMark();
   }
   else
   {
      Output(buffer + last_char_offset, i - last_char_offset);
   }
}

static void FlushWithSpace(void)
{
   for(; i0 < last_char_offset; i0 += u)
   {
      Output(buffer + i0,
             u = (
               encoding & 1
                  ? (buffer[i0] & k248) - k240
                     ?  (buffer[i0] & k240) - k224
                        ?  (buffer[i0] & k224) - k192
                           ? 1
                           : 2
                        : 3
                     : 4
                  : buffer[i0] >= k128 ? 2 : 1));
      Output(const_str, 1);
   }
}

static void Filter(void (*NextChar)(void),
                   void (*ToUpper)(void))
{
   i = i0 =
   state = 0;
   for(; !feof(infile) || i < read_size;)
   {
      last_char_offset = i;
      NextChar();
      if( i < read_size - 3 )
      {
         memmove(buffer, buffer + i0, read_size - i0);
         read_size -= i0;
         i -= i0;
         last_char_offset -= i0;
         i0 = 0;

         ExtendBuffer();
      }

      if( !state )
      {
         if( c >= k128 )
         {
            state = 2;
         }
         else if( IsAlpha() )
         {
            state = 1;
         }
         else
         {
            Output(buffer + last_char_offset, i - last_char_offset);
         }
         i0 = last_char_offset;
      }
      else
      {
         if( IsPunct() ||
             (state - 1 && IsAlpha()) ||
             (state - 2 && !IsAlpha()) )
         {
            if( IsEOSPunct() )
            {
               if( state - 1 )
                  FlushWithSpace();
               else
                  ToUpper();
            }
            Flush();
            state = 0;
         }
      }
   }
}

int main(int argc, char **argv)
{
   buffer_size = 4096;
   buffer = malloc(buffer_size);

   if( argc > 1 )
   {
      for(a = 1; a < argc; a++)
      {
         Output(argv[a], strlen(argv[a]));
         Output(": ", 2);
         if( (infile = fopen(argv[a], "rb")) )
         {
            DetectFileEncoding();
            tmp = encoding - 1
                   ? encoding - 2
                      ? "EUC-JP"
                      : "Shift_JIS"
                   : "UTF-8";
            fclose(infile);
         }
         else
         {
            tmp = "can not open file";
         }
         puts(tmp);
      }
   }
   else
   {
      infile = stdin;
      DetectFileEncoding();
      if( encoding & 1 )
      {
         Filter(NextUTF8Char, ToUpperUTF8);
      }
      else
      {
         if( encoding & 2 )
            Filter(NextSJISChar, ToUpperJIS);
         else
            Filter(NextEUCJPChar, ToUpperJIS);
      }
   }

   free(buffer);
   return 0;
}