647 lines
19 KiB
C
647 lines
19 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 2003, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
*******************************************************************************
|
|
* file name: unorm_it.c
|
|
* encoding: US-ASCII
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2003jan21
|
|
* created by: Markus W. Scherer
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_NORMALIZATION
|
|
|
|
#include "unicode/uiter.h"
|
|
#include "unicode/unorm.h"
|
|
#include "unorm_it.h"
|
|
#include "cmemory.h"
|
|
|
|
/* UNormIterator ------------------------------------------------------------ */
|
|
|
|
enum {
|
|
INITIAL_CAPACITY=100
|
|
};
|
|
|
|
struct UNormIterator {
|
|
UCharIterator api;
|
|
UCharIterator *iter;
|
|
|
|
/*
|
|
* chars and states either use the static buffers
|
|
* or are allocated in the same memory block
|
|
*
|
|
* They are parallel arrays with states[] holding the getState() values
|
|
* from normalization boundaries, and UITER_NO_STATE in between.
|
|
*/
|
|
UChar *chars;
|
|
uint32_t *states;
|
|
|
|
/*
|
|
* api.start: first valid character & state in the arrays
|
|
* api.index: current position
|
|
* api.limit: one past the last valid character in chars[], but states[limit] is valid
|
|
* capacity: length of allocated arrays
|
|
*/
|
|
int32_t capacity;
|
|
|
|
/* the current iter->getState(), saved to avoid unnecessary setState() calls; may not correspond to api->index! */
|
|
uint32_t state;
|
|
|
|
/* there are UChars available before start or after limit? */
|
|
UBool hasPrevious, hasNext, isStackAllocated;
|
|
|
|
UNormalizationMode mode;
|
|
|
|
UChar charsBuffer[INITIAL_CAPACITY];
|
|
uint32_t statesBuffer[INITIAL_CAPACITY+1]; /* one more than charsBuffer[]! */
|
|
};
|
|
|
|
static void
|
|
initIndexes(UNormIterator *uni, UCharIterator *iter) {
|
|
/* do not pass api so that the compiler knows it's an alias pointer to uni itself */
|
|
UCharIterator *api=&uni->api;
|
|
|
|
if(!iter->hasPrevious(iter)) {
|
|
/* set indexes to the beginning of the arrays */
|
|
api->start=api->index=api->limit=0;
|
|
uni->hasPrevious=FALSE;
|
|
uni->hasNext=iter->hasNext(iter);
|
|
} else if(!iter->hasNext(iter)) {
|
|
/* set indexes to the end of the arrays */
|
|
api->start=api->index=api->limit=uni->capacity;
|
|
uni->hasNext=FALSE;
|
|
uni->hasPrevious=iter->hasPrevious(iter);
|
|
} else {
|
|
/* set indexes into the middle of the arrays */
|
|
api->start=api->index=api->limit=uni->capacity/2;
|
|
uni->hasPrevious=uni->hasNext=TRUE;
|
|
}
|
|
}
|
|
|
|
static UBool
|
|
reallocArrays(UNormIterator *uni, int32_t capacity, UBool addAtStart) {
|
|
/* do not pass api so that the compiler knows it's an alias pointer to uni itself */
|
|
UCharIterator *api=&uni->api;
|
|
|
|
uint32_t *states;
|
|
UChar *chars;
|
|
int32_t start, limit;
|
|
|
|
states=(uint32_t *)uprv_malloc((capacity+1)*4+capacity*2);
|
|
if(states==NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
chars=(UChar *)(states+(capacity+1));
|
|
uni->capacity=capacity;
|
|
|
|
start=api->start;
|
|
limit=api->limit;
|
|
|
|
if(addAtStart) {
|
|
/* copy old contents to the end of the new arrays */
|
|
int32_t delta;
|
|
|
|
delta=capacity-uni->capacity;
|
|
uprv_memcpy(states+delta+start, uni->states+start, (limit-start+1)*4);
|
|
uprv_memcpy(chars+delta+start, uni->chars+start, (limit-start)*4);
|
|
|
|
api->start=start+delta;
|
|
api->index+=delta;
|
|
api->limit=limit+delta;
|
|
} else {
|
|
/* copy old contents to the beginning of the new arrays */
|
|
uprv_memcpy(states+start, uni->states+start, (limit-start+1)*4);
|
|
uprv_memcpy(chars+start, uni->chars+start, (limit-start)*4);
|
|
}
|
|
|
|
uni->chars=chars;
|
|
uni->states=states;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
moveContentsTowardStart(UCharIterator *api, UChar chars[], uint32_t states[], int32_t delta) {
|
|
/* move array contents up to make room */
|
|
int32_t srcIndex, destIndex, limit;
|
|
|
|
limit=api->limit;
|
|
srcIndex=delta;
|
|
if(srcIndex>api->start) {
|
|
/* look for a position in the arrays with a known state */
|
|
while(srcIndex<limit && chars[srcIndex]==UITER_NO_STATE) {
|
|
++srcIndex;
|
|
}
|
|
}
|
|
|
|
/* now actually move the array contents */
|
|
api->start=destIndex=0;
|
|
while(srcIndex<limit) {
|
|
chars[destIndex]=chars[srcIndex];
|
|
states[destIndex++]=states[srcIndex++];
|
|
}
|
|
|
|
/* copy states[limit] as well! */
|
|
states[destIndex]=states[srcIndex];
|
|
|
|
api->limit=destIndex;
|
|
}
|
|
|
|
static void
|
|
moveContentsTowardEnd(UCharIterator *api, UChar chars[], uint32_t states[], int32_t delta) {
|
|
/* move array contents up to make room */
|
|
int32_t srcIndex, destIndex, start;
|
|
|
|
start=api->start;
|
|
destIndex=((UNormIterator *)api)->capacity;
|
|
srcIndex=destIndex-delta;
|
|
if(srcIndex<api->limit) {
|
|
/* look for a position in the arrays with a known state */
|
|
while(srcIndex>start && chars[srcIndex]==UITER_NO_STATE) {
|
|
--srcIndex;
|
|
}
|
|
}
|
|
|
|
/* now actually move the array contents */
|
|
api->limit=destIndex;
|
|
|
|
/* copy states[limit] as well! */
|
|
states[destIndex]=states[srcIndex];
|
|
|
|
while(srcIndex>start) {
|
|
chars[--destIndex]=chars[--srcIndex];
|
|
states[destIndex]=states[srcIndex];
|
|
}
|
|
|
|
api->start=destIndex;
|
|
}
|
|
|
|
/* normalize forward from the limit, assume hasNext is true */
|
|
static UBool
|
|
readNext(UNormIterator *uni, UCharIterator *iter) {
|
|
/* do not pass api so that the compiler knows it's an alias pointer to uni itself */
|
|
UCharIterator *api=&uni->api;
|
|
|
|
/* make capacity/4 room at the end of the arrays */
|
|
int32_t limit, capacity, room, delta;
|
|
UErrorCode errorCode;
|
|
|
|
limit=api->limit;
|
|
capacity=uni->capacity;
|
|
room=capacity/4;
|
|
delta=room-(capacity-limit);
|
|
if(delta>0) {
|
|
/* move array contents to make room */
|
|
moveContentsTowardStart(api, uni->chars, uni->states, delta);
|
|
api->index=limit=api->limit;
|
|
uni->hasPrevious=TRUE;
|
|
}
|
|
|
|
/* normalize starting from the limit position */
|
|
errorCode=U_ZERO_ERROR;
|
|
if(uni->state!=uni->states[limit]) {
|
|
uiter_setState(iter, uni->states[limit], &errorCode);
|
|
if(U_FAILURE(errorCode)) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasNext=FALSE;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
room=unorm_next(iter, uni->chars+limit, capacity-limit, uni->mode, 0, TRUE, NULL, &errorCode);
|
|
if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
|
|
if(room<=capacity) {
|
|
/* empty and re-use the arrays */
|
|
uni->states[0]=uni->states[limit];
|
|
api->start=api->index=api->limit=limit=0;
|
|
uni->hasPrevious=TRUE;
|
|
} else {
|
|
capacity+=room+100;
|
|
if(!reallocArrays(uni, capacity, FALSE)) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasNext=FALSE;
|
|
return FALSE;
|
|
}
|
|
limit=api->limit;
|
|
}
|
|
|
|
errorCode=U_ZERO_ERROR;
|
|
uiter_setState(iter, uni->states[limit], &errorCode);
|
|
room=unorm_next(iter, uni->chars+limit, capacity-limit, uni->mode, 0, TRUE, NULL, &errorCode);
|
|
}
|
|
if(U_FAILURE(errorCode) || room==0) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasNext=FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
/* room>0 */
|
|
++limit; /* leave the known states[limit] alone */
|
|
for(--room; room>0; --room) {
|
|
/* set unknown states for all but the normalization boundaries */
|
|
uni->states[limit++]=UITER_NO_STATE;
|
|
}
|
|
uni->states[limit]=uni->state=uiter_getState(iter);
|
|
uni->hasNext=iter->hasNext(iter);
|
|
api->limit=limit;
|
|
return TRUE;
|
|
}
|
|
|
|
/* normalize backward from the start, assume hasPrevious is true */
|
|
static UBool
|
|
readPrevious(UNormIterator *uni, UCharIterator *iter) {
|
|
/* do not pass api so that the compiler knows it's an alias pointer to uni itself */
|
|
UCharIterator *api=&uni->api;
|
|
|
|
/* make capacity/4 room at the start of the arrays */
|
|
int32_t start, capacity, room, delta;
|
|
UErrorCode errorCode;
|
|
|
|
start=api->start;
|
|
capacity=uni->capacity;
|
|
room=capacity/4;
|
|
delta=room-start;
|
|
if(delta>0) {
|
|
/* move array contents to make room */
|
|
moveContentsTowardEnd(api, uni->chars, uni->states, delta);
|
|
api->index=start=api->start;
|
|
uni->hasNext=TRUE;
|
|
}
|
|
|
|
/* normalize ending at the start position */
|
|
errorCode=U_ZERO_ERROR;
|
|
if(uni->state!=uni->states[start]) {
|
|
uiter_setState(iter, uni->states[start], &errorCode);
|
|
if(U_FAILURE(errorCode)) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasPrevious=FALSE;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
room=unorm_previous(iter, uni->chars, start, uni->mode, 0, TRUE, NULL, &errorCode);
|
|
if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
|
|
if(room<=capacity) {
|
|
/* empty and re-use the arrays */
|
|
uni->states[capacity]=uni->states[start];
|
|
api->start=api->index=api->limit=start=capacity;
|
|
uni->hasNext=TRUE;
|
|
} else {
|
|
capacity+=room+100;
|
|
if(!reallocArrays(uni, capacity, TRUE)) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasPrevious=FALSE;
|
|
return FALSE;
|
|
}
|
|
start=api->start;
|
|
}
|
|
|
|
errorCode=U_ZERO_ERROR;
|
|
uiter_setState(iter, uni->states[start], &errorCode);
|
|
room=unorm_previous(iter, uni->chars, start, uni->mode, 0, TRUE, NULL, &errorCode);
|
|
}
|
|
if(U_FAILURE(errorCode) || room==0) {
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasPrevious=FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
/* room>0 */
|
|
do {
|
|
/* copy the UChars from chars[0..room[ to chars[(start-room)..start[ */
|
|
uni->chars[--start]=uni->chars[--room];
|
|
/* set unknown states for all but the normalization boundaries */
|
|
uni->states[start]=UITER_NO_STATE;
|
|
} while(room>0);
|
|
uni->states[start]=uni->state=uiter_getState(iter);
|
|
uni->hasPrevious=iter->hasPrevious(iter);
|
|
api->start=start;
|
|
return TRUE;
|
|
}
|
|
|
|
/* Iterator runtime API functions ------------------------------------------- */
|
|
|
|
static int32_t U_CALLCONV
|
|
unormIteratorGetIndex(UCharIterator *api, UCharIteratorOrigin origin) {
|
|
switch(origin) {
|
|
case UITER_ZERO:
|
|
case UITER_START:
|
|
return 0;
|
|
case UITER_CURRENT:
|
|
case UITER_LIMIT:
|
|
case UITER_LENGTH:
|
|
return UITER_UNKNOWN_INDEX;
|
|
default:
|
|
/* not a valid origin */
|
|
/* Should never get here! */
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static int32_t U_CALLCONV
|
|
unormIteratorMove(UCharIterator *api, int32_t delta, UCharIteratorOrigin origin) {
|
|
UNormIterator *uni=(UNormIterator *)api;
|
|
UCharIterator *iter=uni->iter;
|
|
int32_t pos;
|
|
|
|
switch(origin) {
|
|
case UITER_ZERO:
|
|
case UITER_START:
|
|
/* restart from the beginning */
|
|
if(uni->hasPrevious) {
|
|
iter->move(iter, 0, UITER_START);
|
|
api->start=api->index=api->limit=0;
|
|
uni->states[api->limit]=uni->state=uiter_getState(iter);
|
|
uni->hasPrevious=FALSE;
|
|
uni->hasNext=iter->hasNext(iter);
|
|
} else {
|
|
/* we already have the beginning of the normalized text */
|
|
api->index=api->start;
|
|
}
|
|
break;
|
|
case UITER_CURRENT:
|
|
break;
|
|
case UITER_LIMIT:
|
|
case UITER_LENGTH:
|
|
/* restart from the end */
|
|
if(uni->hasNext) {
|
|
iter->move(iter, 0, UITER_LIMIT);
|
|
api->start=api->index=api->limit=uni->capacity;
|
|
uni->states[api->limit]=uni->state=uiter_getState(iter);
|
|
uni->hasPrevious=iter->hasPrevious(iter);
|
|
uni->hasNext=FALSE;
|
|
} else {
|
|
/* we already have the end of the normalized text */
|
|
api->index=api->limit;
|
|
}
|
|
break;
|
|
default:
|
|
return -1; /* Error */
|
|
}
|
|
|
|
/* move relative to the current position by delta normalized UChars */
|
|
if(delta==0) {
|
|
/* nothing to do */
|
|
} else if(delta>0) {
|
|
/* go forward until the requested position is in the buffer */
|
|
for(;;) {
|
|
pos=api->index+delta; /* requested position */
|
|
delta=pos-api->limit; /* remainder beyond buffered text */
|
|
if(delta<=0) {
|
|
api->index=pos; /* position reached */
|
|
break;
|
|
}
|
|
|
|
/* go to end of buffer and normalize further */
|
|
api->index=api->limit;
|
|
if(!uni->hasNext || !readNext(uni, iter)) {
|
|
break; /* reached end of text */
|
|
}
|
|
}
|
|
} else /* delta<0 */ {
|
|
/* go backward until the requested position is in the buffer */
|
|
for(;;) {
|
|
pos=api->index+delta; /* requested position */
|
|
delta=pos-api->start; /* remainder beyond buffered text */
|
|
if(delta>=0) {
|
|
api->index=pos; /* position reached */
|
|
break;
|
|
}
|
|
|
|
/* go to start of buffer and normalize further */
|
|
api->index=api->start;
|
|
if(!uni->hasPrevious || !readPrevious(uni, iter)) {
|
|
break; /* reached start of text */
|
|
}
|
|
}
|
|
}
|
|
|
|
if(api->index==api->start && !uni->hasPrevious) {
|
|
return 0;
|
|
} else {
|
|
return UITER_UNKNOWN_INDEX;
|
|
}
|
|
}
|
|
|
|
static UBool U_CALLCONV
|
|
unormIteratorHasNext(UCharIterator *api) {
|
|
return api->index<api->limit || ((UNormIterator *)api)->hasNext;
|
|
}
|
|
|
|
static UBool U_CALLCONV
|
|
unormIteratorHasPrevious(UCharIterator *api) {
|
|
return api->index>api->start || ((UNormIterator *)api)->hasPrevious;
|
|
}
|
|
|
|
static UChar32 U_CALLCONV
|
|
unormIteratorCurrent(UCharIterator *api) {
|
|
UNormIterator *uni=(UNormIterator *)api;
|
|
|
|
if( api->index<api->limit ||
|
|
(uni->hasNext && readNext(uni, uni->iter))
|
|
) {
|
|
return uni->chars[api->index];
|
|
} else {
|
|
return U_SENTINEL;
|
|
}
|
|
}
|
|
|
|
static UChar32 U_CALLCONV
|
|
unormIteratorNext(UCharIterator *api) {
|
|
UNormIterator *uni=(UNormIterator *)api;
|
|
|
|
if( api->index<api->limit ||
|
|
(uni->hasNext && readNext(uni, uni->iter))
|
|
) {
|
|
return uni->chars[api->index++];
|
|
} else {
|
|
return U_SENTINEL;
|
|
}
|
|
}
|
|
|
|
static UChar32 U_CALLCONV
|
|
unormIteratorPrevious(UCharIterator *api) {
|
|
UNormIterator *uni=(UNormIterator *)api;
|
|
|
|
if( api->index>api->start ||
|
|
(uni->hasPrevious && readPrevious(uni, uni->iter))
|
|
) {
|
|
return uni->chars[--api->index];
|
|
} else {
|
|
return U_SENTINEL;
|
|
}
|
|
}
|
|
|
|
static uint32_t U_CALLCONV
|
|
unormIteratorGetState(const UCharIterator *api) {
|
|
/* not uni->state because that may not be at api->index */
|
|
return ((UNormIterator *)api)->states[api->index];
|
|
}
|
|
|
|
static void U_CALLCONV
|
|
unormIteratorSetState(UCharIterator *api, uint32_t state, UErrorCode *pErrorCode) {
|
|
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
|
|
/* do nothing */
|
|
} else if(api==NULL) {
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
} else if(state==UITER_NO_STATE) {
|
|
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
|
|
} else {
|
|
UNormIterator *uni=(UNormIterator *)api;
|
|
UCharIterator *iter=((UNormIterator *)api)->iter;
|
|
if(state!=uni->state) {
|
|
uni->state=state;
|
|
uiter_setState(iter, state, pErrorCode);
|
|
}
|
|
|
|
/*
|
|
* Try shortcuts: If the requested state is in the array contents
|
|
* then just set the index there.
|
|
*
|
|
* We assume that the state is unique per position!
|
|
*/
|
|
if(state==uni->states[api->index]) {
|
|
return;
|
|
} else if(state==uni->states[api->limit]) {
|
|
api->index=api->limit;
|
|
return;
|
|
} else {
|
|
/* search for the index with this state */
|
|
int32_t i;
|
|
|
|
for(i=api->start; i<api->limit; ++i) {
|
|
if(state==uni->states[i]) {
|
|
api->index=i;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* there is no array index for this state, reset for fresh contents */
|
|
initIndexes((UNormIterator *)api, iter);
|
|
uni->states[api->limit]=state;
|
|
}
|
|
}
|
|
|
|
static const UCharIterator unormIterator={
|
|
NULL, 0, 0, 0, 0, 0,
|
|
unormIteratorGetIndex,
|
|
unormIteratorMove,
|
|
unormIteratorHasNext,
|
|
unormIteratorHasPrevious,
|
|
unormIteratorCurrent,
|
|
unormIteratorNext,
|
|
unormIteratorPrevious,
|
|
NULL,
|
|
unormIteratorGetState,
|
|
unormIteratorSetState
|
|
};
|
|
|
|
/* Setup functions ---------------------------------------------------------- */
|
|
|
|
U_CAPI UNormIterator * U_EXPORT2
|
|
unorm_openIter(void *stackMem, int32_t stackMemSize, UErrorCode *pErrorCode) {
|
|
UNormIterator *uni;
|
|
|
|
/* argument checking */
|
|
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
|
|
return NULL;
|
|
}
|
|
|
|
/* allocate */
|
|
uni=NULL;
|
|
if(stackMem!=NULL && stackMemSize>=sizeof(UNormIterator)) {
|
|
size_t align=U_ALIGNMENT_OFFSET(stackMem);
|
|
if(align==0) {
|
|
/* already aligned */
|
|
uni=(UNormIterator *)stackMem;
|
|
} else if((stackMemSize-=align)>=sizeof(UNormIterator)) {
|
|
/* needs alignment */
|
|
uni=(UNormIterator *)((char *)stackMem+align);
|
|
} else {
|
|
/* does not fit */
|
|
}
|
|
}
|
|
|
|
if(uni!=NULL) {
|
|
uni->isStackAllocated=TRUE;
|
|
} else {
|
|
uni=(UNormIterator *)uprv_malloc(sizeof(UNormIterator));
|
|
if(uni==NULL) {
|
|
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return NULL;
|
|
}
|
|
uni->isStackAllocated=FALSE;
|
|
}
|
|
|
|
/*
|
|
* initialize
|
|
* do not memset because that would unnecessarily initialize the arrays
|
|
*/
|
|
uni->iter=NULL;
|
|
uni->chars=uni->charsBuffer;
|
|
uni->states=uni->statesBuffer;
|
|
uni->capacity=INITIAL_CAPACITY;
|
|
uni->state=UITER_NO_STATE;
|
|
uni->hasPrevious=uni->hasNext=FALSE;
|
|
uni->mode=UNORM_NONE;
|
|
|
|
/* set a no-op iterator into the api */
|
|
uiter_setString(&uni->api, NULL, 0);
|
|
return uni;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
unorm_closeIter(UNormIterator *uni) {
|
|
if(uni!=NULL) {
|
|
if(uni->states!=uni->statesBuffer) {
|
|
/* chars and states are allocated in the same memory block */
|
|
uprv_free(uni->states);
|
|
}
|
|
if(!uni->isStackAllocated) {
|
|
uprv_free(uni);
|
|
}
|
|
}
|
|
}
|
|
|
|
U_CAPI UCharIterator * U_EXPORT2
|
|
unorm_setIter(UNormIterator *uni, UCharIterator *iter, UNormalizationMode mode, UErrorCode *pErrorCode) {
|
|
/* argument checking */
|
|
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
|
|
return NULL;
|
|
}
|
|
if(uni==NULL) {
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
if( iter==NULL || iter->getState==NULL || iter->setState==NULL ||
|
|
mode<UNORM_NONE || UNORM_MODE_COUNT<=mode
|
|
) {
|
|
/* set a no-op iterator into the api */
|
|
uiter_setString(&uni->api, NULL, 0);
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
/* set the iterator and initialize */
|
|
uprv_memcpy(&uni->api, &unormIterator, sizeof(unormIterator));
|
|
|
|
uni->iter=iter;
|
|
uni->mode=mode;
|
|
|
|
initIndexes(uni, iter);
|
|
uni->states[uni->api.limit]=uni->state=uiter_getState(iter);
|
|
|
|
return &uni->api;
|
|
}
|
|
|
|
#endif /* uconfig.h switches */
|