The Tor Browser / file revision

 /*

 *******************************************************************************

 *

 *   Copyright (C) 2002-2010, International Business Machines

 *   Corporation and others.  All Rights Reserved.

 *

 *******************************************************************************

 *   file name:  propsvec.h

 *   encoding:   US-ASCII

 *   tab size:   8 (not used)

 *   indentation:4

 *

 *   created on: 2002feb22

 *   created by: Markus W. Scherer

 *

 *   Store bits (Unicode character properties) in bit set vectors.

 */

 #ifndef __UPROPSVEC_H__

 #define __UPROPSVEC_H__

 #include "unicode/utypes.h"

 #include "utrie.h"

 #include "utrie2.h"

 U_CDECL_BEGIN

 /**

  * Unicode Properties Vectors associated with code point ranges.

  *

  * Rows of uint32_t integers in a contiguous array store

  * the range limits and the properties vectors.

  *

  * Logically, each row has a certain number of uint32_t values,

  * which is set via the upvec_open() "columns" parameter.

  *

  * Internally, two additional columns are stored.

  * In each internal row,

  * row[0] contains the start code point and

  * row[1] contains the limit code point,

  * which is the start of the next range.

  *

  * Initially, there is only one "normal" row for

  * range [0..0x110000[ with values 0.

  * There are additional rows for special purposes, see UPVEC_FIRST_SPECIAL_CP.

  *

  * It would be possible to store only one range boundary per row,

  * but self-contained rows allow to later sort them by contents.

  */

 struct UPropsVectors;

 typedef struct UPropsVectors UPropsVectors;

 /*

  * Special pseudo code points for storing the initialValue and the errorValue,

  * which are used to initialize a UTrie2 or similar.

  */

 #define UPVEC_FIRST_SPECIAL_CP 0x110000

 #define UPVEC_INITIAL_VALUE_CP 0x110000

 #define UPVEC_ERROR_VALUE_CP 0x110001

 #define UPVEC_MAX_CP 0x110001

 /*

  * Special pseudo code point used in upvec_compact() signalling the end of

  * delivering special values and the beginning of delivering real ones.

  * Stable value, unlike UPVEC_MAX_CP which might grow over time.

  */

 #define UPVEC_START_REAL_VALUES_CP 0x200000

 /*

  * Open a UPropsVectors object.

  * @param columns Number of value integers (uint32_t) per row.

  */

 U_CAPI UPropsVectors * U_EXPORT2

 upvec_open(int32_t columns, UErrorCode *pErrorCode);

 U_CAPI void U_EXPORT2

 upvec_close(UPropsVectors *pv);

 /*

  * In rows for code points [start..end], select the column,

  * reset the mask bits and set the value bits (ANDed with the mask).

  *

  * Will set U_NO_WRITE_PERMISSION if called after upvec_compact().

  */

 U_CAPI void U_EXPORT2

 upvec_setValue(UPropsVectors *pv,

                UChar32 start, UChar32 end,

                int32_t column,

                uint32_t value, uint32_t mask,

                UErrorCode *pErrorCode);

 /*

  * Logically const but must not be used on the same pv concurrently!

  * Always returns 0 if called after upvec_compact().

  */

 U_CAPI uint32_t U_EXPORT2

 upvec_getValue(const UPropsVectors *pv, UChar32 c, int32_t column);

 /*

  * pRangeStart and pRangeEnd can be NULL.

  * @return NULL if rowIndex out of range and for illegal arguments,

  *         or if called after upvec_compact()

  */

 U_CAPI uint32_t * U_EXPORT2

 upvec_getRow(const UPropsVectors *pv, int32_t rowIndex,

              UChar32 *pRangeStart, UChar32 *pRangeEnd);

 /*

  * Compact the vectors:

  * - modify the memory

  * - keep only unique vectors

  * - store them contiguously from the beginning of the memory

  * - for each (non-unique) row, call the handler function

  *

  * The handler's rowIndex is the index of the row in the compacted

  * memory block.

  * (Therefore, it starts at 0 increases in increments of the columns value.)

  *

  * In a first phase, only special values are delivered (each exactly once),

  * with start==end both equalling a special pseudo code point.

  * Then the handler is called once more with start==end==UPVEC_START_REAL_VALUES_CP

  * where rowIndex is the length of the compacted array,

  * and the row is arbitrary (but not NULL).

  * Then, in the second phase, the handler is called for each row of real values.

  */

 typedef void U_CALLCONV

 UPVecCompactHandler(void *context,

                     UChar32 start, UChar32 end,

                     int32_t rowIndex, uint32_t *row, int32_t columns,

                     UErrorCode *pErrorCode);

 U_CAPI void U_EXPORT2

 upvec_compact(UPropsVectors *pv, UPVecCompactHandler *handler, void *context, UErrorCode *pErrorCode);

 /*

  * Get the vectors array after calling upvec_compact().

  * The caller must not modify nor release the returned array.

  * Returns NULL if called before upvec_compact().

  */

 U_CAPI const uint32_t * U_EXPORT2

 upvec_getArray(const UPropsVectors *pv, int32_t *pRows, int32_t *pColumns);

 /*

  * Get a clone of the vectors array after calling upvec_compact().

  * The caller owns the returned array and must uprv_free() it.

  * Returns NULL if called before upvec_compact().

  */

 U_CAPI uint32_t * U_EXPORT2

 upvec_cloneArray(const UPropsVectors *pv,

                  int32_t *pRows, int32_t *pColumns, UErrorCode *pErrorCode);

 /*

  * Call upvec_compact(), create a 16-bit UTrie2 with indexes into the compacted

  * vectors array, and freeze the trie.

  */

 U_CAPI UTrie2 * U_EXPORT2

 upvec_compactToUTrie2WithRowIndexes(UPropsVectors *pv, UErrorCode *pErrorCode);

 struct UPVecToUTrie2Context {

     UTrie2 *trie;

     int32_t initialValue;

     int32_t errorValue;

     int32_t maxValue;

 };

 typedef struct UPVecToUTrie2Context UPVecToUTrie2Context;

 /* context=UPVecToUTrie2Context, creates the trie and stores the rowIndex values */

 U_CAPI void U_CALLCONV

 upvec_compactToUTrie2Handler(void *context,

                              UChar32 start, UChar32 end,

                              int32_t rowIndex, uint32_t *row, int32_t columns,

                              UErrorCode *pErrorCode);

 U_CDECL_END

 #endif