icuSources/common/rbbidata.h

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1999-2004, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  rbbidata.h
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   RBBI data formats  Includes
  14 *
  15 *                          Structs that describes the format of the Binary RBBI data,
  16 *                          as it is stored in ICU's data file.
  17 *
  18 *      RBBIDataWrapper  -  Instances of this class sit between the
  19 *                          raw data structs and the RulesBasedBreakIterator objects
  20 *                          that are created by applications.  The wrapper class
  21 *                          provides reference counting for the underlying data,
  22 *                          and direct pointers to data that would not otherwise
  23 *                          be accessible without ugly pointer arithmetic.  The
  24 *                          wrapper does not attempt to provide any higher level
  25 *                          abstractions for the data itself.
  26 *
  27 *                          There will be only one instance of RBBIDataWrapper for any
  28 *                          set of RBBI run time data being shared by instances
  29 *                          (clones) of RulesBasedBreakIterator.
  30 */
  31
  32 #ifndef __RBBIDATA_H__
  33 #define __RBBIDATA_H__
  34
  35 #include "unicode/utypes.h"
  36 #include "unicode/udata.h"
  37 #include "udataswp.h"
  38
  39 /**
  40  * Swap RBBI data. See udataswp.h.
  41  * @internal
  42  */
  43 U_CAPI int32_t U_EXPORT2
  44 ubrk_swap(const UDataSwapper *ds,
  45           const void *inData, int32_t length, void *outData,
  46           UErrorCode *pErrorCode);
  47
  48 #ifdef XP_CPLUSPLUS
  49
  50 #include "unicode/uobject.h"
  51 #include "unicode/unistr.h"
  52 #include "utrie.h"
  53
  54 U_NAMESPACE_BEGIN
  55
  56 /*
  57  *   The following structs map exactly onto the raw data from ICU common data file.
  58  */
  59 struct RBBIDataHeader {
  60     uint32_t         fMagic;       /*  == 0xbla0 */
  61     uint32_t         fVersion;     /*  == 1 */
  62     uint32_t         fLength;      /*  Total length in bytes of this RBBI Data, */
  63                                    /*      including all sections, not just the header. */
  64     uint32_t         fCatCount;    /*  Number of character categories. */
  65
  66     /*  */
  67     /*  Offsets and sizes of each of the subsections within the RBBI data. */
  68     /*  All offsets are bytes from the start of the RBBIDataHeader. */
  69     /*  All sizes are in bytes. */
  70     /*  */
  71     uint32_t         fFTable;         /*  forward state transition table. */
  72     uint32_t         fFTableLen;
  73     uint32_t         fRTable;         /*  Offset to the reverse state transition table. */
  74     uint32_t         fRTableLen;
  75     uint32_t         fSFTable;        /*  safe point forward transition table */
  76     uint32_t         fSFTableLen;
  77     uint32_t         fSRTable;        /*  safe point reverse transition table */
  78     uint32_t         fSRTableLen;
  79     uint32_t         fTrie;           /*  Offset to Trie data for character categories */
  80     uint32_t         fTrieLen;
  81     uint32_t         fRuleSource;     /*  Offset to the source for for the break */
  82     uint32_t         fRuleSourceLen;  /*    rules.  Stored UChar *. */
  83     uint32_t         fStatusTable;    /* Offset to the table of rule status values */
  84     uint32_t         fStatusTableLen;
  85
  86     uint32_t         fReserved[6];    /*  Reserved for expansion */
  87
  88 };
  89
  90
  91
  92 struct  RBBIStateTableRow {
  93     int16_t          fAccepting;    /*  Non-zero if this row is for an accepting state.   */
  94                                     /*  Value 0: not an accepting state.                  */
  95                                     /*       -1: Unconditional Accepting state.           */
  96                                     /*    positive:  Look-ahead match has completed.      */
  97                                     /*           Actual boundary position happened earlier */
  98                                     /*           Value here == fLookAhead in earlier      */
  99                                     /*              state, at actual boundary pos.        */
 100     int16_t          fLookAhead;    /*  Non-zero if this row is for a state that          */
 101                                     /*    corresponds to a '/' in the rule source.        */
 102                                     /*    Value is the same as the fAccepting             */
 103                                     /*      value for the rule (which will appear         */
 104                                     /*      in a different state.                         */
 105     int16_t          fTagIdx;       /*  Non-zero if this row covers a {tagged} position   */
 106                                     /*     from a rule.  Value is the index in the        */
 107                                     /*     StatusTable of the set of matching             */
 108                                     /*     tags (rule status values)                      */
 109     int16_t          fReserved;
 110     uint16_t         fNextState[2]; /*  Next State, indexed by char category.             */
 111                                     /*    Array Size is fNumCols from the                 */
 112                                     /*    state table header.                             */
 113                                     /*    CAUTION:  see RBBITableBuilder::getTableSize()  */
 114                                     /*              before changing anything here.        */
 115 };
 116
 117
 118 struct RBBIStateTable {
 119     uint32_t         fNumStates;    /*  Number of states.                                 */
 120     uint32_t         fRowLen;       /*  Length of a state table row, in bytes.            */
 121     uint32_t         fFlags;        /*  Option Flags for this state table                 */
 122     uint32_t         fReserved;     /*  reserved                                          */
 123     char             fTableData[4]; /*  First RBBIStateTableRow begins here.              */
 124                                     /*    (making it char[] simplifies ugly address       */
 125                                     /*     arithmetic for indexing variable length rows.) */
 126 };
 127
 128 typedef enum {
 129     RBBI_LOOKAHEAD_HARD_BREAK = 1
 130 } RBBIStateTableFlags;
 131
 132
 133 /*                                        */
 134 /*   The reference counting wrapper class */
 135 /*                                        */
 136 class RBBIDataWrapper : public UMemory {
 137 public:
 138     RBBIDataWrapper(const RBBIDataHeader *data, UErrorCode &status);
 139     RBBIDataWrapper(UDataMemory* udm, UErrorCode &status);
 140     ~RBBIDataWrapper();
 141
 142     void                  init(const RBBIDataHeader *data, UErrorCode &status);
 143     RBBIDataWrapper      *addReference();
 144     void                  removeReference();
 145     UBool                 operator ==(const RBBIDataWrapper &other) const;
 146     int32_t               hashCode();
 147     const UnicodeString  &getRuleSourceString() const;
 148 #ifdef RBBI_DEBUG
 149     void                  printData();
 150     void                  printTable(const char *heading, const RBBIStateTable *table);
 151 #else
 152     #define printData()
 153     #define printTable(heading, table)
 154 #endif
 155
 156     /*                                     */
 157     /*   Pointers to items within the data */
 158     /*                                     */
 159     const RBBIDataHeader     *fHeader;
 160     const RBBIStateTable     *fForwardTable;
 161     const RBBIStateTable     *fReverseTable;
 162     const RBBIStateTable     *fSafeFwdTable;
 163     const RBBIStateTable     *fSafeRevTable;
 164     const UChar              *fRuleSource;
 165     const int32_t            *fRuleStatusTable;
 166
 167     /* number of int32_t values in the rule status table.   Used to sanity check indexing */
 168     int32_t             fStatusMaxIdx;
 169
 170     UTrie               fTrie;
 171
 172 private:
 173     int32_t             fRefCount;
 174     UDataMemory        *fUDataMem;
 175     UnicodeString       fRuleString;
 176
 177     RBBIDataWrapper(const RBBIDataWrapper &other); /*  forbid copying of this class */
 178     RBBIDataWrapper &operator=(const RBBIDataWrapper &other); /*  forbid copying of this class */
 179 };
 180
 181
 182
 183 U_NAMESPACE_END
 184
 185 #endif /* C++ */
 186
 187 #endif