UBool parseLevels(const char *&start);
UBool parseOrdering(const char *start);
- UBool parseInputStringFromBiDiClasses(const char *&start, UBool parseChars);
+ UBool parseInputStringFromBiDiClasses(const char *&start);
UBool checkLevels(const UBiDiLevel actualLevels[], int32_t actualCount);
UBool checkOrdering(UBiDi *ubidi);
return TRUE;
}
-static const UChar pseudoCharFromBiDiClass[U_CHAR_DIRECTION_COUNT]={
+static const UChar charFromBiDiClass[U_CHAR_DIRECTION_COUNT]={
0x6c, // 'l' for L
0x52, // 'R' for R
0x33, // '3' for EN
0x2e // '.' for PDI
};
-static const UChar realCharFromBiDiClass[U_CHAR_DIRECTION_COUNT]={
- 0x006c, // 'l' for L
- 0x05d0, // Hebrew Letter Alef for R
- 0x0033, // '3' for EN
- 0x002d, // '-' for ES
- 0x0025, // '%' for ET
- 0x0669, // Arabic-Indic '9' for AN
- 0x002c, // ',' for CS
- 0x000d, // CR for B
- 0x0009, // Tab for S
- 0x0020, // ' ' for WS
- 0x003d, // '=' for ON
- 0x202a, // LRE
- 0x202d, // LRO
- 0x0630, // Arabic Letter Thal for AL
- 0x202b, // RLE
- 0x202e, // RLO
- 0x202c, // PDF
- 0x05b9, // Hebrew Point Holam for NSM
- 0x00ad, // Soft Hyphen for BN
- 0x2068, // FSI
- 0x2066, // LRI
- 0x2067, // RLI
- 0x2069 // PDI
-};
-
U_CDECL_BEGIN
static UCharDirection U_CALLCONV
biDiConfUBiDiClassCallback(const void * /*context*/, UChar32 c) {
for(int i=0; i<U_CHAR_DIRECTION_COUNT; ++i) {
- if(c==pseudoCharFromBiDiClass[i]) {
+ if(c==charFromBiDiClass[i]) {
return (UCharDirection)i;
}
}
U_CDECL_END
-static int32_t hexdigit(char c) {
- if(c>='0' && c<='9')
- return c - '0';
- if(c>='A' && c<='F')
- return c - ('A'-10);
- if(c>='a' && c<='f')
- return c - ('a'-10);
- return -1;
-}
-
static const int8_t biDiClassNameLengths[U_CHAR_DIRECTION_COUNT+1]={
1, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 3, 3, 2, 3, 3, 3, 3, 2, 3, 3, 3, 3, 0
};
-UBool BiDiConformanceTest::parseInputStringFromBiDiClasses(const char *&start, UBool parseChars) {
+UBool BiDiConformanceTest::parseInputStringFromBiDiClasses(const char *&start) {
inputString.remove();
/*
* Lengthy but fast BiDi class parser.
* but that makes this test take significantly more time.
*/
while(*start!=0 && *(start=u_skipWhitespace(start))!=0 && *start!=';') {
- int32_t d1, d2, hexnum;
- // First look for an hexa value of at least 2 digits
- if(parseChars && (d1=hexdigit(start[0]))>=0 && (d2=hexdigit(start[1]))>=0) {
- const char *saveStart=start;
- hexnum=(d1<<4) + d2;
- start+=2;
- while((d1=hexdigit(start[0]))>=0) {
- hexnum=(hexnum<<4) + d1;
- start++;
- }
- if(hexnum<=0 || hexnum>0xffff ||
- (!U_IS_INV_WHITESPACE(start[0]) && start[0]!=';' && start[0]!=0)) {
- errln("\nError on line %d: Invalid hexa number at %s", (int)lineNumber, saveStart);
- return FALSE;
- }
- inputString.append(hexnum);
- continue;
- }
UCharDirection biDiClass=U_CHAR_DIRECTION_COUNT;
// Compare each character once until we have a match on
// a complete, short BiDi class name.
int8_t biDiClassNameLength=biDiClassNameLengths[biDiClass];
char c=start[biDiClassNameLength];
if(biDiClass<U_CHAR_DIRECTION_COUNT && (U_IS_INV_WHITESPACE(c) || c==';' || c==0)) {
- if(parseChars) {
- inputString.append(realCharFromBiDiClass[biDiClass]);
- } else {
- inputString.append(pseudoCharFromBiDiClass[biDiClass]);
- }
+ inputString.append(charFromBiDiClass[biDiClass]);
start+=biDiClassNameLength;
continue;
}
-#if 0
- // Accept any single character
- // Not currently supported:
- // This parser reads the .txt file as is, with the default charset.
- // We could at most support "invariant" characters,
- // and would have to convert them to Unicode using invariant-character functions.
- // If we need to support Unicode characters, then we would have to
- // rewrite the code for reading and parsing to read UTF-8.
- if(parseChars && (U_IS_INV_WHITESPACE(start[1]) || start[1]==';' || start[1]==0)) {
- inputString.append(start[0]);
- start++;
- continue;
- }
-#endif
errln("\nError on line %d: BiDi class string not recognized at %s", (int)lineNumber, start);
printErrorLine();
return FALSE;
}
// Skip unknown @Xyz: ...
} else {
- if(!parseInputStringFromBiDiClasses(start, FALSE)) {
+ if(!parseInputStringFromBiDiClasses(start)) {
return;
}
start=u_skipWhitespace(start);
semicolon. Each field consists of tokens separated by whitespace (space
or Tab). Whitespace before and after semicolons is optional.
-Field 0: A sequence of tokens where each token may be one of the following:
- - an hexadecimal number of at least 2 digits representing a code point
- - a bidi property value, which must be one of (case sensitive)
- L (translated to 'l'),
- R (translated to Hebrew Letter Alef),
- EN (translated to '3'),
- ES (translated to '-'),
- ET (translated to '%'),
- AN (translated to Arabic-Indic '9'),
- CS (translated to ','),
- B (translated to CR),
- S (translated to Tab),
- WS (translated to space),
- ON (translated to '='),
- LRE, LRO,
- AL (translated to Arabic Letter Thal),
- RLE, RLO, PDF,
- NSM (translated to Hebrew Point Holam),
- BN (translated to Soft Hyphen),
- FSI, LRI, RLI, PDI
- - a single character which represents itself
+Field 0: A sequence of hexadecimal code point values separated by space
Field 1: A value representing the paragraph direction, as follows:
- 0 represents left-to-right
if(*start==0) {
continue; // Skip empty and comment-only lines.
}
- if(!parseInputStringFromBiDiClasses(start, TRUE)) {
+ // Parse the code point string in field 0.
+ UChar *buffer=inputString.getBuffer(200);
+ int32_t length=u_parseString(start, buffer, inputString.getCapacity(), NULL, errorCode);
+ if(errorCode.logIfFailureAndReset("Invalid string in field 0")) {
+ errln("Input line %d: %s", (int)lineNumber, line);
+ inputString.remove();
continue;
}
- start=u_skipWhitespace(start);
- if(*start!=';') {
+ inputString.releaseBuffer(length);
+ start=strchr(start, ';');
+ if(start==NULL) {
errorCount++;
errln("\nError on line %d: Missing ; separator on line: %s", (int)lineNumber, line);
continue;
projects / icu / commitdiff