boolean LoadTableDict(TableMetaData* tableMetaData)
{
char strCode[MAX_CODE_LENGTH + 1];
char *strHZ = 0;
FILE *fpDict;
RECORD *recTemp;
unsigned int i = 0;
uint32_t iTemp, iTempCount;
char cChar = 0, cTemp;
int8_t iVersion = 1;
int iRecordIndex;
TableDict *tableDict;
//读入码表
FcitxLog(DEBUG, _("Loading Table Dict"));
int reload = 0;
do {
boolean error = false;
if (!reload) {
/**
* kcm saves a absolute path here but it is then interpreted as
* a relative path?
**/
fpDict = FcitxXDGGetFileWithPrefix("table", tableMetaData->strPath,
"r", NULL);
} else {
char *tablepath;
char *path = fcitx_utils_get_fcitx_path("pkgdatadir");
fcitx_utils_alloc_cat_str(tablepath, path, "/table/",
tableMetaData->strPath);
fpDict = fopen(tablepath, "r");
free(tablepath);
}
if (!fpDict)
return false;
tableMetaData->tableDict = fcitx_utils_new(TableDict);
tableDict = tableMetaData->tableDict;
tableDict->pool = fcitx_memory_pool_create();
#define CHECK_LOAD_TABLE_ERROR(SIZE) if (size < (SIZE)) { error = true; goto table_load_error; }
//先读取码表的信息
//判断版本信息
size_t size;
size = fcitx_utils_read_uint32(fpDict, &iTemp);
CHECK_LOAD_TABLE_ERROR(1);
if (!iTemp) {
size = fread(&iVersion, sizeof(int8_t), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
iVersion = (iVersion < INTERNAL_VERSION);
size = fcitx_utils_read_uint32(fpDict, &iTemp);
CHECK_LOAD_TABLE_ERROR(1);
}
tableDict->strInputCode = (char*)realloc(tableDict->strInputCode, sizeof(char) * (iTemp + 1));
size = fread(tableDict->strInputCode, sizeof(char), iTemp + 1, fpDict);
CHECK_LOAD_TABLE_ERROR(iTemp + 1);
/*
* 建立索引，加26是为了为拼音编码预留空间
*/
size_t tmp_len = strlen(tableDict->strInputCode) + 26;
tableDict->recordIndex = (RECORD_INDEX*)fcitx_memory_pool_alloc(tableDict->pool, tmp_len * sizeof(RECORD_INDEX));
for (iTemp = 0; iTemp < tmp_len; iTemp++) {
tableDict->recordIndex[iTemp].cCode = 0;
tableDict->recordIndex[iTemp].record = NULL;
}
/********************************************************************/
size = fread(&(tableDict->iCodeLength), sizeof(uint8_t), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
UpdateTableMetaData(tableMetaData);
if (!iVersion) {
size = fread(&(tableDict->iPYCodeLength), sizeof(uint8_t), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
}
else
tableDict->iPYCodeLength = tableDict->iCodeLength;
size = fcitx_utils_read_uint32(fpDict, &iTemp);
CHECK_LOAD_TABLE_ERROR(1);
tableDict->strIgnoreChars = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (iTemp + 1));
size = fread(tableDict->strIgnoreChars, sizeof(char), iTemp + 1, fpDict);
CHECK_LOAD_TABLE_ERROR(iTemp + 1);
size = fread(&(tableDict->bRule), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
if (tableDict->bRule) { //表示有组词规则
tableDict->rule = (RULE*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(RULE) * (tableDict->iCodeLength - 1));
for (i = 0; i < tableDict->iCodeLength - 1; i++) {
size = fread(&(tableDict->rule[i].iFlag), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
size = fread(&(tableDict->rule[i].iWords), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
tableDict->rule[i].rule = (RULE_RULE*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(RULE_RULE) * tableDict->iCodeLength);
for (iTemp = 0; iTemp < tableDict->iCodeLength; iTemp++) {
size = fread(&(tableDict->rule[i].rule[iTemp].iFlag), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
size = fread(&(tableDict->rule[i].rule[iTemp].iWhich), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
size = fread(&(tableDict->rule[i].rule[iTemp].iIndex), sizeof(unsigned char), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
}
}
}
tableDict->recordHead = (RECORD*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(RECORD));
tableDict->currentRecord = tableDict->recordHead;
size = fcitx_utils_read_uint32(fpDict, &tableDict->iRecordCount);
CHECK_LOAD_TABLE_ERROR(1);
for (i = 0; i < SINGLE_HZ_COUNT; i++) {
tableDict->tableSingleHZ[i] = (RECORD*)NULL;
tableDict->tableSingleHZCons[i] = (RECORD*)NULL;
}
iRecordIndex = 0;
size_t bufSize = 0;
for (i = 0; i < tableDict->iRecordCount; i++) {
size = fread(strCode, sizeof(int8_t), tableDict->iPYCodeLength + 1, fpDict);
CHECK_LOAD_TABLE_ERROR(tableDict->iPYCodeLength + 1);
size = fcitx_utils_read_uint32(fpDict, &iTemp);
CHECK_LOAD_TABLE_ERROR(1);
/* we don't actually have such limit, but sometimes, broken table
* may break this, so we need to give a limitation.
*/
if (iTemp > UTF8_MAX_LENGTH * 30) {
error = true;
goto table_load_error;
}
if (iTemp > bufSize) {
bufSize = iTemp;
strHZ = realloc(strHZ, bufSize);
}
size = fread(strHZ, sizeof(int8_t), iTemp, fpDict);
CHECK_LOAD_TABLE_ERROR(iTemp);
recTemp = (RECORD*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(RECORD));
recTemp->strCode = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (tableDict->iPYCodeLength + 1));
memset(recTemp->strCode, 0, sizeof(char) * (tableDict->iPYCodeLength + 1));
strcpy(recTemp->strCode, strCode);
recTemp->strHZ = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * iTemp);
strcpy(recTemp->strHZ, strHZ);
if (!iVersion) {
size = fread(&cTemp, sizeof(int8_t), 1, fpDict);
CHECK_LOAD_TABLE_ERROR(1);
recTemp->type = cTemp;
}
size = fcitx_utils_read_uint32(fpDict, &recTemp->iHit);
CHECK_LOAD_TABLE_ERROR(1);
size = fcitx_utils_read_uint32(fpDict, &recTemp->iIndex);
CHECK_LOAD_TABLE_ERROR(1);
if (recTemp->iIndex > tableDict->iTableIndex)
tableDict->iTableIndex = recTemp->iIndex;
/* 建立索引 */
if (cChar != recTemp->strCode[0]) {
cChar = recTemp->strCode[0];
tableDict->recordIndex[iRecordIndex].cCode = cChar;
tableDict->recordIndex[iRecordIndex].record = recTemp;
iRecordIndex++;
}
/******************************************************************/
/** 为单字生成一个表 */
if (fcitx_utf8_strlen(recTemp->strHZ) == 1 && !IsIgnoreChar(tableDict, strCode[0]))
{
RECORD** tableSingleHZ = NULL;
if (recTemp->type == RECORDTYPE_NORMAL)
tableSingleHZ = tableDict->tableSingleHZ;
else if (recTemp->type == RECORDTYPE_CONSTRUCT)
tableSingleHZ = tableDict->tableSingleHZCons;
if (tableSingleHZ) {
iTemp = CalHZIndex(recTemp->strHZ);
if (iTemp < SINGLE_HZ_COUNT) {
if (tableSingleHZ[iTemp]) {
if (strlen(strCode) > strlen(tableDict->tableSingleHZ[iTemp]->strCode))
tableSingleHZ[iTemp] = recTemp;
} else
tableSingleHZ[iTemp] = recTemp;
}
}
}
if (recTemp->type == RECORDTYPE_PINYIN)
tableDict->bHasPinyin = true;
if (recTemp->type == RECORDTYPE_PROMPT && strlen(recTemp->strCode) == 1)
tableDict->promptCode[(uint8_t) recTemp->strCode[0]] = recTemp;
tableDict->currentRecord->next = recTemp;
recTemp->prev = tableDict->currentRecord;
tableDict->currentRecord = recTemp;
}
if (strHZ) {
free(strHZ);
strHZ = NULL;
}
tableDict->currentRecord->next = tableDict->recordHead;
tableDict->recordHead->prev = tableDict->currentRecord;
table_load_error:
fclose(fpDict);
if (error) {
fcitx_memory_pool_destroy(tableDict->pool);
tableDict->pool = NULL;
reload++;
} else {
break;
}
} while(reload < 2);
if (!tableDict->pool)
return false;
FcitxLog(DEBUG, _("Load Table Dict OK"));
//读取相应的特殊符号表
fpDict = FcitxXDGGetFileWithPrefix("table", tableMetaData->strSymbolFile, "r", NULL);
if (fpDict) {
tableDict->iFH = fcitx_utils_calculate_record_number(fpDict);
tableDict->fh = (FH*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(FH) * tableDict->iFH);
char* strBuf = NULL;
size_t bufLen = 0;
for (i = 0; i < tableDict->iFH; i++) {
if (getline(&strBuf, &bufLen, fpDict) == -1)
break;
if (!fcitx_utf8_check_string(strBuf))
break;
if (fcitx_utf8_strlen(strBuf) > FH_MAX_LENGTH)
break;
strcpy(tableDict->fh[i].strFH, strBuf);
}
fcitx_utils_free(strBuf);
tableDict->iFH = i;
fclose(fpDict);
}
tableDict->strNewPhraseCode = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (tableDict->iCodeLength + 1));
tableDict->strNewPhraseCode[tableDict->iCodeLength] = '\0';
tableDict->iAutoPhrase = 0;
if (tableMetaData->bAutoPhrase) {
tableDict->autoPhrase = (AUTOPHRASE*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(AUTOPHRASE) * AUTO_PHRASE_COUNT);
//读取上次保存的自动词组信息
FcitxLog(DEBUG, _("Loading Autophrase."));
char *temppath;
fcitx_utils_alloc_cat_str(temppath, tableMetaData->uniqueName,
"_LastAutoPhrase.tmp");
fpDict = FcitxXDGGetFileWithPrefix("table", temppath, "r", NULL);
free(temppath);
i = 0;
if (fpDict) {
size_t size = fcitx_utils_read_int32(fpDict, &tableDict->iAutoPhrase);
if (size == 1) {
for (; i < tableDict->iAutoPhrase; i++) {
tableDict->autoPhrase[i].strCode = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (tableDict->iCodeLength + 1));
tableDict->autoPhrase[i].strHZ = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (PHRASE_MAX_LENGTH * UTF8_MAX_LENGTH + 1));
size = fread(tableDict->autoPhrase[i].strCode, tableDict->iCodeLength + 1, 1, fpDict);
if (size != 1) {
tableDict->iAutoPhrase = i;
break;
}
size = fread(tableDict->autoPhrase[i].strHZ, PHRASE_MAX_LENGTH * UTF8_MAX_LENGTH + 1, 1, fpDict);
tableDict->autoPhrase[i].strHZ[PHRASE_MAX_LENGTH * UTF8_MAX_LENGTH] = 0;
if (size != 1 || !fcitx_utf8_check_string(tableDict->autoPhrase[i].strHZ)) {
tableDict->iAutoPhrase = i;
break;
}
size = fcitx_utils_read_uint32(fpDict, &iTempCount);
if (size != 1) {
tableDict->iAutoPhrase = i;
break;
}
tableDict->autoPhrase[i].iSelected = iTempCount;
if (i == AUTO_PHRASE_COUNT - 1)
tableDict->autoPhrase[i].next = &tableDict->autoPhrase[0];
else
tableDict->autoPhrase[i].next = &tableDict->autoPhrase[i + 1];
}
}
fclose(fpDict);
}
for (; i < AUTO_PHRASE_COUNT; i++) {
tableDict->autoPhrase[i].strCode = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (tableDict->iCodeLength + 1));
tableDict->autoPhrase[i].strHZ = (char*)fcitx_memory_pool_alloc(tableDict->pool, sizeof(char) * (PHRASE_MAX_LENGTH * UTF8_MAX_LENGTH + 1));
tableDict->autoPhrase[i].iSelected = 0;
if (i == AUTO_PHRASE_COUNT - 1)
tableDict->autoPhrase[i].next = &tableDict->autoPhrase[0];
else
tableDict->autoPhrase[i].next = &tableDict->autoPhrase[i + 1];
}
if (i == AUTO_PHRASE_COUNT)
tableDict->insertPoint = &tableDict->autoPhrase[0];
else
tableDict->insertPoint = &tableDict->autoPhrase[i - 1];
FcitxLog(DEBUG, _("Load Autophrase OK"));
} else
tableDict->autoPhrase = (AUTOPHRASE *) NULL;
return true;
}
int main (int argc, char* argv[])
{
char *servicename = NULL;
char *address = NULL;
DBusMessage* message = NULL;
DBusConnection* conn = NULL;
int c;
int ret = 1;
int messageType = FCITX_DBUS_GET_CURRENT_STATE;
char *imname = NULL;
while ((c = getopt(argc, argv, "chortTeam:")) != -1) {
switch (c) {
case 'o':
messageType = FCITX_DBUS_ACTIVATE;
break;
case 'c':
messageType = FCITX_DBUS_INACTIVATE;
break;
case 'r':
messageType = FCITX_DBUS_RELOAD_CONFIG;
break;
case 't':
case 'T':
messageType = FCITX_DBUS_TOGGLE;
break;
case 'e':
messageType = FCITX_DBUS_EXIT;
break;
case 'm':
messageType = FCITX_DBUS_GET_IM_ADDON;
imname = strdup(optarg);
break;
case 'a':
address = _fcitx_get_address();
if (address) {
printf("%s\n", address);
return 0;
}
else
return 1;
break;
case 'h':
usage(stdout);
return 0;
default:
usage(stderr);
return 1;
break;
}
}
#define CASE(ENUMNAME, MESSAGENAME) \
case FCITX_DBUS_##ENUMNAME: \
message = dbus_message_new_method_call(servicename, FCITX_IM_DBUS_PATH, FCITX_IM_DBUS_INTERFACE, #MESSAGENAME); \
break;
asprintf(&servicename, "%s-%d", FCITX_DBUS_SERVICE, fcitx_utils_get_display_number());
switch(messageType) {
CASE(ACTIVATE, ActivateIM);
CASE(INACTIVATE, InactivateIM);
CASE(RELOAD_CONFIG, ReloadConfig);
CASE(EXIT, Exit);
CASE(TOGGLE, ToggleIM);
CASE(GET_CURRENT_STATE, GetCurrentState);
CASE(GET_IM_ADDON, GetIMAddon);
default:
goto some_error;
};
if (!message) {
goto some_error;
}
address = _fcitx_get_address();
do {
if (!address)
break;
conn = dbus_connection_open(address, NULL);
if (!conn)
break;
if (!dbus_bus_register(conn, NULL)) {
dbus_connection_unref(conn);
conn = NULL;
break;
}
} while(0);
if (!conn) {
conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
if (!conn) {
goto some_error;
}
dbus_connection_set_exit_on_disconnect(conn, FALSE);
}
if (messageType == FCITX_DBUS_GET_CURRENT_STATE) {
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
int result = 0;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID)) {
printf("%d\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
}
else if (messageType == FCITX_DBUS_GET_IM_ADDON) {
do {
if (!fcitx_utf8_check_string(imname))
break;
dbus_message_append_args(message, DBUS_TYPE_STRING, &imname, DBUS_TYPE_INVALID);
DBusMessage* reply = dbus_connection_send_with_reply_and_block(conn, message, 1000, NULL);
char *result = NULL;
if (reply && dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &result, DBUS_TYPE_INVALID)) {
printf("%s\n", result);
ret = 0;
} else {
fprintf(stderr, "Not get reply\n");
}
} while(0);
} else {
dbus_connection_send(conn, message, NULL);
dbus_connection_flush(conn);
ret = 0;
}
some_error:
if (message)
dbus_message_unref(message);
if (conn)
dbus_connection_unref(conn);
fcitx_utils_free(address);
fcitx_utils_free(servicename);
fcitx_utils_free(imname);
return ret;
}
char* BaiduParsePinyin(FcitxCloudPinyin* cloudpinyin, CurlQueue* queue)
{
char *start = NULL, *end = NULL;
static iconv_t conv = 0;
if (conv == 0)
conv = iconv_open("utf-8", "utf-16be");
if (conv == (iconv_t)(-1))
return NULL;
if ((start = strstr(queue->str, "[[[\"")) != NULL)
{
start += strlen( "[[[\"");
if ((end = strstr(start, "\",")) != NULL)
{
size_t length = end - start;
if (length % 6 != 0 || length == 0)
return NULL;
size_t i = 0, j = 0;
char* buf = fcitx_utils_malloc0((length / 6 + 1) * 2);
while (i < length)
{
if (start[i] == '\\' && start[i+1] == 'u')
{
if (ishex(start[i+2]) && ishex(start[i+3]) && ishex(start[i+4]) && ishex(start[i+5]))
{
buf[j++] = (tohex(start[i+2]) << 4) | tohex(start[i+3]);
buf[j++] = (tohex(start[i+4]) << 4) | tohex(start[i+5]);
}
else
break;
}
i += 6;
}
if (i != length)
{
free(buf);
return NULL;
}
buf[j++] = 0;
buf[j++] = 0;
size_t len = UTF8_MAX_LENGTH * (length / 6) * sizeof(char);
char* realstring = fcitx_utils_malloc0(UTF8_MAX_LENGTH * (length / 6) * sizeof(char));
IconvStr p = buf;
char *pp = realstring;
iconv(conv, &p, &j, &pp, &len);
free(buf);
if (fcitx_utf8_check_string(realstring))
return realstring;
else
{
free(realstring);
return NULL;
}
}
}
return NULL;
}
