U_CDECL_END
U_CAPI void U_EXPORT2
ucm_optimizeStates(UCMStates *states,
uint16_t **pUnicodeCodeUnits,
_MBCSToUFallback *toUFallbacks, int32_t countToUFallbacks,
UBool verbose) {
UErrorCode errorCode;
int32_t state, cell, entry;
/* test each state table entry */
for(state=0; state<states->countStates; ++state) {
for(cell=0; cell<256; ++cell) {
entry=states->stateTable[state][cell];
/*
* if the entry is a final one with an MBCS_STATE_VALID_DIRECT_16 action code
* and the code point is "unassigned" (0xfffe), then change it to
* the "unassigned" action code with bits 26..23 set to zero and U+fffe.
*/
if(MBCS_ENTRY_SET_STATE(entry, 0)==MBCS_ENTRY_FINAL(0, MBCS_STATE_VALID_DIRECT_16, 0xfffe)) {
states->stateTable[state][cell]=MBCS_ENTRY_FINAL_SET_ACTION(entry, MBCS_STATE_UNASSIGNED);
}
}
}
/* try to compact the toUnicode tables */
if(states->maxCharLength==2) {
compactToUnicode2(states, pUnicodeCodeUnits, toUFallbacks, countToUFallbacks, verbose);
} else if(states->maxCharLength>2) {
if(verbose) {
compactToUnicodeHelper(states, *pUnicodeCodeUnits, toUFallbacks, countToUFallbacks);
}
}
/* sort toUFallbacks */
/*
* It should be safe to sort them before compactToUnicode2() is called,
* because it should not change the relative order of the offset values
* that it adjusts, but they need to be sorted at some point, and
* it is safest here.
*/
if(countToUFallbacks>0) {
errorCode=U_ZERO_ERROR; /* nothing bad will happen... */
uprv_sortArray(toUFallbacks, countToUFallbacks,
sizeof(_MBCSToUFallback),
compareFallbacks, NULL, FALSE, &errorCode);
}
}
/*
* state table row grammar (ebnf-style):
* (whitespace is allowed between all tokens)
*
* row=[[firstentry ','] entry (',' entry)*]
* firstentry="initial" | "surrogates"
* (initial state (default for state 0), output is all surrogate pairs)
* entry=range [':' nextstate] ['.' action]
* range=number ['-' number]
* nextstate=number
* (0..7f)
* action='u' | 's' | 'p' | 'i'
* (unassigned, state change only, surrogate pair, illegal)
* number=(1- or 2-digit hexadecimal number)
*/
static const char *
parseState(const char *s, int32_t state[256], uint32_t *pFlags) {
const char *t;
uint32_t start, end, i;
int32_t entry;
/* initialize the state: all illegal with U+ffff */
for(i=0; i<256; ++i) {
state[i]=MBCS_ENTRY_FINAL(0, MBCS_STATE_ILLEGAL, 0xffff);
}
/* skip leading white space */
s=u_skipWhitespace(s);
/* is there an "initial" or "surrogates" directive? */
if(uprv_strncmp("initial", s, 7)==0) {
*pFlags=MBCS_STATE_FLAG_DIRECT;
s=u_skipWhitespace(s+7);
if(*s++!=',') {
return s-1;
}
} else if(*pFlags==0 && uprv_strncmp("surrogates", s, 10)==0) {
*pFlags=MBCS_STATE_FLAG_SURROGATES;
s=u_skipWhitespace(s+10);
if(*s++!=',') {
return s-1;
}
} else if(*s==0) {
/* empty state row: all-illegal */
return NULL;
}
for(;;) {
/* read an entry, the start of the range first */
s=u_skipWhitespace(s);
start=uprv_strtoul(s, (char **)&t, 16);
if(s==t || 0xff<start) {
return s;
}
s=u_skipWhitespace(t);
/* read the end of the range if there is one */
if(*s=='-') {
s=u_skipWhitespace(s+1);
end=uprv_strtoul(s, (char **)&t, 16);
if(s==t || end<start || 0xff<end) {
return s;
}
s=u_skipWhitespace(t);
} else {
end=start;
}
/* determine the state entrys for this range */
if(*s!=':' && *s!='.') {
/* the default is: final state with valid entries */
entry=MBCS_ENTRY_FINAL(0, MBCS_STATE_VALID_16, 0);
} else {
entry=MBCS_ENTRY_TRANSITION(0, 0);
if(*s==':') {
/* get the next state, default to 0 */
s=u_skipWhitespace(s+1);
i=uprv_strtoul(s, (char **)&t, 16);
if(s!=t) {
if(0x7f<i) {
return s;
}
s=u_skipWhitespace(t);
entry=MBCS_ENTRY_SET_STATE(entry, i);
}
}
/* get the state action, default to valid */
if(*s=='.') {
/* this is a final state */
entry=MBCS_ENTRY_SET_FINAL(entry);
s=u_skipWhitespace(s+1);
if(*s=='u') {
/* unassigned set U+fffe */
entry=MBCS_ENTRY_FINAL_SET_ACTION_VALUE(entry, MBCS_STATE_UNASSIGNED, 0xfffe);
s=u_skipWhitespace(s+1);
} else if(*s=='p') {
if(*pFlags!=MBCS_STATE_FLAG_DIRECT) {
entry=MBCS_ENTRY_FINAL_SET_ACTION(entry, MBCS_STATE_VALID_16_PAIR);
} else {
entry=MBCS_ENTRY_FINAL_SET_ACTION(entry, MBCS_STATE_VALID_16);
}
s=u_skipWhitespace(s+1);
} else if(*s=='s') {
entry=MBCS_ENTRY_FINAL_SET_ACTION(entry, MBCS_STATE_CHANGE_ONLY);
s=u_skipWhitespace(s+1);
} else if(*s=='i') {
/* illegal set U+ffff */
entry=MBCS_ENTRY_FINAL_SET_ACTION_VALUE(entry, MBCS_STATE_ILLEGAL, 0xffff);
s=u_skipWhitespace(s+1);
} else {
/* default to valid */
entry=MBCS_ENTRY_FINAL_SET_ACTION(entry, MBCS_STATE_VALID_16);
}
} else {
/* this is an intermediate state, nothing to do */
}
}
/* adjust "final valid" states according to the state flags */
if(MBCS_ENTRY_FINAL_ACTION(entry)==MBCS_STATE_VALID_16) {
switch(*pFlags) {
case 0:
/* no adjustment */
break;
case MBCS_STATE_FLAG_DIRECT:
/* set the valid-direct code point to "unassigned"==0xfffe */
entry=MBCS_ENTRY_FINAL_SET_ACTION_VALUE(entry, MBCS_STATE_VALID_DIRECT_16, 0xfffe);
break;
case MBCS_STATE_FLAG_SURROGATES:
entry=MBCS_ENTRY_FINAL_SET_ACTION_VALUE(entry, MBCS_STATE_VALID_16_PAIR, 0);
break;
default:
break;
}
}
/* set this entry for the range */
for(i=start; i<=end; ++i) {
state[i]=entry;
}
if(*s==',') {
++s;
} else {
return *s==0 ? NULL : s;
}
}
}
U_CAPI void U_EXPORT2
ucm_processStates(UCMStates *states, UBool ignoreSISOCheck) {
int32_t entry, state, cell, count;
if(states->conversionType==UCNV_UNSUPPORTED_CONVERTER) {
fprintf(stderr, "ucm error: missing conversion type (<uconv_class>)\n");
exit(U_INVALID_TABLE_FORMAT);
}
if(states->countStates==0) {
switch(states->conversionType) {
case UCNV_SBCS:
/* SBCS: use MBCS data structure with a default state table */
if(states->maxCharLength!=1) {
fprintf(stderr, "error: SBCS codepage with max B/char!=1\n");
exit(U_INVALID_TABLE_FORMAT);
}
states->conversionType=UCNV_MBCS;
ucm_addState(states, "0-ff");
break;
case UCNV_MBCS:
fprintf(stderr, "ucm error: missing state table information (<icu:state>) for MBCS\n");
exit(U_INVALID_TABLE_FORMAT);
break;
case UCNV_EBCDIC_STATEFUL:
/* EBCDIC_STATEFUL: use MBCS data structure with a default state table */
if(states->minCharLength!=1 || states->maxCharLength!=2) {
fprintf(stderr, "error: DBCS codepage with min B/char!=1 or max B/char!=2\n");
exit(U_INVALID_TABLE_FORMAT);
}
states->conversionType=UCNV_MBCS;
ucm_addState(states, "0-ff, e:1.s, f:0.s");
ucm_addState(states, "initial, 0-3f:4, e:1.s, f:0.s, 40:3, 41-fe:2, ff:4");
ucm_addState(states, "0-40:1.i, 41-fe:1., ff:1.i");
ucm_addState(states, "0-ff:1.i, 40:1.");
ucm_addState(states, "0-ff:1.i");
break;
case UCNV_DBCS:
/* DBCS: use MBCS data structure with a default state table */
if(states->minCharLength!=2 || states->maxCharLength!=2) {
fprintf(stderr, "error: DBCS codepage with min or max B/char!=2\n");
exit(U_INVALID_TABLE_FORMAT);
}
states->conversionType = UCNV_MBCS;
ucm_addState(states, "0-3f:3, 40:2, 41-fe:1, ff:3");
ucm_addState(states, "41-fe");
ucm_addState(states, "40");
ucm_addState(states, "");
break;
default:
fprintf(stderr, "ucm error: unknown charset structure\n");
exit(U_INVALID_TABLE_FORMAT);
break;
}
}
/*
* check that the min/max character lengths are reasonable;
* to do this right, all paths through the state table would have to be
* recursively walked while keeping track of the sequence lengths,
* but these simple checks cover most state tables in practice
*/
if(states->maxCharLength<states->minCharLength) {
fprintf(stderr, "ucm error: max B/char < min B/char\n");
exit(U_INVALID_TABLE_FORMAT);
}
/* count non-direct states and compare with max B/char */
count=0;
for(state=0; state<states->countStates; ++state) {
if((states->stateFlags[state]&0xf)!=MBCS_STATE_FLAG_DIRECT) {
++count;
}
}
if(states->maxCharLength>count+1) {
fprintf(stderr, "ucm error: max B/char too large\n");
exit(U_INVALID_TABLE_FORMAT);
}
if(states->minCharLength==1) {
int32_t action;
/*
* if there are single-byte characters,
* then the initial state must have direct result states
*/
for(cell=0; cell<256; ++cell) {
entry=states->stateTable[0][cell];
if( MBCS_ENTRY_IS_FINAL(entry) &&
((action=MBCS_ENTRY_FINAL_ACTION(entry))==MBCS_STATE_VALID_DIRECT_16 ||
action==MBCS_STATE_UNASSIGNED)
) {
break;
}
}
if(cell==256) {
fprintf(stderr, "ucm warning: min B/char too small\n");
}
}
/*
* make sure that all "next state" values are within limits
* and that all next states after final ones have the "direct"
* flag of initial states
*/
for(state=states->countStates-1; state>=0; --state) {
for(cell=0; cell<256; ++cell) {
entry=states->stateTable[state][cell];
if((uint8_t)MBCS_ENTRY_STATE(entry)>=states->countStates) {
fprintf(stderr, "ucm error: state table entry [%x][%x] has a next state of %x that is too high\n",
(int)state, (int)cell, (int)MBCS_ENTRY_STATE(entry));
exit(U_INVALID_TABLE_FORMAT);
}
if(MBCS_ENTRY_IS_FINAL(entry) && (states->stateFlags[MBCS_ENTRY_STATE(entry)]&0xf)!=MBCS_STATE_FLAG_DIRECT) {
fprintf(stderr, "ucm error: state table entry [%x][%x] is final but has a non-initial next state of %x\n",
(int)state, (int)cell, (int)MBCS_ENTRY_STATE(entry));
exit(U_INVALID_TABLE_FORMAT);
} else if(MBCS_ENTRY_IS_TRANSITION(entry) && (states->stateFlags[MBCS_ENTRY_STATE(entry)]&0xf)==MBCS_STATE_FLAG_DIRECT) {
fprintf(stderr, "ucm error: state table entry [%x][%x] is not final but has an initial next state of %x\n",
(int)state, (int)cell, (int)MBCS_ENTRY_STATE(entry));
exit(U_INVALID_TABLE_FORMAT);
}
}
}
/* is this an SI/SO (like EBCDIC-stateful) state table? */
if(states->countStates>=2 && (states->stateFlags[1]&0xf)==MBCS_STATE_FLAG_DIRECT) {
if(states->maxCharLength!=2) {
fprintf(stderr, "ucm error: SI/SO codepages must have max 2 bytes/char (not %x)\n", (int)states->maxCharLength);
exit(U_INVALID_TABLE_FORMAT);
}
if(states->countStates<3) {
fprintf(stderr, "ucm error: SI/SO codepages must have at least 3 states (not %x)\n", (int)states->countStates);
exit(U_INVALID_TABLE_FORMAT);
}
/* are the SI/SO all in the right places? */
if( ignoreSISOCheck ||
(states->stateTable[0][0xe]==MBCS_ENTRY_FINAL(1, MBCS_STATE_CHANGE_ONLY, 0) &&
states->stateTable[0][0xf]==MBCS_ENTRY_FINAL(0, MBCS_STATE_CHANGE_ONLY, 0) &&
states->stateTable[1][0xe]==MBCS_ENTRY_FINAL(1, MBCS_STATE_CHANGE_ONLY, 0) &&
states->stateTable[1][0xf]==MBCS_ENTRY_FINAL(0, MBCS_STATE_CHANGE_ONLY, 0))
) {
states->outputType=MBCS_OUTPUT_2_SISO;
} else {
fprintf(stderr, "ucm error: SI/SO codepages must have in states 0 and 1 transitions e:1.s, f:0.s\n");
exit(U_INVALID_TABLE_FORMAT);
}
state=2;
} else {
state=1;
}
/* check that no unexpected state is a "direct" one */
while(state<states->countStates) {
if((states->stateFlags[state]&0xf)==MBCS_STATE_FLAG_DIRECT) {
fprintf(stderr, "ucm error: state %d is 'initial' - not supported except for SI/SO codepages\n", (int)state);
exit(U_INVALID_TABLE_FORMAT);
}
++state;
}
sumUpStates(states);
}
