[apple/icu.git] / icuSources / common / rbbidata.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
***************************************************************************
*   Copyright (C) 1999-2014 International Business Machines Corporation   *
*   and others. All rights reserved.                                      *
***************************************************************************
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_BREAK_ITERATION

#include "unicode/utypes.h"
#include "rbbidata.h"
#include "rbbirb.h"
#include "utrie.h"
#include "udatamem.h"
#include "cmemory.h"
#include "cstring.h"
#include "umutex.h"

#include "uassert.h"


//-----------------------------------------------------------------------------------
//
//   Trie access folding function.  Copied as-is from properties code in uchar.c
//
//-----------------------------------------------------------------------------------
U_CDECL_BEGIN
static int32_t U_CALLCONV
getFoldingOffset(uint32_t data) {
    /* if bit 15 is set, then the folding offset is in bits 14..0 of the 16-bit trie result */
    if(data&0x8000) {
        return (int32_t)(data&0x7fff);
    } else {
        return 0;
    }
}
U_CDECL_END

U_NAMESPACE_BEGIN

//-----------------------------------------------------------------------------
//
//    Constructors.
//
//-----------------------------------------------------------------------------
RBBIDataWrapper::RBBIDataWrapper(const RBBIDataHeader *data, UErrorCode &status) {
    init0();
    init(data, status);
}

RBBIDataWrapper::RBBIDataWrapper(const RBBIDataHeader *data, enum EDontAdopt, UErrorCode &status) {
    init0();
    init(data, status);
    fDontFreeData = TRUE;
}

RBBIDataWrapper::RBBIDataWrapper(UDataMemory* udm, UErrorCode &status) {
    init0();
    if (U_FAILURE(status)) {
        return;
    }
    const DataHeader *dh = udm->pHeader;
    int32_t headerSize = dh->dataHeader.headerSize;
    if (  !(headerSize >= 20 &&
            dh->info.isBigEndian == U_IS_BIG_ENDIAN &&
            dh->info.charsetFamily == U_CHARSET_FAMILY &&
            dh->info.dataFormat[0] == 0x42 &&  // dataFormat="Brk "
            dh->info.dataFormat[1] == 0x72 &&
            dh->info.dataFormat[2] == 0x6b &&
            dh->info.dataFormat[3] == 0x20)
            // Note: info.fFormatVersion is duplicated in the RBBIDataHeader, and is
            //       validated when checking that.
        ) {
        status = U_INVALID_FORMAT_ERROR;
        return;
    }
    const char *dataAsBytes = reinterpret_cast<const char *>(dh);
    const RBBIDataHeader *rbbidh = reinterpret_cast<const RBBIDataHeader *>(dataAsBytes + headerSize);
    init(rbbidh, status);
    fUDataMem = udm;
}

//-----------------------------------------------------------------------------
//
//    init().   Does most of the work of construction, shared between the
//              constructors.
//
//-----------------------------------------------------------------------------
void RBBIDataWrapper::init0() {
    fHeader = NULL;
    fForwardTable = NULL;
    fReverseTable = NULL;
    fSafeFwdTable = NULL;
    fSafeRevTable = NULL;
    fRuleSource = NULL;
    fRuleStatusTable = NULL;
    fUDataMem = NULL;
    fRefCount = 0;
    fDontFreeData = TRUE;
}

void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) {
    if (U_FAILURE(status)) {
        return;
    }
    fHeader = data;
    if (fHeader->fMagic != 0xb1a0 || fHeader->fFormatVersion[0] != 3) 
    {
        status = U_INVALID_FORMAT_ERROR;
        return;
    }
    // Note: in ICU version 3.2 and earlier, there was a formatVersion 1
    //       that is no longer supported.  At that time fFormatVersion was
    //       an int32_t field, rather than an array of 4 bytes.

    fDontFreeData = FALSE;
    if (data->fFTableLen != 0) {
        fForwardTable = (RBBIStateTable *)((char *)data + fHeader->fFTable);
    }
    if (data->fRTableLen != 0) {
        fReverseTable = (RBBIStateTable *)((char *)data + fHeader->fRTable);
    }
    if (data->fSFTableLen != 0) {
        fSafeFwdTable = (RBBIStateTable *)((char *)data + fHeader->fSFTable);
    }
    if (data->fSRTableLen != 0) {
        fSafeRevTable = (RBBIStateTable *)((char *)data + fHeader->fSRTable);
    }


    utrie_unserialize(&fTrie,
                       (uint8_t *)data + fHeader->fTrie,
                       fHeader->fTrieLen,
                       &status);
    if (U_FAILURE(status)) {
        return;
    }
    fTrie.getFoldingOffset=getFoldingOffset;


    fRuleSource   = (UChar *)((char *)data + fHeader->fRuleSource);
    fRuleString.setTo(TRUE, fRuleSource, -1);
    U_ASSERT(data->fRuleSourceLen > 0);

    fRuleStatusTable = (int32_t *)((char *)data + fHeader->fStatusTable);
    fStatusMaxIdx    = data->fStatusTableLen / sizeof(int32_t);

    fRefCount = 1;

#ifdef RBBI_DEBUG
    char *debugEnv = getenv("U_RBBIDEBUG");
    if (debugEnv && uprv_strstr(debugEnv, "data")) {this->printData();}
#endif
}


//-----------------------------------------------------------------------------
//
//    Destructor.     Don't call this - use removeReference() instead.
//
//-----------------------------------------------------------------------------
RBBIDataWrapper::~RBBIDataWrapper() {
    U_ASSERT(fRefCount == 0);
    if (fUDataMem) {
        udata_close(fUDataMem);
    } else if (!fDontFreeData) {
        uprv_free((void *)fHeader);
    }
}


//-----------------------------------------------------------------------------
//
//   Operator ==    Consider two RBBIDataWrappers to be equal if they
//                  refer to the same underlying data.  Although
//                  the data wrappers are normally shared between
//                  iterator instances, it's possible to independently
//                  open the same data twice, and get two instances, which
//                  should still be ==.
//
//-----------------------------------------------------------------------------
UBool RBBIDataWrapper::operator ==(const RBBIDataWrapper &other) const {
    if (fHeader == other.fHeader) {
        return TRUE;
    }
    if (fHeader->fLength != other.fHeader->fLength) {
        return FALSE;
    }
    if (uprv_memcmp(fHeader, other.fHeader, fHeader->fLength) == 0) {
        return TRUE;
    }
    return FALSE;
}

int32_t  RBBIDataWrapper::hashCode() {
    return fHeader->fFTableLen;
}


//-----------------------------------------------------------------------------
//
//    Reference Counting.   A single RBBIDataWrapper object is shared among
//                          however many RulesBasedBreakIterator instances are
//                          referencing the same data.
//
//-----------------------------------------------------------------------------
void RBBIDataWrapper::removeReference() {
    if (umtx_atomic_dec(&fRefCount) == 0) {
        delete this;
    }
}


RBBIDataWrapper *RBBIDataWrapper::addReference() {
   umtx_atomic_inc(&fRefCount);
   return this;
}


//-----------------------------------------------------------------------------
//
//  getRuleSourceString
//
//-----------------------------------------------------------------------------
const UnicodeString &RBBIDataWrapper::getRuleSourceString() const {
    return fRuleString;
}


//-----------------------------------------------------------------------------
//
//  print   -  debugging function to dump the runtime data tables.
//
//-----------------------------------------------------------------------------
#ifdef RBBI_DEBUG
void  RBBIDataWrapper::printTable(const char *heading, const RBBIStateTable *table) {
    uint32_t   c;
    uint32_t   s;

    RBBIDebugPrintf("   %s\n", heading);

    RBBIDebugPrintf("State |  Acc  LA TagIx");
    for (c=0; c<fHeader->fCatCount; c++) {RBBIDebugPrintf("%3d ", c);}
    RBBIDebugPrintf("\n------|---------------"); for (c=0;c<fHeader->fCatCount; c++) {
        RBBIDebugPrintf("----");
    }
    RBBIDebugPrintf("\n");

    if (table == NULL) {
        RBBIDebugPrintf("         N U L L   T A B L E\n\n");
        return;
    }
    for (s=0; s<table->fNumStates; s++) {
        RBBIStateTableRow *row = (RBBIStateTableRow *)
                                  (table->fTableData + (table->fRowLen * s));
        RBBIDebugPrintf("%4d  |  %3d %3d %3d ", s, row->fAccepting, row->fLookAhead, row->fTagIdx);
        for (c=0; c<fHeader->fCatCount; c++)  {
            RBBIDebugPrintf("%3d ", row->fNextState[c]);
        }
        RBBIDebugPrintf("\n");
    }
    RBBIDebugPrintf("\n");
}
#endif


#ifdef RBBI_DEBUG
void  RBBIDataWrapper::printData() {
    RBBIDebugPrintf("RBBI Data at %p\n", (void *)fHeader);
    RBBIDebugPrintf("   Version = {%d %d %d %d}\n", fHeader->fFormatVersion[0], fHeader->fFormatVersion[1],
                                                    fHeader->fFormatVersion[2], fHeader->fFormatVersion[3]);
    RBBIDebugPrintf("   total length of data  = %d\n", fHeader->fLength);
    RBBIDebugPrintf("   number of character categories = %d\n\n", fHeader->fCatCount);

    printTable("Forward State Transition Table", fForwardTable);
    printTable("Reverse State Transition Table", fReverseTable);
    printTable("Safe Forward State Transition Table", fSafeFwdTable);
    printTable("Safe Reverse State Transition Table", fSafeRevTable);

    RBBIDebugPrintf("\nOrignal Rules source:\n");
    for (int32_t c=0; fRuleSource[c] != 0; c++) {
        RBBIDebugPrintf("%c", fRuleSource[c]);
    }
    RBBIDebugPrintf("\n\n");
}
#endif


U_NAMESPACE_END
U_NAMESPACE_USE

//-----------------------------------------------------------------------------
//
//  ubrk_swap   -  byte swap and char encoding swap of RBBI data
//
//-----------------------------------------------------------------------------

U_CAPI int32_t U_EXPORT2
ubrk_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outData,
           UErrorCode *status) {

    if (status == NULL || U_FAILURE(*status)) {
        return 0;
    }
    if(ds==NULL || inData==NULL || length<-1 || (length>0 && outData==NULL)) {
        *status=U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }

    //
    //  Check that the data header is for for break data.
    //    (Header contents are defined in genbrk.cpp)
    //
    const UDataInfo *pInfo = (const UDataInfo *)((const char *)inData+4);
    if(!(  pInfo->dataFormat[0]==0x42 &&   /* dataFormat="Brk " */
           pInfo->dataFormat[1]==0x72 &&
           pInfo->dataFormat[2]==0x6b &&
           pInfo->dataFormat[3]==0x20 &&
           pInfo->formatVersion[0]==3  )) {
        udata_printError(ds, "ubrk_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized\n",
                         pInfo->dataFormat[0], pInfo->dataFormat[1],
                         pInfo->dataFormat[2], pInfo->dataFormat[3],
                         pInfo->formatVersion[0]);
        *status=U_UNSUPPORTED_ERROR;
        return 0;
    }

    //
    // Swap the data header.  (This is the generic ICU Data Header, not the RBBI Specific
    //                         RBBIDataHeader).  This swap also conveniently gets us
    //                         the size of the ICU d.h., which lets us locate the start
    //                         of the RBBI specific data.
    //
    int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, status);


    //
    // Get the RRBI Data Header, and check that it appears to be OK.
    //
    //    Note:  ICU 3.2 and earlier, RBBIDataHeader::fDataFormat was actually 
    //           an int32_t with a value of 1.  Starting with ICU 3.4,
    //           RBBI's fDataFormat matches the dataFormat field from the
    //           UDataInfo header, four int8_t bytes.  The value is {3,1,0,0}
    //
    const uint8_t  *inBytes =(const uint8_t *)inData+headerSize;
    RBBIDataHeader *rbbiDH = (RBBIDataHeader *)inBytes;
    if (ds->readUInt32(rbbiDH->fMagic) != 0xb1a0 || 
        rbbiDH->fFormatVersion[0] != 3 ||
        ds->readUInt32(rbbiDH->fLength)  <  sizeof(RBBIDataHeader)) 
    {
        udata_printError(ds, "ubrk_swap(): RBBI Data header is invalid.\n");
        *status=U_UNSUPPORTED_ERROR;
        return 0;
    }

    //
    // Prefight operation?  Just return the size
    //
    int32_t breakDataLength = ds->readUInt32(rbbiDH->fLength);
    int32_t totalSize = headerSize + breakDataLength;
    if (length < 0) {
        return totalSize;
    }

    //
    // Check that length passed in is consistent with length from RBBI data header.
    //
    if (length < totalSize) {
        udata_printError(ds, "ubrk_swap(): too few bytes (%d after ICU Data header) for break data.\n",
                            breakDataLength);
        *status=U_INDEX_OUTOFBOUNDS_ERROR;
        return 0;
        }


    //
    // Swap the Data.  Do the data itself first, then the RBBI Data Header, because
    //                 we need to reference the header to locate the data, and an
    //                 inplace swap of the header leaves it unusable.
    //
    uint8_t         *outBytes = (uint8_t *)outData + headerSize;
    RBBIDataHeader  *outputDH = (RBBIDataHeader *)outBytes;

    int32_t   tableStartOffset;
    int32_t   tableLength;

    //
    // If not swapping in place, zero out the output buffer before starting.
    //    Individual tables and other data items within are aligned to 8 byte boundaries
    //    when originally created.  Any unused space between items needs to be zero.
    //
    if (inBytes != outBytes) {
        uprv_memset(outBytes, 0, breakDataLength);
    }

    //
    // Each state table begins with several 32 bit fields.  Calculate the size
    //   in bytes of these.
    //
    int32_t         topSize = offsetof(RBBIStateTable, fTableData);

    // Forward state table.  
    tableStartOffset = ds->readUInt32(rbbiDH->fFTable);
    tableLength      = ds->readUInt32(rbbiDH->fFTableLen);

    if (tableLength > 0) {
        ds->swapArray32(ds, inBytes+tableStartOffset, topSize, 
                            outBytes+tableStartOffset, status);
        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
                            outBytes+tableStartOffset+topSize, status);
    }
    
    // Reverse state table.  Same layout as forward table, above.
    tableStartOffset = ds->readUInt32(rbbiDH->fRTable);
    tableLength      = ds->readUInt32(rbbiDH->fRTableLen);

    if (tableLength > 0) {
        ds->swapArray32(ds, inBytes+tableStartOffset, topSize, 
                            outBytes+tableStartOffset, status);
        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
                            outBytes+tableStartOffset+topSize, status);
    }

    // Safe Forward state table.  Same layout as forward table, above.
    tableStartOffset = ds->readUInt32(rbbiDH->fSFTable);
    tableLength      = ds->readUInt32(rbbiDH->fSFTableLen);

    if (tableLength > 0) {
        ds->swapArray32(ds, inBytes+tableStartOffset, topSize, 
                            outBytes+tableStartOffset, status);
        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
                            outBytes+tableStartOffset+topSize, status);
    }

    // Safe Reverse state table.  Same layout as forward table, above.
    tableStartOffset = ds->readUInt32(rbbiDH->fSRTable);
    tableLength      = ds->readUInt32(rbbiDH->fSRTableLen);

    if (tableLength > 0) {
        ds->swapArray32(ds, inBytes+tableStartOffset, topSize, 
                            outBytes+tableStartOffset, status);
        ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
                            outBytes+tableStartOffset+topSize, status);
    }

    // Trie table for character categories
    utrie_swap(ds, inBytes+ds->readUInt32(rbbiDH->fTrie), ds->readUInt32(rbbiDH->fTrieLen),
                            outBytes+ds->readUInt32(rbbiDH->fTrie), status);

    // Source Rules Text.  It's UChar data
    ds->swapArray16(ds, inBytes+ds->readUInt32(rbbiDH->fRuleSource), ds->readUInt32(rbbiDH->fRuleSourceLen),
                        outBytes+ds->readUInt32(rbbiDH->fRuleSource), status);

    // Table of rule status values.  It's all int_32 values
    ds->swapArray32(ds, inBytes+ds->readUInt32(rbbiDH->fStatusTable), ds->readUInt32(rbbiDH->fStatusTableLen),
                        outBytes+ds->readUInt32(rbbiDH->fStatusTable), status);

    // And, last, the header.
    //   It is all int32_t values except for fFormataVersion, which is an array of four bytes.
    //   Swap the whole thing as int32_t, then re-swap the one field.
    //
    ds->swapArray32(ds, inBytes, sizeof(RBBIDataHeader), outBytes, status);
    ds->swapArray32(ds, outputDH->fFormatVersion, 4, outputDH->fFormatVersion, status);

    return totalSize;
}


#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b75a7d8f A	3	/*
b75a7d8f A	4	***************************************************************************
b331163b	5	* Copyright (C) 1999-2014 International Business Machines Corporation *
b75a7d8f A	6	* and others. All rights reserved. *
	7	***************************************************************************
	8	*/
	9
	10	#include "unicode/utypes.h"
	11
	12	#if !UCONFIG_NO_BREAK_ITERATION
	13
	14	#include "unicode/utypes.h"
	15	#include "rbbidata.h"
	16	#include "rbbirb.h"
	17	#include "utrie.h"
	18	#include "udatamem.h"
	19	#include "cmemory.h"
	20	#include "cstring.h"
	21	#include "umutex.h"
	22
	23	#include "uassert.h"
	24
	25
	26	//-----------------------------------------------------------------------------------
	27	//
	28	// Trie access folding function. Copied as-is from properties code in uchar.c
	29	//
	30	//-----------------------------------------------------------------------------------
	31	U_CDECL_BEGIN
	32	static int32_t U_CALLCONV
	33	getFoldingOffset(uint32_t data) {
	34	/* if bit 15 is set, then the folding offset is in bits 14..0 of the 16-bit trie result */
	35	if(data&0x8000) {
	36	return (int32_t)(data&0x7fff);
	37	} else {
	38	return 0;
	39	}
	40	}
	41	U_CDECL_END
	42
	43	U_NAMESPACE_BEGIN
	44
	45	//-----------------------------------------------------------------------------
	46	//
	47	// Constructors.
	48	//
	49	//-----------------------------------------------------------------------------
	50	RBBIDataWrapper::RBBIDataWrapper(const RBBIDataHeader *data, UErrorCode &status) {
b331163b	51	init0();
b75a7d8f A	52	init(data, status);
	53	}
	54
46f4442e	55	RBBIDataWrapper::RBBIDataWrapper(const RBBIDataHeader *data, enum EDontAdopt, UErrorCode &status) {
b331163b	56	init0();
46f4442e A	57	init(data, status);
	58	fDontFreeData = TRUE;
	59	}
	60
b75a7d8f	61	RBBIDataWrapper::RBBIDataWrapper(UDataMemory* udm, UErrorCode &status) {
b331163b A	62	init0();
	63	if (U_FAILURE(status)) {
	64	return;
	65	}
	66	const DataHeader *dh = udm->pHeader;
	67	int32_t headerSize = dh->dataHeader.headerSize;
	68	if ( !(headerSize >= 20 &&
	69	dh->info.isBigEndian == U_IS_BIG_ENDIAN &&
	70	dh->info.charsetFamily == U_CHARSET_FAMILY &&
	71	dh->info.dataFormat[0] == 0x42 && // dataFormat="Brk "
	72	dh->info.dataFormat[1] == 0x72 &&
	73	dh->info.dataFormat[2] == 0x6b &&
	74	dh->info.dataFormat[3] == 0x20)
	75	// Note: info.fFormatVersion is duplicated in the RBBIDataHeader, and is
	76	// validated when checking that.
	77	) {
	78	status = U_INVALID_FORMAT_ERROR;
	79	return;
	80	}
	81	const char dataAsBytes = reinterpret_cast<const char >(dh);
	82	const RBBIDataHeader rbbidh = reinterpret_cast<const RBBIDataHeader >(dataAsBytes + headerSize);
	83	init(rbbidh, status);
b75a7d8f A	84	fUDataMem = udm;
	85	}
	86
	87	//-----------------------------------------------------------------------------
	88	//
	89	// init(). Does most of the work of construction, shared between the
	90	// constructors.
	91	//
	92	//-----------------------------------------------------------------------------
b331163b A	93	void RBBIDataWrapper::init0() {
	94	fHeader = NULL;
	95	fForwardTable = NULL;
	96	fReverseTable = NULL;
	97	fSafeFwdTable = NULL;
	98	fSafeRevTable = NULL;
	99	fRuleSource = NULL;
	100	fRuleStatusTable = NULL;
	101	fUDataMem = NULL;
	102	fRefCount = 0;
	103	fDontFreeData = TRUE;
	104	}
	105
b75a7d8f A	106	void RBBIDataWrapper::init(const RBBIDataHeader *data, UErrorCode &status) {
	107	if (U_FAILURE(status)) {
	108	return;
	109	}
	110	fHeader = data;
729e4ab9	111	if (fHeader->fMagic != 0xb1a0 \|\| fHeader->fFormatVersion[0] != 3)
73c04bcf A	112	{
73c04bcf A	113	status = U_INVALID_FORMAT_ERROR;
b75a7d8f A	114	return;
b75a7d8f A	115	}
729e4ab9 A	116	// Note: in ICU version 3.2 and earlier, there was a formatVersion 1
	117	// that is no longer supported. At that time fFormatVersion was
	118	// an int32_t field, rather than an array of 4 bytes.
b75a7d8f	119
46f4442e	120	fDontFreeData = FALSE;
374ca955 A	121	if (data->fFTableLen != 0) {
	122	fForwardTable = (RBBIStateTable )((char )data + fHeader->fFTable);
	123	}
b75a7d8f A	124	if (data->fRTableLen != 0) {
	125	fReverseTable = (RBBIStateTable )((char )data + fHeader->fRTable);
	126	}
374ca955 A	127	if (data->fSFTableLen != 0) {
	128	fSafeFwdTable = (RBBIStateTable )((char )data + fHeader->fSFTable);
	129	}
	130	if (data->fSRTableLen != 0) {
	131	fSafeRevTable = (RBBIStateTable )((char )data + fHeader->fSRTable);
	132	}
b75a7d8f A	133
	134
	135	utrie_unserialize(&fTrie,
	136	(uint8_t *)data + fHeader->fTrie,
	137	fHeader->fTrieLen,
	138	&status);
	139	if (U_FAILURE(status)) {
	140	return;
	141	}
	142	fTrie.getFoldingOffset=getFoldingOffset;
	143
	144
	145	fRuleSource = (UChar )((char )data + fHeader->fRuleSource);
	146	fRuleString.setTo(TRUE, fRuleSource, -1);
374ca955 A	147	U_ASSERT(data->fRuleSourceLen > 0);
	148
	149	fRuleStatusTable = (int32_t )((char )data + fHeader->fStatusTable);
	150	fStatusMaxIdx = data->fStatusTableLen / sizeof(int32_t);
b75a7d8f A	151
	152	fRefCount = 1;
	153
	154	#ifdef RBBI_DEBUG
	155	char *debugEnv = getenv("U_RBBIDEBUG");
	156	if (debugEnv && uprv_strstr(debugEnv, "data")) {this->printData();}
	157	#endif
	158	}
	159
	160
	161	//-----------------------------------------------------------------------------
	162	//
374ca955	163	// Destructor. Don't call this - use removeReference() instead.
b75a7d8f A	164	//
	165	//-----------------------------------------------------------------------------
	166	RBBIDataWrapper::~RBBIDataWrapper() {
	167	U_ASSERT(fRefCount == 0);
	168	if (fUDataMem) {
	169	udata_close(fUDataMem);
46f4442e	170	} else if (!fDontFreeData) {
b75a7d8f A	171	uprv_free((void *)fHeader);
	172	}
	173	}
	174
	175
	176
	177	//-----------------------------------------------------------------------------
	178	//
	179	// Operator == Consider two RBBIDataWrappers to be equal if they
	180	// refer to the same underlying data. Although
	181	// the data wrappers are normally shared between
	182	// iterator instances, it's possible to independently
	183	// open the same data twice, and get two instances, which
	184	// should still be ==.
	185	//
	186	//-----------------------------------------------------------------------------
	187	UBool RBBIDataWrapper::operator ==(const RBBIDataWrapper &other) const {
	188	if (fHeader == other.fHeader) {
	189	return TRUE;
	190	}
	191	if (fHeader->fLength != other.fHeader->fLength) {
	192	return FALSE;
	193	}
	194	if (uprv_memcmp(fHeader, other.fHeader, fHeader->fLength) == 0) {
	195	return TRUE;
	196	}
	197	return FALSE;
	198	}
	199
	200	int32_t RBBIDataWrapper::hashCode() {
	201	return fHeader->fFTableLen;
	202	}
	203
	204
	205
	206	//-----------------------------------------------------------------------------
	207	//
	208	// Reference Counting. A single RBBIDataWrapper object is shared among
	209	// however many RulesBasedBreakIterator instances are
	210	// referencing the same data.
	211	//
	212	//-----------------------------------------------------------------------------
	213	void RBBIDataWrapper::removeReference() {
	214	if (umtx_atomic_dec(&fRefCount) == 0) {
	215	delete this;
	216	}
	217	}
	218
	219
	220	RBBIDataWrapper *RBBIDataWrapper::addReference() {
	221	umtx_atomic_inc(&fRefCount);
	222	return this;
	223	}
	224
	225
	226
	227	//-----------------------------------------------------------------------------
	228	//
	229	// getRuleSourceString
	230	//
	231	//-----------------------------------------------------------------------------
374ca955	232	const UnicodeString &RBBIDataWrapper::getRuleSourceString() const {
b75a7d8f A	233	return fRuleString;
	234	}
	235
	236
	237	//-----------------------------------------------------------------------------
	238	//
	239	// print - debugging function to dump the runtime data tables.
	240	//
	241	//-----------------------------------------------------------------------------
b75a7d8f	242	#ifdef RBBI_DEBUG
374ca955 A	243	void RBBIDataWrapper::printTable(const char heading, const RBBIStateTable table) {
	244	uint32_t c;
	245	uint32_t s;
b75a7d8f	246
374ca955	247	RBBIDebugPrintf(" %s\n", heading);
b75a7d8f	248
374ca955	249	RBBIDebugPrintf("State \| Acc LA TagIx");
b75a7d8f	250	for (c=0; c<fHeader->fCatCount; c++) {RBBIDebugPrintf("%3d ", c);}
374ca955 A	251	RBBIDebugPrintf("\n------\|---------------"); for (c=0;c<fHeader->fCatCount; c++) {
	252	RBBIDebugPrintf("----");
	253	}
b75a7d8f A	254	RBBIDebugPrintf("\n");
b75a7d8f A	255
374ca955 A	256	if (table == NULL) {
	257	RBBIDebugPrintf(" N U L L T A B L E\n\n");
	258	return;
	259	}
	260	for (s=0; s<table->fNumStates; s++) {
b75a7d8f	261	RBBIStateTableRow row = (RBBIStateTableRow )
374ca955 A	262	(table->fTableData + (table->fRowLen * s));
374ca955 A	263	RBBIDebugPrintf("%4d \| %3d %3d %3d ", s, row->fAccepting, row->fLookAhead, row->fTagIdx);
b75a7d8f A	264	for (c=0; c<fHeader->fCatCount; c++) {
	265	RBBIDebugPrintf("%3d ", row->fNextState[c]);
	266	}
	267	RBBIDebugPrintf("\n");
	268	}
374ca955 A	269	RBBIDebugPrintf("\n");
	270	}
	271	#endif
	272
	273
	274	#ifdef RBBI_DEBUG
	275	void RBBIDataWrapper::printData() {
	276	RBBIDebugPrintf("RBBI Data at %p\n", (void *)fHeader);
73c04bcf A	277	RBBIDebugPrintf(" Version = {%d %d %d %d}\n", fHeader->fFormatVersion[0], fHeader->fFormatVersion[1],
73c04bcf A	278	fHeader->fFormatVersion[2], fHeader->fFormatVersion[3]);
374ca955 A	279	RBBIDebugPrintf(" total length of data = %d\n", fHeader->fLength);
	280	RBBIDebugPrintf(" number of character categories = %d\n\n", fHeader->fCatCount);
	281
	282	printTable("Forward State Transition Table", fForwardTable);
	283	printTable("Reverse State Transition Table", fReverseTable);
	284	printTable("Safe Forward State Transition Table", fSafeFwdTable);
	285	printTable("Safe Reverse State Transition Table", fSafeRevTable);
b75a7d8f A	286
b75a7d8f A	287	RBBIDebugPrintf("\nOrignal Rules source:\n");
374ca955	288	for (int32_t c=0; fRuleSource[c] != 0; c++) {
b75a7d8f	289	RBBIDebugPrintf("%c", fRuleSource[c]);
b75a7d8f A	290	}
b75a7d8f A	291	RBBIDebugPrintf("\n\n");
b75a7d8f	292	}
374ca955	293	#endif
b75a7d8f A	294
	295
	296	U_NAMESPACE_END
46f4442e	297	U_NAMESPACE_USE
b75a7d8f	298
374ca955 A	299	//-----------------------------------------------------------------------------
	300	//
	301	// ubrk_swap - byte swap and char encoding swap of RBBI data
	302	//
	303	//-----------------------------------------------------------------------------
	304
	305	U_CAPI int32_t U_EXPORT2
	306	ubrk_swap(const UDataSwapper ds, const void inData, int32_t length, void *outData,
	307	UErrorCode *status) {
	308
	309	if (status == NULL \|\| U_FAILURE(*status)) {
	310	return 0;
	311	}
73c04bcf A	312	if(ds==NULL \|\| inData==NULL \|\| length<-1 \|\| (length>0 && outData==NULL)) {
	313	*status=U_ILLEGAL_ARGUMENT_ERROR;
	314	return 0;
	315	}
374ca955 A	316
	317	//
	318	// Check that the data header is for for break data.
	319	// (Header contents are defined in genbrk.cpp)
	320	//
	321	const UDataInfo pInfo = (const UDataInfo )((const char *)inData+4);
	322	if(!( pInfo->dataFormat[0]==0x42 && /* dataFormat="Brk " */
	323	pInfo->dataFormat[1]==0x72 &&
	324	pInfo->dataFormat[2]==0x6b &&
	325	pInfo->dataFormat[3]==0x20 &&
	326	pInfo->formatVersion[0]==3 )) {
	327	udata_printError(ds, "ubrk_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized\n",
	328	pInfo->dataFormat[0], pInfo->dataFormat[1],
	329	pInfo->dataFormat[2], pInfo->dataFormat[3],
	330	pInfo->formatVersion[0]);
	331	*status=U_UNSUPPORTED_ERROR;
	332	return 0;
	333	}
	334
	335	//
	336	// Swap the data header. (This is the generic ICU Data Header, not the RBBI Specific
	337	// RBBIDataHeader). This swap also conveniently gets us
	338	// the size of the ICU d.h., which lets us locate the start
	339	// of the RBBI specific data.
	340	//
	341	int32_t headerSize=udata_swapDataHeader(ds, inData, length, outData, status);
	342
	343
	344	//
	345	// Get the RRBI Data Header, and check that it appears to be OK.
	346	//
73c04bcf A	347	// Note: ICU 3.2 and earlier, RBBIDataHeader::fDataFormat was actually
	348	// an int32_t with a value of 1. Starting with ICU 3.4,
	349	// RBBI's fDataFormat matches the dataFormat field from the
	350	// UDataInfo header, four int8_t bytes. The value is {3,1,0,0}
	351	//
374ca955 A	352	const uint8_t inBytes =(const uint8_t )inData+headerSize;
374ca955 A	353	RBBIDataHeader rbbiDH = (RBBIDataHeader )inBytes;
729e4ab9 A	354	if (ds->readUInt32(rbbiDH->fMagic) != 0xb1a0 \|\|
729e4ab9 A	355	rbbiDH->fFormatVersion[0] != 3 \|\|
374ca955 A	356	ds->readUInt32(rbbiDH->fLength) < sizeof(RBBIDataHeader))
	357	{
	358	udata_printError(ds, "ubrk_swap(): RBBI Data header is invalid.\n");
	359	*status=U_UNSUPPORTED_ERROR;
	360	return 0;
	361	}
	362
	363	//
	364	// Prefight operation? Just return the size
	365	//
73c04bcf A	366	int32_t breakDataLength = ds->readUInt32(rbbiDH->fLength);
73c04bcf A	367	int32_t totalSize = headerSize + breakDataLength;
374ca955 A	368	if (length < 0) {
	369	return totalSize;
	370	}
	371
	372	//
	373	// Check that length passed in is consistent with length from RBBI data header.
	374	//
73c04bcf A	375	if (length < totalSize) {
	376	udata_printError(ds, "ubrk_swap(): too few bytes (%d after ICU Data header) for break data.\n",
	377	breakDataLength);
	378	*status=U_INDEX_OUTOFBOUNDS_ERROR;
	379	return 0;
374ca955	380	}
374ca955 A	381
	382
	383	//
	384	// Swap the Data. Do the data itself first, then the RBBI Data Header, because
	385	// we need to reference the header to locate the data, and an
	386	// inplace swap of the header leaves it unusable.
	387	//
73c04bcf A	388	uint8_t outBytes = (uint8_t )outData + headerSize;
	389	RBBIDataHeader outputDH = (RBBIDataHeader )outBytes;
	390
374ca955 A	391	int32_t tableStartOffset;
	392	int32_t tableLength;
	393
	394	//
	395	// If not swapping in place, zero out the output buffer before starting.
	396	// Individual tables and other data items within are aligned to 8 byte boundaries
	397	// when originally created. Any unused space between items needs to be zero.
	398	//
	399	if (inBytes != outBytes) {
73c04bcf	400	uprv_memset(outBytes, 0, breakDataLength);
374ca955 A	401	}
	402
	403	//
	404	// Each state table begins with several 32 bit fields. Calculate the size
	405	// in bytes of these.
	406	//
46f4442e	407	int32_t topSize = offsetof(RBBIStateTable, fTableData);
374ca955 A	408
	409	// Forward state table.
	410	tableStartOffset = ds->readUInt32(rbbiDH->fFTable);
	411	tableLength = ds->readUInt32(rbbiDH->fFTableLen);
	412
	413	if (tableLength > 0) {
	414	ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
	415	outBytes+tableStartOffset, status);
	416	ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
	417	outBytes+tableStartOffset+topSize, status);
	418	}
	419
	420	// Reverse state table. Same layout as forward table, above.
	421	tableStartOffset = ds->readUInt32(rbbiDH->fRTable);
	422	tableLength = ds->readUInt32(rbbiDH->fRTableLen);
	423
	424	if (tableLength > 0) {
	425	ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
	426	outBytes+tableStartOffset, status);
	427	ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
	428	outBytes+tableStartOffset+topSize, status);
	429	}
	430
	431	// Safe Forward state table. Same layout as forward table, above.
	432	tableStartOffset = ds->readUInt32(rbbiDH->fSFTable);
	433	tableLength = ds->readUInt32(rbbiDH->fSFTableLen);
	434
	435	if (tableLength > 0) {
	436	ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
	437	outBytes+tableStartOffset, status);
	438	ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
	439	outBytes+tableStartOffset+topSize, status);
	440	}
	441
	442	// Safe Reverse state table. Same layout as forward table, above.
	443	tableStartOffset = ds->readUInt32(rbbiDH->fSRTable);
	444	tableLength = ds->readUInt32(rbbiDH->fSRTableLen);
	445
	446	if (tableLength > 0) {
	447	ds->swapArray32(ds, inBytes+tableStartOffset, topSize,
	448	outBytes+tableStartOffset, status);
	449	ds->swapArray16(ds, inBytes+tableStartOffset+topSize, tableLength-topSize,
	450	outBytes+tableStartOffset+topSize, status);
	451	}
	452
	453	// Trie table for character categories
	454	utrie_swap(ds, inBytes+ds->readUInt32(rbbiDH->fTrie), ds->readUInt32(rbbiDH->fTrieLen),
	455	outBytes+ds->readUInt32(rbbiDH->fTrie), status);
	456
	457	// Source Rules Text. It's UChar data
	458	ds->swapArray16(ds, inBytes+ds->readUInt32(rbbiDH->fRuleSource), ds->readUInt32(rbbiDH->fRuleSourceLen),
	459	outBytes+ds->readUInt32(rbbiDH->fRuleSource), status);
	460
	461	// Table of rule status values. It's all int_32 values
	462	ds->swapArray32(ds, inBytes+ds->readUInt32(rbbiDH->fStatusTable), ds->readUInt32(rbbiDH->fStatusTableLen),
	463	outBytes+ds->readUInt32(rbbiDH->fStatusTable), status);
	464
73c04bcf	465	// And, last, the header.
729e4ab9 A	466	// It is all int32_t values except for fFormataVersion, which is an array of four bytes.
729e4ab9 A	467	// Swap the whole thing as int32_t, then re-swap the one field.
73c04bcf A	468	//
73c04bcf A	469	ds->swapArray32(ds, inBytes, sizeof(RBBIDataHeader), outBytes, status);
729e4ab9	470	ds->swapArray32(ds, outputDH->fFormatVersion, 4, outputDH->fFormatVersion, status);
374ca955 A	471
	472	return totalSize;
	473	}
	474
	475
b75a7d8f	476	#endif /* #if !UCONFIG_NO_BREAK_ITERATION */