text: /*
   * The authors of this software are Rob Pike and Ken Thompson.
   *              Copyright (c) 2002 by Lucent Technologies.
   * Permission to use, copy, modify, and distribute this software for any
   * purpose without fee is hereby granted, provided that this entire notice
   * is included in all copies of any software which is or includes a copy
   * or modification of this software and in all copies of the supporting
   * documentation for such software.
   * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
   * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
   * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
   * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
   */
  #include <stdarg.h>
  #include <string.h>
  #include "kudu/gutil/utf/utf.h"
  #include "kudu/gutil/utf/utfdef.h"
  
  enum
  {
  	Bit1	= 7,
  	Bitx	= 6,
  	Bit2	= 5,
  	Bit3	= 4,
  	Bit4	= 3,
  	Bit5	= 2, 
  
  	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
  	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
  	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
  	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
  	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
  	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
  
  	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
  	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
  	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
  	Rune4	= (1<<(Bit4+3*Bitx))-1,
                                          /* 0001 1111 1111 1111 1111 1111 */
  
  	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
  	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
  
  	Bad	= Runeerror,
  };
  
  /*
   * Modified by Wei-Hwa Huang, Google Inc., on 2004-09-24
   * This is a slower but "safe" version of the old chartorune 
   * that works on strings that are not necessarily null-terminated.
   * 
   * If you know for sure that your string is null-terminated,
   * chartorune will be a bit faster.
   *
   * It is guaranteed not to attempt to access "length"
   * past the incoming pointer.  This is to avoid
   * possible access violations.  If the string appears to be
   * well-formed but incomplete (i.e., to get the whole Rune
   * we'd need to read past str+length) then we'll set the Rune
   * to Bad and return 0.
   *
   * Note that if we have decoding problems for other
   * reasons, we return 1 instead of 0.
   */
  int
  charntorune(Rune *rune, const char *str, int length)
  {
  	int c, c1, c2, c3;
  	long l;
  
  	/* When we're not allowed to read anything */
  	if(length <= 0) {
  		goto badlen;
  	}
  
  	/*
  	 * one character sequence (7-bit value)
  	 *	00000-0007F => T1
  	 */
  	c = *(uchar*)str;
  	if(c < Tx) {
  		*rune = c;
  		return 1;
  	}
  
  	// If we can't read more than one character we must stop
  	if(length <= 1) {
  		goto badlen;
  	}
  
  	/*
  	 * two character sequence (11-bit value)
  	 *	0080-07FF => T2 Tx
  	 */
  	c1 = *(uchar*)(str+1) ^ Tx;
  	if(c1 & Testx)
  		goto bad;
  	if(c < T3) {
  		if(c < T2)
  			goto bad;
  		l = ((c << Bitx) | c1) & Rune2;
  		if(l <= Rune1)
  			goto bad;
  		*rune = l;
  		return 2;
  	}
  
  	// If we can't read more than two characters we must stop
  	if(length <= 2) {
  		goto badlen;
  	}
  
  	/*
  	 * three character sequence (16-bit value)
  	 *	0800-FFFF => T3 Tx Tx
  	 */
  	c2 = *(uchar*)(str+2) ^ Tx;
  	if(c2 & Testx)
  		goto bad;
  	if(c < T4) {
  		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
  		if(l <= Rune2)
  			goto bad;
  		*rune = l;
  		return 3;
  	}
  
  	if (length <= 3)
  		goto badlen;
  
  	/*
  	 * four character sequence (21-bit value)
  	 *	10000-1FFFFF => T4 Tx Tx Tx
  	 */
  	c3 = *(uchar*)(str+3) ^ Tx;
  	if (c3 & Testx)
  		goto bad;
  	if (c < T5) {
  		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
  		if (l <= Rune3)
  			goto bad;
  		*rune = l;
  		return 4;
  	}
  
  	// Support for 5-byte or longer UTF-8 would go here, but
  	// since we don't have that, we'll just fall through to bad.
  
  	/*
  	 * bad decoding
  	 */
  bad:
  	*rune = Bad;
  	return 1;
  badlen:
  	*rune = Bad;
  	return 0;
  
  }
  
  
  /*
   * This is the older "unsafe" version, which works fine on 
   * null-terminated strings.
   */
  int
  chartorune(Rune *rune, const char *str)
  {
  	int c, c1, c2, c3;
  	long l;
  
  	/*
  	 * one character sequence
  	 *	00000-0007F => T1
  	 */
  	c = *(uchar*)str;
  	if(c < Tx) {
  		*rune = c;
  		return 1;
  	}
  
  	/*
  	 * two character sequence
  	 *	0080-07FF => T2 Tx
  	 */
  	c1 = *(uchar*)(str+1) ^ Tx;
  	if(c1 & Testx)
  		goto bad;
  	if(c < T3) {
  		if(c < T2)
  			goto bad;
  		l = ((c << Bitx) | c1) & Rune2;
  		if(l <= Rune1)
  			goto bad;
  		*rune = l;
  		return 2;
  	}
  
  	/*
  	 * three character sequence
  	 *	0800-FFFF => T3 Tx Tx
  	 */
  	c2 = *(uchar*)(str+2) ^ Tx;
  	if(c2 & Testx)
  		goto bad;
  	if(c < T4) {
  		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
  		if(l <= Rune2)
  			goto bad;
  		*rune = l;
  		return 3;
  	}
  
  	/*
  	 * four character sequence (21-bit value)
  	 *	10000-1FFFFF => T4 Tx Tx Tx
  	 */
  	c3 = *(uchar*)(str+3) ^ Tx;
  	if (c3 & Testx)
  		goto bad;
  	if (c < T5) {
  		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
  		if (l <= Rune3)
  			goto bad;
  		*rune = l;
  		return 4;
  	}
  
  	/*
  	 * Support for 5-byte or longer UTF-8 would go here, but
  	 * since we don't have that, we'll just fall through to bad.
  	 */
  
  	/*
  	 * bad decoding
  	 */
  bad:
  	*rune = Bad;
  	return 1;
  }
  
  int
  isvalidcharntorune(const char* str, int length, Rune* rune, int* consumed) {
  	*consumed = charntorune(rune, str, length);
  	return *rune != Runeerror || *consumed == 3;
  }
      
  int
  runetochar(char *str, const Rune *rune)
  {
  	/* Runes are signed, so convert to unsigned for range check. */
  	unsigned long c;
  
  	/*
  	 * one character sequence
  	 *	00000-0007F => 00-7F
  	 */
  	c = *rune;
  	if(c <= Rune1) {
  		str[0] = c;
  		return 1;
  	}
  
  	/*
  	 * two character sequence
  	 *	0080-07FF => T2 Tx
  	 */
  	if(c <= Rune2) {
  		str[0] = T2 | (c >> 1*Bitx);
  		str[1] = Tx | (c & Maskx);
  		return 2;
  	}
  
  	/*
  	 * If the Rune is out of range, convert it to the error rune.
  	 * Do this test here because the error rune encodes to three bytes.
  	 * Doing it earlier would duplicate work, since an out of range
  	 * Rune wouldn't have fit in one or two bytes.
  	 */
  	if (c > Runemax)
  		c = Runeerror;
  
  	/*
  	 * three character sequence
  	 *	0800-FFFF => T3 Tx Tx
  	 */
  	if (c <= Rune3) {
  		str[0] = T3 |  (c >> 2*Bitx);
  		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
  		str[2] = Tx |  (c & Maskx);
  		return 3;
  	}
  
  	/*
  	 * four character sequence (21-bit value)
  	 *     10000-1FFFFF => T4 Tx Tx Tx
  	 */
  	str[0] = T4 | (c >> 3*Bitx);
  	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
  	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
  	str[3] = Tx | (c & Maskx);
  	return 4;
  }
  
  int
  runelen(Rune rune)
  {
  	char str[10];
  
  	return runetochar(str, &rune);
  }
  
  int
  runenlen(const Rune *r, int nrune)
  {
  	int nb, c;
  
  	nb = 0;
  	while(nrune--) {
  		c = *r++;
  		if (c <= Rune1)
  			nb++;
  		else if (c <= Rune2)
  			nb += 2;
  		else if (c <= Rune3)
  			nb += 3;
  		else /* assert(c <= Rune4) */ 
  			nb += 4;
  	}
  	return nb;
  }
  
  int
  fullrune(const char *str, int n)
  {
  	if (n > 0) {
  		int c = *(uchar*)str;
  		if (c < Tx)
  			return 1;
  		if (n > 1) {
  			if (c < T3)
  				return 1;
  			if (n > 2) {
  				if (c < T4 || n > 3)
  					return 1;
  			}
  		}
  	}
  	return 0;
  }
  