utf8Utils.c

/* "$Id: $"
 *
 * Author: Jean-Marc Lienher ( http://oksid.ch )
 * Copyright 2000-2003 by O'ksi'D.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA.
 *
 * Please report all bugs and problems on the following page:
 *
 *     http://www.fltk.org/str.php
 */
 
/*
 * Unicode to UTF-8 conversion functions.
 */
 
#if !defined(WIN32) && !defined(__APPLE__)
 
#include "../../FL/Xutf8.h"
 
/*** NOTE : all functions are LIMITED to 24 bits Unicode values !!! ***/
 
/* 
 * Converts the first char of the UTF-8 string to an Unicode value 
 * Returns the byte length of the converted UTF-8 char 
 * Returns -1 if the UTF-8 string is not valid 
 */
int
XConvertUtf8ToUcs(const unsigned char     *buf,
                  int                     len,
                  unsigned int            *ucs) {
 
  if (buf[0] & 0x80) {
    if (buf[0] & 0x40) {
      if (buf[0] & 0x20) {
        if (buf[0] & 0x10) {
          if (buf[0] & 0x08) {
            if (buf[0] & 0x04) {
              if (buf[0] & 0x02) {
                /* bad UTF-8 string */
              } else {
                /* 0x04000000 - 0x7FFFFFFF */
              } 
            } else if (len > 4 
                       && (buf[1] & 0xC0) == 0x80
                       && (buf[2] & 0xC0) == 0x80
                       && (buf[3] & 0xC0) == 0x80
                       && (buf[4] & 0xC0) == 0x80) {
              /* 0x00200000 - 0x03FFFFFF */
              *ucs =  ((buf[0] & ~0xF8) << 24) +
                      ((buf[1] & ~0x80) << 18) +
                      ((buf[2] & ~0x80) << 12) +
                      ((buf[3] & ~0x80) << 6) +
                       (buf[4] & ~0x80);
              if (*ucs > 0x001FFFFF && *ucs < 0x01000000) return 5;
            }
          } else if (len > 3 
                     && (buf[1] & 0xC0) == 0x80
                     && (buf[2] & 0xC0) == 0x80
                     && (buf[3] & 0xC0) == 0x80) {
            /* 0x00010000 - 0x001FFFFF */
            *ucs =  ((buf[0] & ~0xF0) << 18) +
                    ((buf[1] & ~0x80) << 12) +
                    ((buf[2] & ~0x80) << 6) +
                     (buf[3] & ~0x80);
            if (*ucs > 0x0000FFFF) return 4;
          }
        } else if (len > 2
                   && (buf[1] & 0xC0) == 0x80 
                   && (buf[2] & 0xC0) == 0x80) {
          /* 0x00000800 - 0x0000FFFF */
          *ucs =  ((buf[0] & ~0xE0) << 12) +
                  ((buf[1] & ~0x80) << 6) +
                   (buf[2] & ~0x80);
          if (*ucs > 0x000007FF) return 3;
        }       
      } else if (len > 1 && (buf[1] & 0xC0) == 0x80) {
        /* 0x00000080 - 0x000007FF */
        *ucs = ((buf[0] & ~0xC0) << 6) +
                (buf[1] & ~0x80);
        if (*ucs > 0x0000007F) return 2;
      }
    }
  } else if (len > 0) {
    /* 0x00000000 - 0x0000007F */
    *ucs = buf[0];
    return 1;
  } 
 
  *ucs = (unsigned int) '?'; /* bad utf-8 string */
  return -1;
}
 
/* 
 * Converts an Unicode value to an UTF-8 string 
 * NOTE : the buffer (buf) must be at least 5 bytes long !!!  
 */
int 
XConvertUcsToUtf8(unsigned int  ucs, 
                  char          *buf) {
 
  if (ucs < 0x000080) {
    buf[0] = ucs;
    return 1;
  } else if (ucs < 0x000800) {
    buf[0] = 0xC0 | (ucs >> 6);
    buf[1] = 0x80 | (ucs & 0x3F);
    return 2;
  } else if (ucs < 0x010000) { 
    buf[0] = 0xE0 | (ucs >> 12);
    buf[1] = 0x80 | ((ucs >> 6) & 0x3F);
    buf[2] = 0x80 | (ucs & 0x3F);
    return 3;
  } else if (ucs < 0x00200000) {
    buf[0] = 0xF0 | (ucs >> 18);
    buf[1] = 0x80 | ((ucs >> 12) & 0x3F);
    buf[2] = 0x80 | ((ucs >> 6) & 0x3F);
    buf[3] = 0x80 | (ucs & 0x3F);
    return 4;
  } else if (ucs < 0x01000000) {
    buf[0] = 0xF8 | (ucs >> 24);
    buf[1] = 0x80 | ((ucs >> 18) & 0x3F);
    buf[2] = 0x80 | ((ucs >> 12) & 0x3F);
    buf[3] = 0x80 | ((ucs >> 6) & 0x3F);
    buf[4] = 0x80 | (ucs & 0x3F);
    return 5;
  }
  buf[0] = '?';
  return -1;
}
 
/* 
 * returns the byte length of the first UTF-8 char 
 * (returns -1 if not valid) 
 */
int
XUtf8CharByteLen(const unsigned char     *buf,
                 int                     len) {
  unsigned int ucs;
  return XConvertUtf8ToUcs(buf, len, &ucs);
}
 
/*
 * returns the quantity of Unicode chars in the UTF-8 string 
 */
int 
XCountUtf8Char(const unsigned char      *buf, 
               int                      len) {
 
  int i = 0;
  int nbc = 0;
  while (i < len) {
    int cl = XUtf8CharByteLen(buf + i, len - i);
    if (cl < 1) cl = 1;
    nbc++;
    i += cl;
  }
  return nbc;
}
 
/* 
 * Same as XConvertUtf8ToUcs but no sanity check is done.
 */
int
XFastConvertUtf8ToUcs(const unsigned char     *buf,
                      int                     len,
                      unsigned int            *ucs) {
 
  if (buf[0] & 0x80) {
    if (buf[0] & 0x40) {
      if (buf[0] & 0x20) {
        if (buf[0] & 0x10) {
          if (buf[0] & 0x08) {
            if (buf[0] & 0x04) {
              if (buf[0] & 0x02) {
                /* bad UTF-8 string */
              } else {
                /* 0x04000000 - 0x7FFFFFFF */
              } 
            } else if (len > 4) {
              /* 0x00200000 - 0x03FFFFFF */
              *ucs =  ((buf[0] & ~0xF8) << 24) +
                      ((buf[1] & ~0x80) << 18) +
                      ((buf[2] & ~0x80) << 12) +
                      ((buf[3] & ~0x80) << 6) +
                       (buf[4] & ~0x80);
              return 5;
            }
          } else if (len > 3) {
            /* 0x00010000 - 0x001FFFFF */
            *ucs =  ((buf[0] & ~0xF0) << 18) +
                    ((buf[1] & ~0x80) << 12) +
                    ((buf[2] & ~0x80) << 6) +
                     (buf[3] & ~0x80);
            return 4;
          }
        } else if (len > 2) {
          /* 0x00000800 - 0x0000FFFF */
          *ucs =  ((buf[0] & ~0xE0) << 12) +
                  ((buf[1] & ~0x80) << 6) +
                   (buf[2] & ~0x80);
          return 3;
        }       
      } else if (len > 1) {
        /* 0x00000080 - 0x000007FF */
        *ucs = ((buf[0] & ~0xC0) << 6) +
                (buf[1] & ~0x80);
        return 2;
      }
    }
  } else if (len > 0) {
    /* 0x00000000 - 0x0000007F */
    *ucs = buf[0];
    return 1;
  } 
 
  *ucs = (unsigned int) '?'; /* bad utf-8 string */
  return -1;
}
 
#endif /* X11 only */
 
/*
 * End of "$Id: $".
 */