rune.c File Reference

#include <stdarg.h>
#include <string.h>
#include "third_party/utf/utf.h"
#include "third_party/utf/utfdef.h"

Go to the source code of this file.

Enumerations
enum	{   Bit1 = 7 , Bitx = 6 , Bit2 = 5 , Bit3 = 4 ,   Bit4 = 3 , Bit5 = 2 , T1 = ((1 << (Bit1 + 1)) - 1) ^ 0xFF , Tx = ((1 << (Bitx + 1)) - 1) ^ 0xFF ,   T2 = ((1 << (Bit2 + 1)) - 1) ^ 0xFF , T3 = ((1 << (Bit3 + 1)) - 1) ^ 0xFF , T4 = ((1 << (Bit4 + 1)) - 1) ^ 0xFF , T5 = ((1 << (Bit5 + 1)) - 1) ^ 0xFF ,   Rune1 = (1 << (Bit1 + 0 * Bitx)) - 1 , Rune2 = (1 << (Bit2 + 1 * Bitx)) - 1 , Rune3 = (1 << (Bit3 + 2 * Bitx)) - 1 , Rune4 = (1 << (Bit4 + 3 * Bitx)) - 1 ,   Maskx = (1 << Bitx) - 1 , Testx = Maskx ^ 0xFF , Bad = Runeerror }

Functions
int	charntorune (Rune *rune, const char *str, int length)
int	chartorune (Rune *rune, const char *str)
int	isvalidcharntorune (const char *str, int length, Rune *rune, int *consumed)
int	runetochar (char *str, const Rune *rune)
int	runelen (Rune rune)
int	runenlen (const Rune *r, int nrune)
int	fullrune (const char *str, int n)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
Bit1
Bitx
Bit2
Bit3
Bit4
Bit5
T1
Tx
T2
T3
T4
T5
Rune1
Rune2
Rune3
Rune4
Maskx
Testx
Bad

Definition at line 19 of file rune.c.

     {
  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,
};

Function Documentation

charntorune()

int charntorune	(	Rune *	rune,
		const char *	str,
		int	length
	)

Definition at line 64 of file rune.c.

                                                         {
  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;
    if (l > Runemax)
      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;
}

chartorune()

int chartorune	(	Rune *	rune,
		const char *	str
	)

Definition at line 163 of file rune.c.

                                            {
  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;
    if (l > Runemax)
      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;
}

fullrune()

int fullrune	(	const char *	str,
		int	n
	)

Definition at line 326 of file rune.c.

                                     {
  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;
}

isvalidcharntorune()

int isvalidcharntorune	(	const char *	str,
		int	length,
		Rune *	rune,
		int *	consumed
	)

Definition at line 239 of file rune.c.

                                                                               {
  *consumed = charntorune(rune, str, length);
  return *rune != Runeerror || *consumed == 3;
}

runelen()

int runelen

(

Rune

rune

)

Definition at line 299 of file rune.c.

                       {
  char str[10];
 
  return runetochar(str, &rune);
}

runenlen()

int runenlen	(	const Rune *	r,
		int	nrune
	)

Definition at line 305 of file rune.c.

                                       {
  int nb;
  ulong c; /* Rune is signed, so use unsigned for range check. */
 
  nb = 0;
  while (nrune--) {
    c = *r++;
    if (c <= Rune1)
      nb++;
    else if (c <= Rune2)
      nb += 2;
    else if (c <= Rune3)
      nb += 3;
    else if (c <= Runemax)
      nb += 4;
    else
      nb += 3; /* Runeerror = 0xFFFD, see runetochar */
  }
  return nb;
}

runetochar()

int runetochar	(	char *	str,
		const Rune *	rune
	)

Definition at line 244 of file rune.c.

                                            {
  /* 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;
}