1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef LATINIME_DEFINES_H
18 #define LATINIME_DEFINES_H
19
20 #ifdef __GNUC__
21 #define AK_FORCE_INLINE __attribute__((always_inline)) __inline__
22 #else // __GNUC__
23 #define AK_FORCE_INLINE inline
24 #endif // __GNUC__
25
26 #if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
27 #undef AK_FORCE_INLINE
28 #define AK_FORCE_INLINE inline
29 #endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
30
31 // Must be equal to Constants.Dictionary.MAX_WORD_LENGTH in Java
32 #define MAX_WORD_LENGTH 48
33 // Must be equal to BinaryDictionary.MAX_RESULTS in Java
34 #define MAX_RESULTS 18
35 // Must be equal to ProximityInfo.MAX_PROXIMITY_CHARS_SIZE in Java
36 #define MAX_PROXIMITY_CHARS_SIZE 16
37 #define ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE 2
38 #define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
39
intArrayToCharArray(const int * const source,const int sourceSize,char * dest,const int destSize)40 AK_FORCE_INLINE static int intArrayToCharArray(const int *const source, const int sourceSize,
41 char *dest, const int destSize) {
42 // We want to always terminate with a 0 char, so stop one short of the length to make
43 // sure there is room.
44 const int destLimit = destSize - 1;
45 int si = 0;
46 int di = 0;
47 while (si < sourceSize && di < destLimit && 0 != source[si]) {
48 const int codePoint = source[si++];
49 if (codePoint < 0x7F) { // One byte
50 dest[di++] = codePoint;
51 } else if (codePoint < 0x7FF) { // Two bytes
52 if (di + 1 >= destLimit) break;
53 dest[di++] = 0xC0 + (codePoint >> 6);
54 dest[di++] = 0x80 + (codePoint & 0x3F);
55 } else if (codePoint < 0xFFFF) { // Three bytes
56 if (di + 2 >= destLimit) break;
57 dest[di++] = 0xE0 + (codePoint >> 12);
58 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
59 dest[di++] = 0x80 + (codePoint & 0x3F);
60 } else if (codePoint <= 0x1FFFFF) { // Four bytes
61 if (di + 3 >= destLimit) break;
62 dest[di++] = 0xF0 + (codePoint >> 18);
63 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
64 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
65 dest[di++] = 0x80 + (codePoint & 0x3F);
66 } else if (codePoint <= 0x3FFFFFF) { // Five bytes
67 if (di + 4 >= destLimit) break;
68 dest[di++] = 0xF8 + (codePoint >> 24);
69 dest[di++] = 0x80 + ((codePoint >> 18) & 0x3F);
70 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
71 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
72 dest[di++] = codePoint & 0x3F;
73 } else if (codePoint <= 0x7FFFFFFF) { // Six bytes
74 if (di + 5 >= destLimit) break;
75 dest[di++] = 0xFC + (codePoint >> 30);
76 dest[di++] = 0x80 + ((codePoint >> 24) & 0x3F);
77 dest[di++] = 0x80 + ((codePoint >> 18) & 0x3F);
78 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
79 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
80 dest[di++] = codePoint & 0x3F;
81 } else {
82 // Not a code point... skip.
83 }
84 }
85 dest[di] = 0;
86 return di;
87 }
88
89 #if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
90 #include <android/log.h>
91 #ifndef LOG_TAG
92 #define LOG_TAG "LatinIME: "
93 #endif // LOG_TAG
94 #define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
95 #define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
96
97 #define DUMP_RESULT(words, frequencies) do { dumpResult(words, frequencies); } while (0)
98 #define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
99 #define INTS_TO_CHARS(input, length, output, outlength) do { \
100 intArrayToCharArray(input, length, output, outlength); } while (0)
101
dumpWordInfo(const int * word,const int length,const int rank,const int probability)102 static inline void dumpWordInfo(const int *word, const int length, const int rank,
103 const int probability) {
104 static char charBuf[50];
105 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
106 if (N > 1) {
107 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, probability);
108 }
109 }
110
dumpResult(const int * outWords,const int * frequencies)111 static inline void dumpResult(const int *outWords, const int *frequencies) {
112 AKLOGI("--- DUMP RESULT ---------");
113 for (int i = 0; i < MAX_RESULTS; ++i) {
114 dumpWordInfo(&outWords[i * MAX_WORD_LENGTH], MAX_WORD_LENGTH, i, frequencies[i]);
115 }
116 AKLOGI("-------------------------");
117 }
118
dumpWord(const int * word,const int length)119 static AK_FORCE_INLINE void dumpWord(const int *word, const int length) {
120 static char charBuf[50];
121 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
122 if (N > 1) {
123 AKLOGI("[ %s ]", charBuf);
124 }
125 }
126
127 #ifndef __ANDROID__
128 #include <cassert>
129 #include <execinfo.h>
130 #include <stdlib.h>
131
132 #define DO_ASSERT_TEST
133 #define ASSERT(success) do { if (!(success)) { showStackTrace(); assert(success);} } while (0)
134 #define SHOW_STACK_TRACE do { showStackTrace(); } while (0)
135
showStackTrace()136 static inline void showStackTrace() {
137 void *callstack[128];
138 int i, frames = backtrace(callstack, 128);
139 char **strs = backtrace_symbols(callstack, frames);
140 for (i = 0; i < frames; ++i) {
141 if (i == 0) {
142 AKLOGI("=== Trace ===");
143 continue;
144 }
145 AKLOGI("%s", strs[i]);
146 }
147 free(strs);
148 }
149 #else // __ANDROID__
150 #include <cassert>
151 #define DO_ASSERT_TEST
152 #define ASSERT(success) assert(success)
153 #define SHOW_STACK_TRACE
154 #endif // __ANDROID__
155
156 #else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
157 #define AKLOGE(fmt, ...)
158 #define AKLOGI(fmt, ...)
159 #define DUMP_RESULT(words, frequencies)
160 #define DUMP_WORD(word, length)
161 #undef DO_ASSERT_TEST
162 #define ASSERT(success)
163 #define SHOW_STACK_TRACE
164 #define INTS_TO_CHARS(input, length, output)
165 #endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
166
167 #ifdef FLAG_DO_PROFILE
168 // Profiler
169 #include <time.h>
170
171 #define PROF_BUF_SIZE 100
172 static float profile_buf[PROF_BUF_SIZE];
173 static float profile_old[PROF_BUF_SIZE];
174 static unsigned int profile_counter[PROF_BUF_SIZE];
175
176 #define PROF_RESET prof_reset()
177 #define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
178 #define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while (0)
179 #define PROF_START(prof_buf_id) do { \
180 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while (0)
181 #define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while (0)
182 #define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
183 #define PROF_CLOCKOUT(prof_buf_id) \
184 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
185 #define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while (0)
186
prof_reset(void)187 static inline void prof_reset(void) {
188 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
189 profile_buf[i] = 0;
190 profile_old[i] = 0;
191 profile_counter[i] = 0;
192 }
193 }
194
prof_out(void)195 static inline void prof_out(void) {
196 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
197 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
198 }
199 AKLOGI("Total time is %6.3f ms.",
200 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
201 float all = 0.0f;
202 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
203 all += profile_buf[i];
204 }
205 if (all < 1.0f) all = 1.0f;
206 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
207 if (profile_buf[i] > 0.0f) {
208 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
209 i, (profile_buf[i] * 100.0f / all),
210 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
211 profile_counter[i]);
212 }
213 }
214 }
215
216 #else // FLAG_DO_PROFILE
217 #define PROF_BUF_SIZE 0
218 #define PROF_RESET
219 #define PROF_COUNT(prof_buf_id)
220 #define PROF_OPEN
221 #define PROF_START(prof_buf_id)
222 #define PROF_CLOSE
223 #define PROF_END(prof_buf_id)
224 #define PROF_CLOCK_OUT(prof_buf_id)
225 #define PROF_CLOCKOUT(prof_buf_id)
226 #define PROF_OUTALL
227
228 #endif // FLAG_DO_PROFILE
229
230 #ifdef FLAG_DBG
231 #define DEBUG_DICT true
232 #define DEBUG_DICT_FULL false
233 #define DEBUG_EDIT_DISTANCE false
234 #define DEBUG_NODE DEBUG_DICT_FULL
235 #define DEBUG_TRACE DEBUG_DICT_FULL
236 #define DEBUG_PROXIMITY_INFO false
237 #define DEBUG_PROXIMITY_CHARS false
238 #define DEBUG_CORRECTION false
239 #define DEBUG_CORRECTION_FREQ false
240 #define DEBUG_SAMPLING_POINTS false
241 #define DEBUG_POINTS_PROBABILITY false
242 #define DEBUG_DOUBLE_LETTER false
243 #define DEBUG_CACHE false
244 #define DEBUG_DUMP_ERROR false
245 #define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
246
247 #ifdef FLAG_FULL_DBG
248 #define DEBUG_GEO_FULL true
249 #else
250 #define DEBUG_GEO_FULL false
251 #endif
252
253 #else // FLAG_DBG
254
255 #define DEBUG_DICT false
256 #define DEBUG_DICT_FULL false
257 #define DEBUG_EDIT_DISTANCE false
258 #define DEBUG_NODE false
259 #define DEBUG_TRACE false
260 #define DEBUG_PROXIMITY_INFO false
261 #define DEBUG_PROXIMITY_CHARS false
262 #define DEBUG_CORRECTION false
263 #define DEBUG_CORRECTION_FREQ false
264 #define DEBUG_SAMPLING_POINTS false
265 #define DEBUG_POINTS_PROBABILITY false
266 #define DEBUG_DOUBLE_LETTER false
267 #define DEBUG_CACHE false
268 #define DEBUG_DUMP_ERROR false
269 #define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
270
271 #define DEBUG_GEO_FULL false
272
273 #endif // FLAG_DBG
274
275 #ifndef S_INT_MAX
276 #define S_INT_MAX 2147483647 // ((1 << 31) - 1)
277 #endif
278 #ifndef S_INT_MIN
279 // The literal constant -2147483648 does not work in C prior C90, because
280 // the compiler tries to fit the positive number into an int and then negate it.
281 // GCC warns about this.
282 #define S_INT_MIN (-2147483647 - 1) // -(1 << 31)
283 #endif
284
285 #define M_PI_F 3.14159265f
286 #define MAX_PERCENTILE 100
287
288 // Number of base-10 digits in the largest integer + 1 to leave room for a zero terminator.
289 // As such, this is the maximum number of characters will be needed to represent an int as a
290 // string, including the terminator; this is used as the size of a string buffer large enough to
291 // hold any value that is intended to fit in an integer, e.g. in the code that reads the header
292 // of the binary dictionary where a {key,value} string pair scheme is used.
293 #define LARGEST_INT_DIGIT_COUNT 11
294
295 #define NOT_A_CODE_POINT (-1)
296 #define NOT_A_DISTANCE (-1)
297 #define NOT_A_COORDINATE (-1)
298 #define NOT_AN_INDEX (-1)
299 #define NOT_A_PROBABILITY (-1)
300 #define NOT_A_DICT_POS (S_INT_MIN)
301
302 // A special value to mean the first word confidence makes no sense in this case,
303 // e.g. this is not a multi-word suggestion.
304 #define NOT_A_FIRST_WORD_CONFIDENCE (S_INT_MAX)
305 // How high the confidence needs to be for us to auto-commit. Arbitrary.
306 // This needs to be the same as CONFIDENCE_FOR_AUTO_COMMIT in BinaryDictionary.java
307 #define CONFIDENCE_FOR_AUTO_COMMIT (1000000)
308 // 80% of the full confidence
309 #define DISTANCE_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
310 // 100% of the full confidence
311 #define LENGTH_WEIGHT_FOR_AUTO_COMMIT (CONFIDENCE_FOR_AUTO_COMMIT)
312 // 80% of the full confidence
313 #define SPACE_COUNT_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
314
315 #define KEYCODE_SPACE ' '
316 #define KEYCODE_SINGLE_QUOTE '\''
317 #define KEYCODE_HYPHEN_MINUS '-'
318
319 #define SUGGEST_INTERFACE_OUTPUT_SCALE 1000000.0f
320 #define MAX_PROBABILITY 255
321 #define MAX_BIGRAM_ENCODED_PROBABILITY 15
322
323 // Assuming locale strings such as en_US, sr-Latn etc.
324 #define MAX_LOCALE_STRING_LENGTH 10
325
326 // Max value for length, distance and probability which are used in weighting
327 // TODO: Remove
328 #define MAX_VALUE_FOR_WEIGHTING 10000000
329
330 // The max number of the keys in one keyboard layout
331 #define MAX_KEY_COUNT_IN_A_KEYBOARD 64
332
333 // TODO: Remove
334 #define MAX_POINTER_COUNT 1
335 #define MAX_POINTER_COUNT_G 2
336
min(const T & a,const T & b)337 template<typename T> AK_FORCE_INLINE const T &min(const T &a, const T &b) { return a < b ? a : b; }
max(const T & a,const T & b)338 template<typename T> AK_FORCE_INLINE const T &max(const T &a, const T &b) { return a > b ? a : b; }
339
340 // DEBUG
341 #define INPUTLENGTH_FOR_DEBUG (-1)
342 #define MIN_OUTPUT_INDEX_FOR_DEBUG (-1)
343
344 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
345 TypeName(const TypeName&); \
346 void operator=(const TypeName&)
347
348 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
349 TypeName(); \
350 DISALLOW_COPY_AND_ASSIGN(TypeName)
351
352 // Used as a return value for character comparison
353 typedef enum {
354 // Same char, possibly with different case or accent
355 MATCH_CHAR,
356 // It is a char located nearby on the keyboard
357 PROXIMITY_CHAR,
358 // Additional proximity char which can differ by language.
359 ADDITIONAL_PROXIMITY_CHAR,
360 // It is a substitution char
361 SUBSTITUTION_CHAR,
362 // It is an unrelated char
363 UNRELATED_CHAR,
364 } ProximityType;
365
366 typedef enum {
367 NOT_A_DOUBLE_LETTER,
368 A_DOUBLE_LETTER,
369 A_STRONG_DOUBLE_LETTER
370 } DoubleLetterLevel;
371
372 typedef enum {
373 // Correction for MATCH_CHAR
374 CT_MATCH,
375 // Correction for PROXIMITY_CHAR
376 CT_PROXIMITY,
377 // Correction for ADDITIONAL_PROXIMITY_CHAR
378 CT_ADDITIONAL_PROXIMITY,
379 // Correction for SUBSTITUTION_CHAR
380 CT_SUBSTITUTION,
381 // Skip one omitted letter
382 CT_OMISSION,
383 // Delete an unnecessarily inserted letter
384 CT_INSERTION,
385 // Swap the order of next two touch points
386 CT_TRANSPOSITION,
387 CT_COMPLETION,
388 CT_TERMINAL,
389 CT_TERMINAL_INSERTION,
390 // Create new word with space omission
391 CT_NEW_WORD_SPACE_OMISSION,
392 // Create new word with space substitution
393 CT_NEW_WORD_SPACE_SUBSTITUTION,
394 } CorrectionType;
395
396 // ErrorType is mainly decided by CorrectionType but it is also depending on if
397 // the correction has really been performed or not.
398 typedef enum {
399 // Substitution, omission and transposition
400 ET_EDIT_CORRECTION,
401 // Proximity error
402 ET_PROXIMITY_CORRECTION,
403 // Completion
404 ET_COMPLETION,
405 // New word
406 // TODO: Remove.
407 // A new word error should be an edit correction error or a proximity correction error.
408 ET_NEW_WORD,
409 // Treat error as an intentional omission when the CorrectionType is omission and the node can
410 // be intentional omission.
411 ET_INTENTIONAL_OMISSION,
412 // Not treated as an error. Tracked for checking exact match
413 ET_NOT_AN_ERROR
414 } ErrorType;
415 #endif // LATINIME_DEFINES_H
416