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_DBG) 27#undef AK_FORCE_INLINE 28#define AK_FORCE_INLINE inline 29#endif // 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. 42template <typename T, int N> 43char (&ArraySizeHelper(T (&array)[N]))[N]; 44#define NELEMS(x) (sizeof(ArraySizeHelper(x))) 45 46AK_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 118static 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 > 0) { 123 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, probability); 124 } 125} 126 127static 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 144static 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_DBG 176#define DEBUG_DICT true 177#define DEBUG_DICT_FULL false 178#define DEBUG_EDIT_DISTANCE false 179#define DEBUG_NODE DEBUG_DICT_FULL 180#define DEBUG_TRACE DEBUG_DICT_FULL 181#define DEBUG_PROXIMITY_INFO false 182#define DEBUG_PROXIMITY_CHARS false 183#define DEBUG_CORRECTION false 184#define DEBUG_CORRECTION_FREQ false 185#define DEBUG_SAMPLING_POINTS false 186#define DEBUG_POINTS_PROBABILITY false 187#define DEBUG_DOUBLE_LETTER false 188#define DEBUG_CACHE false 189#define DEBUG_DUMP_ERROR false 190#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false 191 192#ifdef FLAG_FULL_DBG 193#define DEBUG_GEO_FULL true 194#else 195#define DEBUG_GEO_FULL false 196#endif 197 198#else // FLAG_DBG 199 200#define DEBUG_DICT false 201#define DEBUG_DICT_FULL false 202#define DEBUG_EDIT_DISTANCE false 203#define DEBUG_NODE false 204#define DEBUG_TRACE false 205#define DEBUG_PROXIMITY_INFO false 206#define DEBUG_PROXIMITY_CHARS false 207#define DEBUG_CORRECTION false 208#define DEBUG_CORRECTION_FREQ false 209#define DEBUG_SAMPLING_POINTS false 210#define DEBUG_POINTS_PROBABILITY false 211#define DEBUG_DOUBLE_LETTER false 212#define DEBUG_CACHE false 213#define DEBUG_DUMP_ERROR false 214#define DEBUG_EVALUATE_MOST_PROBABLE_STRING false 215 216#define DEBUG_GEO_FULL false 217 218#endif // FLAG_DBG 219 220#ifndef S_INT_MAX 221#define S_INT_MAX 2147483647 // ((1 << 31) - 1) 222#endif 223#ifndef S_INT_MIN 224// The literal constant -2147483648 does not work in C prior C90, because 225// the compiler tries to fit the positive number into an int and then negate it. 226// GCC warns about this. 227#define S_INT_MIN (-2147483647 - 1) // -(1 << 31) 228#endif 229 230#define M_PI_F 3.14159265f 231#define MAX_PERCENTILE 100 232 233#define NOT_A_CODE_POINT (-1) 234#define NOT_A_DISTANCE (-1) 235#define NOT_A_COORDINATE (-1) 236#define NOT_AN_INDEX (-1) 237#define NOT_A_PROBABILITY (-1) 238#define NOT_A_DICT_POS (S_INT_MIN) 239#define NOT_A_WORD_ID (S_INT_MIN) 240#define NOT_A_TIMESTAMP (-1) 241#define NOT_A_WEIGHT_OF_LANG_MODEL_VS_SPATIAL_MODEL (-1.0f) 242 243// A special value to mean the first word confidence makes no sense in this case, 244// e.g. this is not a multi-word suggestion. 245#define NOT_A_FIRST_WORD_CONFIDENCE (S_INT_MIN) 246// How high the confidence needs to be for us to auto-commit. Arbitrary. 247// This needs to be the same as CONFIDENCE_FOR_AUTO_COMMIT in BinaryDictionary.java 248#define CONFIDENCE_FOR_AUTO_COMMIT (1000000) 249// 80% of the full confidence 250#define DISTANCE_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100) 251// 100% of the full confidence 252#define LENGTH_WEIGHT_FOR_AUTO_COMMIT (CONFIDENCE_FOR_AUTO_COMMIT) 253// 80% of the full confidence 254#define SPACE_COUNT_WEIGHT_FOR_AUTO_COMMIT (80 * CONFIDENCE_FOR_AUTO_COMMIT / 100) 255 256#define KEYCODE_SPACE ' ' 257#define KEYCODE_SINGLE_QUOTE '\'' 258#define KEYCODE_HYPHEN_MINUS '-' 259// Code point to indicate beginning-of-sentence. This is not in the code point space of unicode. 260#define CODE_POINT_BEGINNING_OF_SENTENCE 0x110000 261 262#define SUGGEST_INTERFACE_OUTPUT_SCALE 1000000.0f 263#define MAX_PROBABILITY 255 264#define MAX_BIGRAM_ENCODED_PROBABILITY 15 265 266// Max value for length, distance and probability which are used in weighting 267// TODO: Remove 268#define MAX_VALUE_FOR_WEIGHTING 10000000 269 270// The max number of the keys in one keyboard layout 271#define MAX_KEY_COUNT_IN_A_KEYBOARD 64 272 273// TODO: Remove 274#define MAX_POINTER_COUNT 1 275#define MAX_POINTER_COUNT_G 2 276 277// (MAX_PREV_WORD_COUNT_FOR_N_GRAM + 1)-gram is supported. 278#define MAX_PREV_WORD_COUNT_FOR_N_GRAM 3 279 280#define DISALLOW_DEFAULT_CONSTRUCTOR(TypeName) \ 281 TypeName() = delete 282 283#define DISALLOW_COPY_CONSTRUCTOR(TypeName) \ 284 TypeName(const TypeName&) = delete 285 286#define DISALLOW_ASSIGNMENT_OPERATOR(TypeName) \ 287 void operator=(const TypeName&) = delete 288 289#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 290 DISALLOW_COPY_CONSTRUCTOR(TypeName); \ 291 DISALLOW_ASSIGNMENT_OPERATOR(TypeName) 292 293#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ 294 DISALLOW_DEFAULT_CONSTRUCTOR(TypeName); \ 295 DISALLOW_COPY_AND_ASSIGN(TypeName) 296 297// Used as a return value for character comparison 298typedef enum { 299 // Same char, possibly with different case or accent 300 MATCH_CHAR, 301 // It is a char located nearby on the keyboard 302 PROXIMITY_CHAR, 303 // Additional proximity char which can differ by language. 304 ADDITIONAL_PROXIMITY_CHAR, 305 // It is a substitution char 306 SUBSTITUTION_CHAR, 307 // It is an unrelated char 308 UNRELATED_CHAR, 309} ProximityType; 310 311typedef enum { 312 NOT_A_DOUBLE_LETTER, 313 A_DOUBLE_LETTER, 314 A_STRONG_DOUBLE_LETTER 315} DoubleLetterLevel; 316 317typedef enum { 318 // Correction for MATCH_CHAR 319 CT_MATCH, 320 // Correction for PROXIMITY_CHAR 321 CT_PROXIMITY, 322 // Correction for ADDITIONAL_PROXIMITY_CHAR 323 CT_ADDITIONAL_PROXIMITY, 324 // Correction for SUBSTITUTION_CHAR 325 CT_SUBSTITUTION, 326 // Skip one omitted letter 327 CT_OMISSION, 328 // Delete an unnecessarily inserted letter 329 CT_INSERTION, 330 // Swap the order of next two touch points 331 CT_TRANSPOSITION, 332 CT_COMPLETION, 333 CT_TERMINAL, 334 CT_TERMINAL_INSERTION, 335 // Create new word with space omission 336 CT_NEW_WORD_SPACE_OMISSION, 337 // Create new word with space substitution 338 CT_NEW_WORD_SPACE_SUBSTITUTION, 339} CorrectionType; 340#endif // LATINIME_DEFINES_H 341