blob: 1719b1c603b5a673870f0956e7bdf3ffae270062 [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 Wakasa1ce96fe2012-11-15 19:09:11 +0900121static AK_FORCE_INLINE void dumpWord(const int *word, const int length) {
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900122 static char charBuf[50];
Jean Chalard7eba0192013-06-27 17:31:13 +0900123 const int N = intArrayToCharArray(word, length, charBuf, NELEMS(charBuf));
Satoshi Kataoka42217382012-12-17 23:28:17 +0900124 if (N > 1) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +0900125 AKLOGI("[ %s ]", charBuf);
126 }
satok6ad15fc2012-01-16 16:21:21 +0900127}
128
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900129#ifndef __ANDROID__
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900130#include <cassert>
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900131#include <execinfo.h>
132#include <stdlib.h>
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900133
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900134#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900135#define ASSERT(success) do { if (!(success)) { showStackTrace(); assert(success);} } while (0)
136#define SHOW_STACK_TRACE do { showStackTrace(); } while (0)
137
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900138static inline void showStackTrace() {
139 void *callstack[128];
140 int i, frames = backtrace(callstack, 128);
141 char **strs = backtrace_symbols(callstack, frames);
142 for (i = 0; i < frames; ++i) {
143 if (i == 0) {
144 AKLOGI("=== Trace ===");
145 continue;
146 }
147 AKLOGI("%s", strs[i]);
148 }
149 free(strs);
150}
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900151#else // __ANDROID__
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900152#include <cassert>
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900153#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900154#define ASSERT(success) assert(success)
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900155#define SHOW_STACK_TRACE
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900156#endif // __ANDROID__
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900157
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900158#else // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
satok9fb6f472012-01-13 18:01:22 +0900159#define AKLOGE(fmt, ...)
160#define AKLOGI(fmt, ...)
Keisuke Kuroyanagid73edf22014-03-27 20:05:33 +0900161#define DUMP_SUGGESTION(words, frequencies, index, score)
satok6ad15fc2012-01-16 16:21:21 +0900162#define DUMP_WORD(word, length)
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900163#undef DO_ASSERT_TEST
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900164#define ASSERT(success)
165#define SHOW_STACK_TRACE
Ken Wakasa1e614932012-10-29 18:06:22 +0900166#define INTS_TO_CHARS(input, length, output)
Ken Wakasa6cee61d2013-01-15 16:15:48 +0900167#endif // defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
satok827ced82011-07-14 09:01:09 +0900168
satok20d9fda2011-07-13 14:40:30 +0900169#ifdef FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900170// Profiler
171#include <time.h>
satok9fb6f472012-01-13 18:01:22 +0900172
satok61e2f852011-01-05 14:13:07 +0900173#define PROF_BUF_SIZE 100
satok0028ed32012-05-16 20:42:12 +0900174static float profile_buf[PROF_BUF_SIZE];
175static float profile_old[PROF_BUF_SIZE];
satok61e2f852011-01-05 14:13:07 +0900176static unsigned int profile_counter[PROF_BUF_SIZE];
177
Ken Wakasae90b3332011-01-07 15:01:51 +0900178#define PROF_RESET prof_reset()
179#define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
Ken Wakasaf2789812012-09-04 12:49:46 +0900180#define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900181#define PROF_START(prof_buf_id) do { \
Ken Wakasaf2789812012-09-04 12:49:46 +0900182 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while (0)
183#define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900184#define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
185#define PROF_CLOCKOUT(prof_buf_id) \
satok9fb6f472012-01-13 18:01:22 +0900186 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
Ken Wakasaf2789812012-09-04 12:49:46 +0900187#define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while (0)
satok61e2f852011-01-05 14:13:07 +0900188
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900189static inline void prof_reset(void) {
Ken Wakasae90b3332011-01-07 15:01:51 +0900190 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
satok61e2f852011-01-05 14:13:07 +0900191 profile_buf[i] = 0;
192 profile_old[i] = 0;
193 profile_counter[i] = 0;
194 }
195}
196
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900197static inline void prof_out(void) {
satok61e2f852011-01-05 14:13:07 +0900198 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
satok9fb6f472012-01-13 18:01:22 +0900199 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
satok61e2f852011-01-05 14:13:07 +0900200 }
satok9fb6f472012-01-13 18:01:22 +0900201 AKLOGI("Total time is %6.3f ms.",
Ken Wakasa77e8e812012-08-02 19:48:08 +0900202 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900203 float all = 0.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900204 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
satok61e2f852011-01-05 14:13:07 +0900205 all += profile_buf[i];
206 }
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900207 if (all < 1.0f) all = 1.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900208 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900209 if (profile_buf[i] > 0.0f) {
satok9fb6f472012-01-13 18:01:22 +0900210 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900211 i, (profile_buf[i] * 100.0f / all),
Ken Wakasa77e8e812012-08-02 19:48:08 +0900212 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
213 profile_counter[i]);
Ken Wakasae90b3332011-01-07 15:01:51 +0900214 }
satok61e2f852011-01-05 14:13:07 +0900215 }
216}
217
satok20d9fda2011-07-13 14:40:30 +0900218#else // FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900219#define PROF_BUF_SIZE 0
220#define PROF_RESET
221#define PROF_COUNT(prof_buf_id)
222#define PROF_OPEN
223#define PROF_START(prof_buf_id)
224#define PROF_CLOSE
225#define PROF_END(prof_buf_id)
226#define PROF_CLOCK_OUT(prof_buf_id)
227#define PROF_CLOCKOUT(prof_buf_id)
228#define PROF_OUTALL
229
satok20d9fda2011-07-13 14:40:30 +0900230#endif // FLAG_DO_PROFILE
231
232#ifdef FLAG_DBG
satok20d9fda2011-07-13 14:40:30 +0900233#define DEBUG_DICT true
234#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900235#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900236#define DEBUG_NODE DEBUG_DICT_FULL
237#define DEBUG_TRACE DEBUG_DICT_FULL
satok1a6da632011-12-16 23:15:06 +0900238#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900239#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900240#define DEBUG_CORRECTION false
satok29dc8062012-01-17 15:59:15 +0900241#define DEBUG_CORRECTION_FREQ false
Satoshi Kataoka0ed8c6e2012-12-04 16:28:06 +0900242#define DEBUG_SAMPLING_POINTS false
243#define DEBUG_POINTS_PROBABILITY false
244#define DEBUG_DOUBLE_LETTER false
Satoshi Kataokabc25b802013-02-21 21:54:21 +0900245#define DEBUG_CACHE false
246#define DEBUG_DUMP_ERROR false
Satoshi Kataoka8b3009e2013-04-10 11:45:12 +0900247#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
satok20d9fda2011-07-13 14:40:30 +0900248
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900249#ifdef FLAG_FULL_DBG
250#define DEBUG_GEO_FULL true
251#else
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900252#define DEBUG_GEO_FULL false
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900253#endif
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900254
satok20d9fda2011-07-13 14:40:30 +0900255#else // FLAG_DBG
satok827ced82011-07-14 09:01:09 +0900256
satok20d9fda2011-07-13 14:40:30 +0900257#define DEBUG_DICT false
258#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900259#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900260#define DEBUG_NODE false
261#define DEBUG_TRACE false
262#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900263#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900264#define DEBUG_CORRECTION false
265#define DEBUG_CORRECTION_FREQ false
Keisuke Kuroyanagi806eba42012-10-09 19:57:08 +0900266#define DEBUG_SAMPLING_POINTS false
267#define DEBUG_POINTS_PROBABILITY false
Satoshi Kataoka9af53352012-11-16 23:06:41 +0900268#define DEBUG_DOUBLE_LETTER false
Satoshi Kataokabc25b802013-02-21 21:54:21 +0900269#define DEBUG_CACHE false
270#define DEBUG_DUMP_ERROR false
Satoshi Kataoka8b3009e2013-04-10 11:45:12 +0900271#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false
satok20d9fda2011-07-13 14:40:30 +0900272
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900273#define DEBUG_GEO_FULL false
274
satoke808e432010-12-02 14:53:24 +0900275#endif // FLAG_DBG
276
Jean Chalarda5d58492011-02-18 17:50:58 +0900277#ifndef S_INT_MAX
satok3c4bb772011-03-04 22:50:19 -0800278#define S_INT_MAX 2147483647 // ((1 << 31) - 1)
Jean Chalarda5d58492011-02-18 17:50:58 +0900279#endif
Jean Chalard592f2b32012-11-20 21:19:26 +0900280#ifndef S_INT_MIN
281// The literal constant -2147483648 does not work in C prior C90, because
282// the compiler tries to fit the positive number into an int and then negate it.
283// GCC warns about this.
284#define S_INT_MIN (-2147483647 - 1) // -(1 << 31)
285#endif
Satoshi Kataokaee62b782013-01-21 18:29:27 +0900286
Ken Wakasa6c224392013-01-22 13:14:53 +0900287#define M_PI_F 3.14159265f
Satoshi Kataokaee62b782013-01-21 18:29:27 +0900288#define MAX_PERCENTILE 100
289
Jean Chalard22025c62012-11-29 17:33:53 +0900290// Number of base-10 digits in the largest integer + 1 to leave room for a zero terminator.
291// As such, this is the maximum number of characters will be needed to represent an int as a
292// string, including the terminator; this is used as the size of a string buffer large enough to
293// hold any value that is intended to fit in an integer, e.g. in the code that reads the header
294// of the binary dictionary where a {key,value} string pair scheme is used.
295#define LARGEST_INT_DIGIT_COUNT 11
satok662fe692010-12-08 17:05:39 +0900296
Ken Wakasaf2789812012-09-04 12:49:46 +0900297#define NOT_A_CODE_POINT (-1)
298#define NOT_A_DISTANCE (-1)
299#define NOT_A_COORDINATE (-1)
Ken Wakasaf2789812012-09-04 12:49:46 +0900300#define NOT_AN_INDEX (-1)
301#define NOT_A_PROBABILITY (-1)
Keisuke Kuroynagi68e7edf2013-06-27 12:53:31 +0900302#define NOT_A_DICT_POS (S_INT_MIN)
Ken Wakasa2fa36932013-12-13 17:09:16 +0900303#define NOT_A_TIMESTAMP (-1)
Keisuke Kuroyanagide2b3122014-04-03 01:43:36 +0900304#define NOT_A_LANGUAGE_WEIGHT (-1.0f)
Jean Chalard459cd6f2013-10-01 17:30:40 +0900305
Jean Chalardbb570902013-09-30 21:39:43 +0900306// A special value to mean the first word confidence makes no sense in this case,
307// e.g. this is not a multi-word suggestion.
Keisuke Kuroyanagi8c5c01e2014-02-05 11:40:17 +0900308#define NOT_A_FIRST_WORD_CONFIDENCE (S_INT_MIN)
Jean Chalard459cd6f2013-10-01 17:30:40 +0900309// How high the confidence needs to be for us to auto-commit. Arbitrary.
310// This needs to be the same as CONFIDENCE_FOR_AUTO_COMMIT in BinaryDictionary.java
311#define CONFIDENCE_FOR_AUTO_COMMIT (1000000)
312// 80% of the full confidence
313#define DISTANCE_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
314// 100% of the full confidence
315#define LENGTH_WEIGHT_FOR_AUTO_COMMIT (CONFIDENCE_FOR_AUTO_COMMIT)
316// 80% of the full confidence
317#define SPACE_COUNT_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100)
satoke808e432010-12-02 14:53:24 +0900318
satok817e5172011-03-04 06:06:45 -0800319#define KEYCODE_SPACE ' '
Ken Wakasa1e614932012-10-29 18:06:22 +0900320#define KEYCODE_SINGLE_QUOTE '\''
321#define KEYCODE_HYPHEN_MINUS '-'
satok817e5172011-03-04 06:06:45 -0800322
Tom Ouyang31f7ece2013-02-21 15:42:05 -0800323#define SUGGEST_INTERFACE_OUTPUT_SCALE 1000000.0f
Satoshi Kataokae0e67372013-03-18 13:08:31 +0900324#define MAX_PROBABILITY 255
325#define MAX_BIGRAM_ENCODED_PROBABILITY 15
satoke808e432010-12-02 14:53:24 +0900326
Ken Wakasa9e0c7112012-08-09 22:26:58 +0900327// Assuming locale strings such as en_US, sr-Latn etc.
328#define MAX_LOCALE_STRING_LENGTH 10
329
Satoshi Kataoka830ba672013-03-05 14:12:06 +0900330// Max value for length, distance and probability which are used in weighting
331// TODO: Remove
332#define MAX_VALUE_FOR_WEIGHTING 10000000
Satoshi Kataoka687a2442012-08-23 15:46:43 +0900333
Keisuke Kuroyanagi95a49a52012-09-04 17:00:24 +0900334// The max number of the keys in one keyboard layout
335#define MAX_KEY_COUNT_IN_A_KEYBOARD 64
336
Ken Wakasa5150e152012-09-27 19:21:25 +0900337// TODO: Remove
Satoshi Kataokafe4f1ce2012-12-10 17:17:52 +0900338#define MAX_POINTER_COUNT 1
Satoshi Kataoka99eae8e2013-01-30 20:55:31 +0900339#define MAX_POINTER_COUNT_G 2
Ken Wakasa5150e152012-09-27 19:21:25 +0900340
Ken Wakasa2fa36932013-12-13 17:09:16 +0900341#define DISALLOW_DEFAULT_CONSTRUCTOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900342 TypeName() = delete
Ken Wakasa2fa36932013-12-13 17:09:16 +0900343
344#define DISALLOW_COPY_CONSTRUCTOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900345 TypeName(const TypeName&) = delete
Ken Wakasa2fa36932013-12-13 17:09:16 +0900346
347#define DISALLOW_ASSIGNMENT_OPERATOR(TypeName) \
Yohei Yukawa72c36292014-03-06 20:48:43 +0900348 void operator=(const TypeName&) = delete
satok1bc038c2012-06-14 11:25:50 -0700349
Ken Wakasa2fa36932013-12-13 17:09:16 +0900350#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
351 DISALLOW_COPY_CONSTRUCTOR(TypeName); \
352 DISALLOW_ASSIGNMENT_OPERATOR(TypeName)
353
satok1bc038c2012-06-14 11:25:50 -0700354#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
Ken Wakasa2fa36932013-12-13 17:09:16 +0900355 DISALLOW_DEFAULT_CONSTRUCTOR(TypeName); \
satok1bc038c2012-06-14 11:25:50 -0700356 DISALLOW_COPY_AND_ASSIGN(TypeName)
357
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900358// Used as a return value for character comparison
359typedef enum {
360 // Same char, possibly with different case or accent
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900361 MATCH_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900362 // It is a char located nearby on the keyboard
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900363 PROXIMITY_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900364 // Additional proximity char which can differ by language.
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900365 ADDITIONAL_PROXIMITY_CHAR,
366 // It is a substitution char
367 SUBSTITUTION_CHAR,
368 // It is an unrelated char
369 UNRELATED_CHAR,
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900370} ProximityType;
Satoshi Kataoka6ae8dd42012-11-22 20:15:40 +0900371
372typedef enum {
373 NOT_A_DOUBLE_LETTER,
374 A_DOUBLE_LETTER,
375 A_STRONG_DOUBLE_LETTER
376} DoubleLetterLevel;
Satoshi Kataokad8708912013-03-04 17:05:28 +0900377
378typedef enum {
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900379 // Correction for MATCH_CHAR
Satoshi Kataokad8708912013-03-04 17:05:28 +0900380 CT_MATCH,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900381 // Correction for PROXIMITY_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900382 CT_PROXIMITY,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900383 // Correction for ADDITIONAL_PROXIMITY_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900384 CT_ADDITIONAL_PROXIMITY,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900385 // Correction for SUBSTITUTION_CHAR
Satoshi Kataokaf4425aa2013-03-07 13:06:32 +0900386 CT_SUBSTITUTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900387 // Skip one omitted letter
Satoshi Kataokad8708912013-03-04 17:05:28 +0900388 CT_OMISSION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900389 // Delete an unnecessarily inserted letter
Satoshi Kataokad8708912013-03-04 17:05:28 +0900390 CT_INSERTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900391 // Swap the order of next two touch points
Satoshi Kataokad8708912013-03-04 17:05:28 +0900392 CT_TRANSPOSITION,
Satoshi Kataokad8708912013-03-04 17:05:28 +0900393 CT_COMPLETION,
394 CT_TERMINAL,
Satoshi Kataoka75322ce2013-06-14 18:40:59 +0900395 CT_TERMINAL_INSERTION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900396 // Create new word with space omission
Jean Chalardda06e382013-09-30 18:41:55 +0900397 CT_NEW_WORD_SPACE_OMISSION,
Keisuke Kuroynagi911f3262013-04-24 20:21:18 +0900398 // Create new word with space substitution
Satoshi Kataoka252412d2013-04-16 14:39:30 +0900399 CT_NEW_WORD_SPACE_SUBSTITUTION,
Satoshi Kataokad8708912013-03-04 17:05:28 +0900400} CorrectionType;
satoke808e432010-12-02 14:53:24 +0900401#endif // LATINIME_DEFINES_H