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
39 // TODO: Use size_t instead of int.
40 // Disclaimer: You will see a compile error if you use this macro against a variable-length array.
41 // Sorry for the inconvenience. It isn't supported.
42 template <typename T, int N>
43 char (&ArraySizeHelper(T (&array)[N]))[N];
44 #define NELEMS(x) (sizeof(ArraySizeHelper(x)))
45
intArrayToCharArray(const int * const source,const int sourceSize,char * dest,const int destSize)46 AK_FORCE_INLINE static int intArrayToCharArray(const int *const source, const int sourceSize,
47 char *dest, const int destSize) {
48 // We want to always terminate with a 0 char, so stop one short of the length to make
49 // sure there is room.
50 const int destLimit = destSize - 1;
51 int si = 0;
52 int di = 0;
53 while (si < sourceSize && di < destLimit && 0 != source[si]) {
54 const int codePoint = source[si++];
55 if (codePoint < 0x7F) { // One byte
56 dest[di++] = codePoint;
57 } else if (codePoint < 0x7FF) { // Two bytes
58 if (di + 1 >= destLimit) break;
59 dest[di++] = 0xC0 + (codePoint >> 6);
60 dest[di++] = 0x80 + (codePoint & 0x3F);
61 } else if (codePoint < 0xFFFF) { // Three bytes
62 if (di + 2 >= destLimit) break;
63 dest[di++] = 0xE0 + (codePoint >> 12);
64 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
65 dest[di++] = 0x80 + (codePoint & 0x3F);
66 } else if (codePoint <= 0x1FFFFF) { // Four bytes
67 if (di + 3 >= destLimit) break;
68 dest[di++] = 0xF0 + (codePoint >> 18);
69 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
70 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
71 dest[di++] = 0x80 + (codePoint & 0x3F);
72 } else if (codePoint <= 0x3FFFFFF) { // Five bytes
73 if (di + 4 >= destLimit) break;
74 dest[di++] = 0xF8 + (codePoint >> 24);
75 dest[di++] = 0x80 + ((codePoint >> 18) & 0x3F);
76 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
77 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
78 dest[di++] = codePoint & 0x3F;
79 } else if (codePoint <= 0x7FFFFFFF) { // Six bytes
80 if (di + 5 >= destLimit) break;
81 dest[di++] = 0xFC + (codePoint >> 30);
82 dest[di++] = 0x80 + ((codePoint >> 24) & 0x3F);
83 dest[di++] = 0x80 + ((codePoint >> 18) & 0x3F);
84 dest[di++] = 0x80 + ((codePoint >> 12) & 0x3F);
85 dest[di++] = 0x80 + ((codePoint >> 6) & 0x3F);
86 dest[di++] = codePoint & 0x3F;
87 } else {
88 // Not a code point... skip.
89 }
90 }
91 dest[di] = 0;
92 return di;
93 }
94
95 #if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
96 #if defined(__ANDROID__)
97 #include <android/log.h>
98 #endif // defined(__ANDROID__)
99 #ifndef LOG_TAG
100 #define LOG_TAG "LatinIME: "
101 #endif // LOG_TAG
102
103 #if defined(HOST_TOOL)
104 #include <stdio.h>
105 #define AKLOGE(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
106 #define AKLOGI(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
107 #else // defined(HOST_TOOL)
108 #define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
109 #define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
110 #endif // defined(HOST_TOOL)
111
112 #define DUMP_SUGGESTION(words, frequencies, index, score) \
113 do { dumpWordInfo(words, frequencies, index, score); } while (0)
114 #define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
115 #define INTS_TO_CHARS(input, length, output, outlength) do { \
116 intArrayToCharArray(input, length, output, outlength); } while (0)
117
dumpWordInfo(const int * word,const int length,const int rank,const int probability)118 static inline void dumpWordInfo(const int *word, const int length, const int rank,
119 const int probability) {
120 static char charBuf[50];
121 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
122 if (N > 1) {
123 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, probability);
124 }
125 }
126
dumpWord(const int * word,const int length)127 static AK_FORCE_INLINE void dumpWord(const int *word, const int length) {
128 static char charBuf[50];
129 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
130 if (N > 1) {
131 AKLOGI("[ %s ]", charBuf);
132 }
133 }
134
135 #ifndef __ANDROID__
136 #include <cassert>
137 #include <execinfo.h>
138 #include <stdlib.h>
139
140 #define DO_ASSERT_TEST
141 #define ASSERT(success) do { if (!(success)) { showStackTrace(); assert(success);} } while (0)
142 #define SHOW_STACK_TRACE do { showStackTrace(); } while (0)
143
showStackTrace()144 static inline void showStackTrace() {
145 void *callstack[128];
146 int i, frames = backtrace(callstack, 128);
147 char **strs = backtrace_symbols(callstack, frames);
148 for (i = 0; i < frames; ++i) {
149 if (i == 0) {
150 AKLOGI("=== Trace ===");
151 continue;
152 }
153 AKLOGI("%s", strs[i]);
154 }
155 free(strs);
156 }
157 #else // __ANDROID__
158 #include <cassert>
159 #define DO_ASSERT_TEST
160 #define ASSERT(success) assert(success)
161 #define SHOW_STACK_TRACE
162 #endif // __ANDROID__
163
164 #else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
165 #define AKLOGE(fmt, ...)
166 #define AKLOGI(fmt, ...)
167 #define DUMP_SUGGESTION(words, frequencies, index, score)
168 #define DUMP_WORD(word, length)
169 #undef DO_ASSERT_TEST
170 #define ASSERT(success)
171 #define SHOW_STACK_TRACE
172 #define INTS_TO_CHARS(input, length, output)
173 #endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
174
175 #ifdef FLAG_DO_PROFILE
176 // Profiler
177 #include <time.h>
178
179 #define PROF_BUF_SIZE 100
180 static float profile_buf[PROF_BUF_SIZE];
181 static float profile_old[PROF_BUF_SIZE];
182 static unsigned int profile_counter[PROF_BUF_SIZE];
183
184 #define PROF_RESET prof_reset()
185 #define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
186 #define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while (0)
187 #define PROF_START(prof_buf_id) do { \
188 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while (0)
189 #define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while (0)
190 #define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
191 #define PROF_CLOCKOUT(prof_buf_id) \
192 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
193 #define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while (0)
194
prof_reset(void)195 static inline void prof_reset(void) {
196 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
197 profile_buf[i] = 0;
198 profile_old[i] = 0;
199 profile_counter[i] = 0;
200 }
201 }
202
prof_out(void)203 static inline void prof_out(void) {
204 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
205 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
206 }
207 AKLOGI("Total time is %6.3f ms.",
208 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
209 float all = 0.0f;
210 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
211 all += profile_buf[i];
212 }
213 if (all < 1.0f) all = 1.0f;
214 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
215 if (profile_buf[i] > 0.0f) {
216 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
217 i, (profile_buf[i] * 100.0f / all),
218 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
219 profile_counter[i]);
220 }
221 }
222 }
223
224 #else // FLAG_DO_PROFILE
225 #define PROF_BUF_SIZE 0
226 #define PROF_RESET
227 #define PROF_COUNT(prof_buf_id)
228 #define PROF_OPEN
229 #define PROF_START(prof_buf_id)
230 #define PROF_CLOSE
231 #define PROF_END(prof_buf_id)
232 #define PROF_CLOCK_OUT(prof_buf_id)
233 #define PROF_CLOCKOUT(prof_buf_id)
234 #define PROF_OUTALL
235
236 #endif // FLAG_DO_PROFILE
237
238 #ifdef FLAG_DBG
239 #define DEBUG_DICT true
240 #define DEBUG_DICT_FULL false
241 #define DEBUG_EDIT_DISTANCE false
242 #define DEBUG_NODE DEBUG_DICT_FULL
243 #define DEBUG_TRACE DEBUG_DICT_FULL
244 #define DEBUG_PROXIMITY_INFO false
245 #define DEBUG_PROXIMITY_CHARS false
246 #define DEBUG_CORRECTION false
247 #define DEBUG_CORRECTION_FREQ false
248 #define DEBUG_SAMPLING_POINTS false
249 #define DEBUG_POINTS_PROBABILITY false
250 #define DEBUG_DOUBLE_LETTER false
251 #define DEBUG_CACHE false
252 #define DEBUG_DUMP_ERROR false
253 #define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
254
255 #ifdef FLAG_FULL_DBG
256 #define DEBUG_GEO_FULL true
257 #else
258 #define DEBUG_GEO_FULL false
259 #endif
260
261 #else // FLAG_DBG
262
263 #define DEBUG_DICT false
264 #define DEBUG_DICT_FULL false
265 #define DEBUG_EDIT_DISTANCE false
266 #define DEBUG_NODE false
267 #define DEBUG_TRACE false
268 #define DEBUG_PROXIMITY_INFO false
269 #define DEBUG_PROXIMITY_CHARS false
270 #define DEBUG_CORRECTION false
271 #define DEBUG_CORRECTION_FREQ false
272 #define DEBUG_SAMPLING_POINTS false
273 #define DEBUG_POINTS_PROBABILITY false
274 #define DEBUG_DOUBLE_LETTER false
275 #define DEBUG_CACHE false
276 #define DEBUG_DUMP_ERROR false
277 #define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
278
279 #define DEBUG_GEO_FULL false
280
281 #endif // FLAG_DBG
282
283 #ifndef S_INT_MAX
284 #define S_INT_MAX 2147483647 // ((1 << 31) - 1)
285 #endif
286 #ifndef S_INT_MIN
287 // The literal constant -2147483648 does not work in C prior C90, because
288 // the compiler tries to fit the positive number into an int and then negate it.
289 // GCC warns about this.
290 #define S_INT_MIN (-2147483647 - 1) // -(1 << 31)
291 #endif
292
293 #define M_PI_F 3.14159265f
294 #define MAX_PERCENTILE 100
295
296 #define NOT_A_CODE_POINT (-1)
297 #define NOT_A_DISTANCE (-1)
298 #define NOT_A_COORDINATE (-1)
299 #define NOT_AN_INDEX (-1)
300 #define NOT_A_PROBABILITY (-1)
301 #define NOT_A_DICT_POS (S_INT_MIN)
302 #define NOT_A_TIMESTAMP (-1)
303 #define NOT_A_LANGUAGE_WEIGHT (-1.0f)
304
305 // A special value to mean the first word confidence makes no sense in this case,
306 // e.g. this is not a multi-word suggestion.
307 #define NOT_A_FIRST_WORD_CONFIDENCE (S_INT_MIN)
308 // How high the confidence needs to be for us to auto-commit. Arbitrary.
309 // This needs to be the same as CONFIDENCE_FOR_AUTO_COMMIT in BinaryDictionary.java
310 #define CONFIDENCE_FOR_AUTO_COMMIT (1000000)
311 // 80% of the full confidence
312 #define DISTANCE_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
313 // 100% of the full confidence
314 #define LENGTH_WEIGHT_FOR_AUTO_COMMIT (CONFIDENCE_FOR_AUTO_COMMIT)
315 // 80% of the full confidence
316 #define SPACE_COUNT_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
317
318 #define KEYCODE_SPACE ' '
319 #define KEYCODE_SINGLE_QUOTE '\''
320 #define KEYCODE_HYPHEN_MINUS '-'
321 // Code point to indicate beginning-of-sentence. This is not in the code point space of unicode.
322 #define CODE_POINT_BEGINNING_OF_SENTENCE 0x110000
323
324 #define SUGGEST_INTERFACE_OUTPUT_SCALE 1000000.0f
325 #define MAX_PROBABILITY 255
326 #define MAX_BIGRAM_ENCODED_PROBABILITY 15
327
328 // Max value for length, distance and probability which are used in weighting
329 // TODO: Remove
330 #define MAX_VALUE_FOR_WEIGHTING 10000000
331
332 // The max number of the keys in one keyboard layout
333 #define MAX_KEY_COUNT_IN_A_KEYBOARD 64
334
335 // TODO: Remove
336 #define MAX_POINTER_COUNT 1
337 #define MAX_POINTER_COUNT_G 2
338
339 // (MAX_PREV_WORD_COUNT_FOR_N_GRAM + 1)-gram is supported.
340 #define MAX_PREV_WORD_COUNT_FOR_N_GRAM 1
341
342 #define DISALLOW_DEFAULT_CONSTRUCTOR(TypeName) \
343 TypeName() = delete
344
345 #define DISALLOW_COPY_CONSTRUCTOR(TypeName) \
346 TypeName(const TypeName&) = delete
347
348 #define DISALLOW_ASSIGNMENT_OPERATOR(TypeName) \
349 void operator=(const TypeName&) = delete
350
351 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
352 DISALLOW_COPY_CONSTRUCTOR(TypeName); \
353 DISALLOW_ASSIGNMENT_OPERATOR(TypeName)
354
355 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
356 DISALLOW_DEFAULT_CONSTRUCTOR(TypeName); \
357 DISALLOW_COPY_AND_ASSIGN(TypeName)
358
359 // Used as a return value for character comparison
360 typedef enum {
361 // Same char, possibly with different case or accent
362 MATCH_CHAR,
363 // It is a char located nearby on the keyboard
364 PROXIMITY_CHAR,
365 // Additional proximity char which can differ by language.
366 ADDITIONAL_PROXIMITY_CHAR,
367 // It is a substitution char
368 SUBSTITUTION_CHAR,
369 // It is an unrelated char
370 UNRELATED_CHAR,
371 } ProximityType;
372
373 typedef enum {
374 NOT_A_DOUBLE_LETTER,
375 A_DOUBLE_LETTER,
376 A_STRONG_DOUBLE_LETTER
377 } DoubleLetterLevel;
378
379 typedef enum {
380 // Correction for MATCH_CHAR
381 CT_MATCH,
382 // Correction for PROXIMITY_CHAR
383 CT_PROXIMITY,
384 // Correction for ADDITIONAL_PROXIMITY_CHAR
385 CT_ADDITIONAL_PROXIMITY,
386 // Correction for SUBSTITUTION_CHAR
387 CT_SUBSTITUTION,
388 // Skip one omitted letter
389 CT_OMISSION,
390 // Delete an unnecessarily inserted letter
391 CT_INSERTION,
392 // Swap the order of next two touch points
393 CT_TRANSPOSITION,
394 CT_COMPLETION,
395 CT_TERMINAL,
396 CT_TERMINAL_INSERTION,
397 // Create new word with space omission
398 CT_NEW_WORD_SPACE_OMISSION,
399 // Create new word with space substitution
400 CT_NEW_WORD_SPACE_SUBSTITUTION,
401 } CorrectionType;
402 #endif // LATINIME_DEFINES_H
403