blob: 3651cd52318e867c3c7c93a068e1524eefa96df0 [file] [log] [blame]
satoke808e432010-12-02 14:53:24 +09001/*
Ken Wakasaa10b1a82013-01-08 17:23:43 +09002 * Copyright (C) 2010 The Android Open Source Project
Ken Wakasa0bbb9172012-07-25 17:51:43 +09003 *
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 *
Ken Wakasaa10b1a82013-01-08 17:23:43 +09008 * http://www.apache.org/licenses/LICENSE-2.0
Ken Wakasa0bbb9172012-07-25 17:51:43 +09009 *
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 */
satoke808e432010-12-02 14:53:24 +090016
17#ifndef LATINIME_DEFINES_H
18#define LATINIME_DEFINES_H
19
Ken Wakasa1ce96fe2012-11-15 19:09:11 +090020#ifdef __GNUC__
21#define AK_FORCE_INLINE __attribute__((always_inline)) __inline__
22#else // __GNUC__
23#define AK_FORCE_INLINE inline
24#endif // __GNUC__
25
Ken Wakasa6cee61d2013-01-15 16:15:48 +090026#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
Ken Wakasa6c224392013-01-22 13:14:53 +090031// Must be equal to Constants.Dictionary.MAX_WORD_LENGTH in Java
Ken Wakasa5db594a2013-01-12 01:18:00 +090032#define MAX_WORD_LENGTH 48
Ken Wakasa6c224392013-01-22 13:14:53 +090033// Must be equal to BinaryDictionary.MAX_RESULTS in Java
Ken Wakasa5db594a2013-01-12 01:18:00 +090034#define MAX_RESULTS 18
Ken Wakasa6c224392013-01-22 13:14:53 +090035// 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
Jean Chalard7eba0192013-06-27 17:31:13 +090038#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
39
40AK_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}
Satoshi Kataoka42217382012-12-17 23:28:17 +090088
satok827ced82011-07-14 09:01:09 +090089#if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
Jean Chalarda245d152013-12-12 15:08:10 +090090#if defined(__ANDROID__)
Ken Wakasae3f26dd2012-07-27 18:06:06 +090091#include <android/log.h>
Jean Chalarda245d152013-12-12 15:08:10 +090092#endif // defined(__ANDROID__)
Ken Wakasae3f26dd2012-07-27 18:06:06 +090093#ifndef LOG_TAG
94#define LOG_TAG "LatinIME: "
Ken Wakasa6cee61d2013-01-15 16:15:48 +090095#endif // LOG_TAG
Jean Chalarda245d152013-12-12 15:08:10 +090096
97#if defined(HOST_TOOL)
98#include <stdio.h>
99#define AKLOGE(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
100#define AKLOGI(fmt, ...) printf(fmt "\n", ##__VA_ARGS__)
101#else // defined(HOST_TOOL)
Ken Wakasae3f26dd2012-07-27 18:06:06 +0900102#define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
103#define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
Jean Chalarda245d152013-12-12 15:08:10 +0900104#endif // defined(HOST_TOOL)
satok6ad15fc2012-01-16 16:21:21 +0900105
Keisuke Kuroyanagid73edf22014-03-27 20:05:33 +0900106#define DUMP_SUGGESTION(words, frequencies, index, score) \
107 do { dumpWordInfo(words, frequencies, index, score); } while (0)
Ken Wakasaf2789812012-09-04 12:49:46 +0900108#define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
Jean Chalard7eba0192013-06-27 17:31:13 +0900109#define INTS_TO_CHARS(input, length, output, outlength) do { \
110 intArrayToCharArray(input, length, output, outlength); } while (0)
Satoshi Kataoka42217382012-12-17 23:28:17 +0900111
Ken Wakasa1e614932012-10-29 18:06:22 +0900112static inline void dumpWordInfo(const int *word, const int length, const int rank,
Satoshi Kataokae0e67372013-03-18 13:08:31 +0900113 const int probability) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900114 static char charBuf[50];
Jean Chalard7eba0192013-06-27 17:31:13 +0900115 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
Satoshi Kataoka42217382012-12-17 23:28:17 +0900116 if (N > 1) {
Satoshi Kataokae0e67372013-03-18 13:08:31 +0900117 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, probability);
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900118 }
119}
120
Ken Wakasa5db594a2013-01-12 01:18:00 +0900121static inline void dumpResult(const int *outWords, const int *frequencies) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900122 AKLOGI("--- DUMP RESULT ---------");
Ken Wakasa5db594a2013-01-12 01:18:00 +0900123 for (int i = 0; i < MAX_RESULTS; ++i) {
124 dumpWordInfo(&outWords[i * MAX_WORD_LENGTH], MAX_WORD_LENGTH, i, frequencies[i]);
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900125 }
126 AKLOGI("-------------------------");
127}
128
Ken Wakasa1ce96fe2012-11-15 19:09:11 +0900129static AK_FORCE_INLINE void dumpWord(const int *word, const int length) {
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900130 static char charBuf[50];
Jean Chalard7eba0192013-06-27 17:31:13 +0900131 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
Satoshi Kataoka42217382012-12-17 23:28:17 +0900132 if (N > 1) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900133 AKLOGI("[ %s ]", charBuf);
134 }
satok6ad15fc2012-01-16 16:21:21 +0900135}
136
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900137#ifndef __ANDROID__
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900138#include <cassert>
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900139#include <execinfo.h>
140#include <stdlib.h>
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900141
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900142#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900143#define ASSERT(success) do { if (!(success)) { showStackTrace(); assert(success);} } while (0)
144#define SHOW_STACK_TRACE do { showStackTrace(); } while (0)
145
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900146static inline void showStackTrace() {
147 void *callstack[128];
148 int i, frames = backtrace(callstack, 128);
149 char **strs = backtrace_symbols(callstack, frames);
150 for (i = 0; i < frames; ++i) {
151 if (i == 0) {
152 AKLOGI("=== Trace ===");
153 continue;
154 }
155 AKLOGI("%s", strs[i]);
156 }
157 free(strs);
158}
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900159#else // __ANDROID__
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900160#include <cassert>
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900161#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900162#define ASSERT(success) assert(success)
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900163#define SHOW_STACK_TRACE
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900164#endif // __ANDROID__
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900165
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900166#else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
satok9fb6f472012-01-13 18:01:22 +0900167#define AKLOGE(fmt, ...)
168#define AKLOGI(fmt, ...)
Keisuke Kuroyanagid73edf22014-03-27 20:05:33 +0900169#define DUMP_SUGGESTION(words, frequencies, index, score)
satok6ad15fc2012-01-16 16:21:21 +0900170#define DUMP_WORD(word, length)
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900171#undef DO_ASSERT_TEST
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900172#define ASSERT(success)
173#define SHOW_STACK_TRACE
Ken Wakasa1e614932012-10-29 18:06:22 +0900174#define INTS_TO_CHARS(input, length, output)
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900175#endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
satok827ced82011-07-14 09:01:09 +0900176
satok20d9fda2011-07-13 14:40:30 +0900177#ifdef FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900178// Profiler
179#include <time.h>
satok9fb6f472012-01-13 18:01:22 +0900180
satok61e2f852011-01-05 14:13:07 +0900181#define PROF_BUF_SIZE 100
satok0028ed32012-05-16 20:42:12 +0900182static float profile_buf[PROF_BUF_SIZE];
183static float profile_old[PROF_BUF_SIZE];
satok61e2f852011-01-05 14:13:07 +0900184static unsigned int profile_counter[PROF_BUF_SIZE];
185
Ken Wakasae90b3332011-01-07 15:01:51 +0900186#define PROF_RESET prof_reset()
187#define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
Ken Wakasaf2789812012-09-04 12:49:46 +0900188#define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900189#define PROF_START(prof_buf_id) do { \
Ken Wakasaf2789812012-09-04 12:49:46 +0900190 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while (0)
191#define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900192#define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
193#define PROF_CLOCKOUT(prof_buf_id) \
satok9fb6f472012-01-13 18:01:22 +0900194 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
Ken Wakasaf2789812012-09-04 12:49:46 +0900195#define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while (0)
satok61e2f852011-01-05 14:13:07 +0900196
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900197static inline void prof_reset(void) {
Ken Wakasae90b3332011-01-07 15:01:51 +0900198 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
satok61e2f852011-01-05 14:13:07 +0900199 profile_buf[i] = 0;
200 profile_old[i] = 0;
201 profile_counter[i] = 0;
202 }
203}
204
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900205static inline void prof_out(void) {
satok61e2f852011-01-05 14:13:07 +0900206 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
satok9fb6f472012-01-13 18:01:22 +0900207 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
satok61e2f852011-01-05 14:13:07 +0900208 }
satok9fb6f472012-01-13 18:01:22 +0900209 AKLOGI("Total time is %6.3f ms.",
Ken Wakasa77e8e812012-08-02 19:48:08 +0900210 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900211 float all = 0.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900212 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
satok61e2f852011-01-05 14:13:07 +0900213 all += profile_buf[i];
214 }
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900215 if (all < 1.0f) all = 1.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900216 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900217 if (profile_buf[i] > 0.0f) {
satok9fb6f472012-01-13 18:01:22 +0900218 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900219 i, (profile_buf[i] * 100.0f / all),
Ken Wakasa77e8e812012-08-02 19:48:08 +0900220 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
221 profile_counter[i]);
Ken Wakasae90b3332011-01-07 15:01:51 +0900222 }
satok61e2f852011-01-05 14:13:07 +0900223 }
224}
225
satok20d9fda2011-07-13 14:40:30 +0900226#else // FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900227#define PROF_BUF_SIZE 0
228#define PROF_RESET
229#define PROF_COUNT(prof_buf_id)
230#define PROF_OPEN
231#define PROF_START(prof_buf_id)
232#define PROF_CLOSE
233#define PROF_END(prof_buf_id)
234#define PROF_CLOCK_OUT(prof_buf_id)
235#define PROF_CLOCKOUT(prof_buf_id)
236#define PROF_OUTALL
237
satok20d9fda2011-07-13 14:40:30 +0900238#endif // FLAG_DO_PROFILE
239
240#ifdef FLAG_DBG
satok20d9fda2011-07-13 14:40:30 +0900241#define DEBUG_DICT true
242#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900243#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900244#define DEBUG_NODE DEBUG_DICT_FULL
245#define DEBUG_TRACE DEBUG_DICT_FULL
satok1a6da632011-12-16 23:15:06 +0900246#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900247#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900248#define DEBUG_CORRECTION false
satok29dc8062012-01-17 15:59:15 +0900249#define DEBUG_CORRECTION_FREQ false
Satoshi Kataoka0ed8c6e2012-12-04 16:28:06 +0900250#define DEBUG_SAMPLING_POINTS false
251#define DEBUG_POINTS_PROBABILITY false
252#define DEBUG_DOUBLE_LETTER false
Satoshi Kataokabc25b802013-02-21 21:54:21 +0900253#define DEBUG_CACHE false
254#define DEBUG_DUMP_ERROR false
Satoshi Kataoka8b3009e2013-04-10 11:45:12 +0900255#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
satok20d9fda2011-07-13 14:40:30 +0900256
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900257#ifdef FLAG_FULL_DBG
258#define DEBUG_GEO_FULL true
259#else
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900260#define DEBUG_GEO_FULL false
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900261#endif
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900262
satok20d9fda2011-07-13 14:40:30 +0900263#else // FLAG_DBG
satok827ced82011-07-14 09:01:09 +0900264
satok20d9fda2011-07-13 14:40:30 +0900265#define DEBUG_DICT false
266#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900267#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900268#define DEBUG_NODE false
269#define DEBUG_TRACE false
270#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900271#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900272#define DEBUG_CORRECTION false
273#define DEBUG_CORRECTION_FREQ false
Keisuke Kuroyanagi806eba42012-10-09 19:57:08 +0900274#define DEBUG_SAMPLING_POINTS false
275#define DEBUG_POINTS_PROBABILITY false
Satoshi Kataoka9af53352012-11-16 23:06:41 +0900276#define DEBUG_DOUBLE_LETTER false
Satoshi Kataokabc25b802013-02-21 21:54:21 +0900277#define DEBUG_CACHE false
278#define DEBUG_DUMP_ERROR false
Satoshi Kataoka8b3009e2013-04-10 11:45:12 +0900279#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
satok20d9fda2011-07-13 14:40:30 +0900280
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900281#define DEBUG_GEO_FULL false
282
satoke808e432010-12-02 14:53:24 +0900283#endif // FLAG_DBG
284
Jean Chalarda5d58492011-02-18 17:50:58 +0900285#ifndef S_INT_MAX
satok3c4bb772011-03-04 22:50:19 -0800286#define S_INT_MAX 2147483647 // ((1 << 31) - 1)
Jean Chalarda5d58492011-02-18 17:50:58 +0900287#endif
Jean Chalard592f2b32012-11-20 21:19:26 +0900288#ifndef S_INT_MIN
289// The literal constant -2147483648 does not work in C prior C90, because
290// the compiler tries to fit the positive number into an int and then negate it.
291// GCC warns about this.
292#define S_INT_MIN (-2147483647 - 1) // -(1 << 31)
293#endif
Satoshi Kataokaee62b782013-01-21 18:29:27 +0900294
Ken Wakasa6c224392013-01-22 13:14:53 +0900295#define M_PI_F 3.14159265f
Satoshi Kataokaee62b782013-01-21 18:29:27 +0900296#define MAX_PERCENTILE 100
297
Jean Chalard22025c62012-11-29 17:33:53 +0900298// Number of base-10 digits in the largest integer + 1 to leave room for a zero terminator.
299// As such, this is the maximum number of characters will be needed to represent an int as a
300// string, including the terminator; this is used as the size of a string buffer large enough to
301// hold any value that is intended to fit in an integer, e.g. in the code that reads the header
302// of the binary dictionary where a {key,value} string pair scheme is used.
303#define LARGEST_INT_DIGIT_COUNT 11
satok662fe692010-12-08 17:05:39 +0900304
Ken Wakasaf2789812012-09-04 12:49:46 +0900305#define NOT_A_CODE_POINT (-1)
306#define NOT_A_DISTANCE (-1)
307#define NOT_A_COORDINATE (-1)
Ken Wakasaf2789812012-09-04 12:49:46 +0900308#define NOT_AN_INDEX (-1)
309#define NOT_A_PROBABILITY (-1)
Keisuke Kuroynagi68e7edf2013-06-27 12:53:31 +0900310#define NOT_A_DICT_POS (S_INT_MIN)
Ken Wakasa2fa36932013-12-13 17:09:16 +0900311#define NOT_A_TIMESTAMP (-1)
Jean Chalard459cd6f2013-10-01 17:30:40 +0900312
Jean Chalardbb570902013-09-30 21:39:43 +0900313// A special value to mean the first word confidence makes no sense in this case,
314// e.g. this is not a multi-word suggestion.
Keisuke Kuroyanagi8c5c01e2014-02-05 11:40:17 +0900315#define NOT_A_FIRST_WORD_CONFIDENCE (S_INT_MIN)
Jean Chalard459cd6f2013-10-01 17:30:40 +0900316// How high the confidence needs to be for us to auto-commit. Arbitrary.
317// This needs to be the same as CONFIDENCE_FOR_AUTO_COMMIT in BinaryDictionary.java
318#define CONFIDENCE_FOR_AUTO_COMMIT (1000000)
319// 80% of the full confidence
320#define DISTANCE_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
321// 100% of the full confidence
322#define LENGTH_WEIGHT_FOR_AUTO_COMMIT (CONFIDENCE_FOR_AUTO_COMMIT)
323// 80% of the full confidence
324#define SPACE_COUNT_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
satoke808e432010-12-02 14:53:24 +0900325
satok817e5172011-03-04 06:06:45 -0800326#define KEYCODE_SPACE ' '
Ken Wakasa1e614932012-10-29 18:06:22 +0900327#define KEYCODE_SINGLE_QUOTE '\''
328#define KEYCODE_HYPHEN_MINUS '-'
satok817e5172011-03-04 06:06:45 -0800329
Tom Ouyang31f7ece2013-02-21 15:42:05 -0800330#define SUGGEST_INTERFACE_OUTPUT_SCALE 1000000.0f
Satoshi Kataokae0e67372013-03-18 13:08:31 +0900331#define MAX_PROBABILITY 255
332#define MAX_BIGRAM_ENCODED_PROBABILITY 15
satoke808e432010-12-02 14:53:24 +0900333
Ken Wakasa9e0c7112012-08-09 22:26:58 +0900334// Assuming locale strings such as en_US, sr-Latn etc.
335#define MAX_LOCALE_STRING_LENGTH 10
336
Satoshi Kataoka830ba672013-03-05 14:12:06 +0900337// Max value for length, distance and probability which are used in weighting
338// TODO: Remove
339#define MAX_VALUE_FOR_WEIGHTING 10000000
Satoshi Kataoka687a2442012-08-23 15:46:43 +0900340
Keisuke Kuroyanagi95a49a52012-09-04 17:00:24 +0900341// The max number of the keys in one keyboard layout
342#define MAX_KEY_COUNT_IN_A_KEYBOARD 64
343
Ken Wakasa5150e152012-09-27 19:21:25 +0900344// TODO: Remove
Satoshi Kataokafe4f1ce2012-12-10 17:17:52 +0900345#define MAX_POINTER_COUNT 1
Satoshi Kataoka99eae8e2013-01-30 20:55:31 +0900346#define MAX_POINTER_COUNT_G 2
Ken Wakasa5150e152012-09-27 19:21:25 +0900347
Ken Wakasa2fa36932013-12-13 17:09:16 +0900348#define DISALLOW_DEFAULT_CONSTRUCTOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900349 TypeName() = delete
Ken Wakasa2fa36932013-12-13 17:09:16 +0900350
351#define DISALLOW_COPY_CONSTRUCTOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900352 TypeName(const TypeName&) = delete
Ken Wakasa2fa36932013-12-13 17:09:16 +0900353
354#define DISALLOW_ASSIGNMENT_OPERATOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900355 void operator=(const TypeName&) = delete
satok1bc038c2012-06-14 11:25:50 -0700356
Ken Wakasa2fa36932013-12-13 17:09:16 +0900357#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
358 DISALLOW_COPY_CONSTRUCTOR(TypeName); \
359 DISALLOW_ASSIGNMENT_OPERATOR(TypeName)
360
satok1bc038c2012-06-14 11:25:50 -0700361#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
Ken Wakasa2fa36932013-12-13 17:09:16 +0900362 DISALLOW_DEFAULT_CONSTRUCTOR(TypeName); \
satok1bc038c2012-06-14 11:25:50 -0700363 DISALLOW_COPY_AND_ASSIGN(TypeName)
364
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900365// Used as a return value for character comparison
366typedef enum {
367 // Same char, possibly with different case or accent
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900368 MATCH_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900369 // It is a char located nearby on the keyboard
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900370 PROXIMITY_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900371 // Additional proximity char which can differ by language.
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900372 ADDITIONAL_PROXIMITY_CHAR,
373 // It is a substitution char
374 SUBSTITUTION_CHAR,
375 // It is an unrelated char
376 UNRELATED_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900377} ProximityType;
Satoshi Kataoka6ae8dd42012-11-22 20:15:40 +0900378
379typedef enum {
380 NOT_A_DOUBLE_LETTER,
381 A_DOUBLE_LETTER,
382 A_STRONG_DOUBLE_LETTER
383} DoubleLetterLevel;
Satoshi Kataokad8708912013-03-04 17:05:28 +0900384
385typedef enum {
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900386 // Correction for MATCH_CHAR
Satoshi Kataokad8708912013-03-04 17:05:28 +0900387 CT_MATCH,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900388 // Correction for PROXIMITY_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900389 CT_PROXIMITY,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900390 // Correction for ADDITIONAL_PROXIMITY_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900391 CT_ADDITIONAL_PROXIMITY,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900392 // Correction for SUBSTITUTION_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900393 CT_SUBSTITUTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900394 // Skip one omitted letter
Satoshi Kataokad8708912013-03-04 17:05:28 +0900395 CT_OMISSION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900396 // Delete an unnecessarily inserted letter
Satoshi Kataokad8708912013-03-04 17:05:28 +0900397 CT_INSERTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900398 // Swap the order of next two touch points
Satoshi Kataokad8708912013-03-04 17:05:28 +0900399 CT_TRANSPOSITION,
Satoshi Kataokad8708912013-03-04 17:05:28 +0900400 CT_COMPLETION,
401 CT_TERMINAL,
Satoshi Kataoka75322ce2013-06-14 18:40:59 +0900402 CT_TERMINAL_INSERTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900403 // Create new word with space omission
Jean Chalardda06e382013-09-30 18:41:55 +0900404 CT_NEW_WORD_SPACE_OMISSION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900405 // Create new word with space substitution
Satoshi Kataoka252412d2013-04-16 14:39:30 +0900406 CT_NEW_WORD_SPACE_SUBSTITUTION,
Satoshi Kataokad8708912013-03-04 17:05:28 +0900407} CorrectionType;
satoke808e432010-12-02 14:53:24 +0900408#endif // LATINIME_DEFINES_H