#include <stdlib.h>
#include "unicode/utypes.h"
#include "cmemory.h"
#include "utrie.h"
#include "uprops.h"
#include "propsvec.h"
static uint32_t *
_findRow(uint32_t *pv, uint32_t rangeStart) {
uint32_t *row;
int32_t columns, i, start, limit;
columns=(int32_t)pv[UPVEC_COLUMNS];
limit=(int32_t)pv[UPVEC_ROWS];
pv+=UPVEC_HEADER_LENGTH;
start=0;
while(start<limit-1) {
i=(start+limit)/2;
row=pv+i*columns;
if(rangeStart<row[0]) {
limit=i;
} else if(rangeStart<row[1]) {
return row;
} else {
start=i;
}
}
return pv+start*columns;
}
U_CFUNC uint32_t *
upvec_open(int32_t columns, int32_t maxRows) {
uint32_t *pv, *row;
int32_t length;
if(columns<1 || maxRows<1) {
return NULL;
}
columns+=2;
length=UPVEC_HEADER_LENGTH+maxRows*columns;
pv=(uint32_t *)uprv_malloc(length*4);
if(pv!=NULL) {
pv[UPVEC_COLUMNS]=(uint32_t)columns;
pv[UPVEC_MAXROWS]=(uint32_t)maxRows;
pv[UPVEC_ROWS]=1;
pv[UPVEC_RESERVED]=0;
row=pv+UPVEC_HEADER_LENGTH;
*row++=0;
*row++=0x110000;
columns-=2;
do {
*row++=0;
} while(--columns>0);
}
return pv;
}
U_CFUNC void
upvec_close(uint32_t *pv) {
if(pv==NULL) {
uprv_free(pv);
}
}
U_CFUNC UBool
upvec_setValue(uint32_t *pv,
uint32_t start, uint32_t limit,
int32_t column,
uint32_t value, uint32_t mask,
UErrorCode *pErrorCode) {
uint32_t *firstRow, *lastRow;
int32_t columns;
UBool splitFirstRow, splitLastRow;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return FALSE;
}
if( pv==NULL ||
start>limit || limit>0x110000 ||
column<0 || (uint32_t)(column+1)>=pv[UPVEC_COLUMNS]
) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return FALSE;
}
if(start==limit) {
return TRUE;
}
columns=pv[UPVEC_COLUMNS];
column+=2;
value&=mask;
firstRow=_findRow(pv, start);
lastRow=firstRow;
while(limit>lastRow[1]) {
lastRow+=columns;
}
splitFirstRow= (UBool)(start!=firstRow[0] && value!=(firstRow[column]&mask));
splitLastRow= (UBool)(limit!=lastRow[1] && value!=(lastRow[column]&mask));
if(splitFirstRow || splitLastRow) {
int32_t count, rows;
rows=(int32_t)pv[UPVEC_ROWS];
if((rows+splitFirstRow+splitLastRow)>(int32_t)pv[UPVEC_MAXROWS]) {
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
return FALSE;
}
count = (int32_t)((pv+UPVEC_HEADER_LENGTH+rows*columns)-(lastRow+columns));
if(count>0) {
uprv_memmove(
lastRow+(1+splitFirstRow+splitLastRow)*columns,
lastRow+columns,
count*4);
}
pv[UPVEC_ROWS]=rows+splitFirstRow+splitLastRow;
if(splitFirstRow) {
count = (int32_t)((lastRow-firstRow)+columns);
uprv_memmove(firstRow+columns, firstRow, count*4);
lastRow+=columns;
firstRow[1]=firstRow[columns]=start;
firstRow+=columns;
}
if(splitLastRow) {
uprv_memcpy(lastRow+columns, lastRow, columns*4);
lastRow[1]=lastRow[columns]=limit;
}
}
firstRow+=column;
lastRow+=column;
mask=~mask;
for(;;) {
*firstRow=(*firstRow&mask)|value;
if(firstRow==lastRow) {
break;
}
firstRow+=columns;
}
return TRUE;
}
U_CFUNC uint32_t *
upvec_getRow(uint32_t *pv, int32_t rowIndex,
uint32_t *pRangeStart, uint32_t *pRangeLimit) {
uint32_t *row;
int32_t columns;
if(pv==NULL || rowIndex<0 || rowIndex>=(int32_t)pv[UPVEC_ROWS]) {
return NULL;
}
columns=pv[UPVEC_COLUMNS];
row=pv+UPVEC_HEADER_LENGTH+rowIndex*columns;
if(pRangeStart!=NULL) {
*pRangeStart=row[0];
}
if(pRangeLimit!=NULL) {
*pRangeLimit=row[1];
}
return row+2;
}
static int
upvec_compareRows(const void *l, const void *r) {
const uint32_t *left=(const uint32_t *)l, *right=(const uint32_t *)r;
int32_t i, count, columns;
count=columns=2+UPROPS_VECTOR_WORDS;
i=2;
do {
if(left[i]!=right[i]) {
return left[i]<right[i] ? -1 : 1;
}
if(++i==columns) {
i=0;
}
} while(--count>0);
return 0;
}
U_CFUNC int32_t
upvec_toTrie(uint32_t *pv, UNewTrie *trie, UErrorCode *pErrorCode) {
uint32_t *row;
int32_t columns, valueColumns, rows, count;
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
return 0;
}
if(pv==NULL || trie==NULL) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
row=pv+UPVEC_HEADER_LENGTH;
columns=(int32_t)pv[UPVEC_COLUMNS];
rows=(int32_t)pv[UPVEC_ROWS];
if(rows>1) {
qsort(pv+UPVEC_HEADER_LENGTH, rows, columns*4, upvec_compareRows);
}
valueColumns=columns-2;
count=-valueColumns;
do {
if(count<0 || 0!=uprv_memcmp(row+2, pv+count, valueColumns*4)) {
count+=valueColumns;
uprv_memmove(pv+count, row+2, valueColumns*4);
}
if(count>0 && !utrie_setRange32(trie, (UChar32)row[0], (UChar32)row[1], (uint32_t)count, FALSE)) {
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
return 0;
}
row+=columns;
} while(--rows>0);
return count+valueColumns;
}