mirror of
https://github.com/tesseract-ocr/tesseract.git
synced 2024-12-18 19:39:24 +08:00
342 lines
7.4 KiB
C
342 lines
7.4 KiB
C
/*
|
|
* 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 "third_party/utf/utf.h"
|
|
#include "third_party/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;
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
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;
|
|
}
|
|
|
|
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;
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|