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