static void ClipboardInitReadHistory(FcitxClipboard *clipboard) { FILE *fp; if (!clipboard->config.save_history) return; fp = FcitxXDGGetFileUserWithPrefix("clipboard", "history.dat", "r", NULL); if (!fp) return; uint32_t len; if (!fcitx_utils_read_uint32(fp, &len)) goto out; fcitx_utils_read_uint32(fp, &clipboard->primary.len); if (len > (uint32_t)clipboard->config.history_len) { clipboard->clp_hist_len = clipboard->config.history_len; } else { clipboard->clp_hist_len = len; } ClipboardSelectionStr *clp_hist_lst = clipboard->clp_hist_lst; unsigned int i; for (i = 0;i < clipboard->clp_hist_len;i++) { fcitx_utils_read_uint32(fp, &clp_hist_lst[i].len); } if (fseek(fp, (len + 2) * sizeof(uint32_t), SEEK_SET) < 0) { clipboard->clp_hist_len = 0; clipboard->primary.len = 0; goto out; } clipboard->primary.str = malloc(clipboard->primary.len + 1); fread(clipboard->primary.str, 1, clipboard->primary.len, fp); clipboard->primary.str[clipboard->primary.len] = '\0'; for (i = 0;i < clipboard->clp_hist_len;i++) { clp_hist_lst[i].str = malloc(clp_hist_lst[i].len + 1); fread(clp_hist_lst[i].str, 1, clp_hist_lst[i].len, fp); clp_hist_lst[i].str[clp_hist_lst[i].len] = '\0'; } out: fclose(fp); }
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 strCode[100]; char strHZ[UTF8_MAX_LENGTH * 31]; FILE *fpDict; unsigned int i = 0; uint32_t iTemp; uint32_t j; unsigned char iLen; unsigned char iRule; unsigned char iPYLen; char iVersion = 0; boolean old = false; const char** templ = NULL; int c; while ((c = getopt(argc, argv, "oh")) != -1) { switch (c) { case 'o': old = true; break; case 'h': default: usage(); } } templ = old ? templateOld : templateNew; if (optind + 1 != argc) { usage(); } fpDict = fopen(argv[optind], "r"); if (!fpDict) { printf("\nCannot read source file!\n\n"); exit(2); } //先读取码表的信息 fcitx_utils_read_uint32(fpDict, &iTemp); if (iTemp == 0) { fread(&iVersion, sizeof(char), 1, fpDict); printf(templ[TEMPL_VERNEW], iVersion); fcitx_utils_read_uint32(fpDict, &iTemp); } else printf("%s", templ[TEMPL_VEROLD]); fread(strCode, sizeof(char), iTemp + 1, fpDict); printf(templ[TEMPL_KEYCODE], strCode); char cPinyin = '\0'; fread(&iLen, sizeof(unsigned char), 1, fpDict); printf(templ[TEMPL_LEN], iLen); if (iVersion) { fread(&iPYLen, sizeof(unsigned char), 1, fpDict); if (iPYLen) { cPinyin = guessValidChar('@', strCode); printf(templ[TEMPL_PY], cPinyin); printf(templ[TEMPL_PYLEN], iPYLen); } } char* temp = malloc(strlen(strCode) * sizeof(char) + 3); strcpy(temp, strCode); char pyStr[] = {cPinyin, '\0'}; strcat(temp, pyStr); char cPrompt = guessValidChar('&', temp); char prStr[] = {cPrompt, '\0'}; strcat(temp, prStr); char cPhrase = guessValidChar('^', temp); free(temp); if (cPrompt == 0) { printf("%s", templ[TEMPL_PROMPT2]); } else { printf(templ[TEMPL_PROMPT], cPrompt); } if (cPhrase == 0) { printf("%s", templ[TEMPL_CONSTRUCTPHRASE2]); } else { printf(templ[TEMPL_CONSTRUCTPHRASE], cPhrase); } fcitx_utils_read_uint32(fpDict, &iTemp); fread(strCode, sizeof(char), iTemp + 1, fpDict); if (iTemp) printf(templ[TEMPL_INVALIDCHAR], strCode); fread(&iRule, sizeof(unsigned char), 1, fpDict); if (iRule) { //表示有组词规则 printf("%s", templ[TEMPL_RULE]); for (i = 0; i < iLen - 1; i++) { fread(&iRule, sizeof(unsigned char), 1, fpDict); printf("%c", (iRule) ? 'a' : 'e'); fread(&iRule, sizeof(unsigned char), 1, fpDict); printf("%d=", iRule); for (iTemp = 0; iTemp < iLen; iTemp++) { fread(&iRule, sizeof(unsigned char), 1, fpDict); printf("%c", (iRule) ? 'p' : 'n'); fread(&iRule, sizeof(unsigned char), 1, fpDict); printf("%d", iRule); fread(&iRule, sizeof(unsigned char), 1, fpDict); printf("%d", iRule); if (iTemp != (iLen - 1)) printf("+"); } printf("\n"); } } printf("%s", templ[TEMPL_DATA]); fcitx_utils_read_uint32(fpDict, &j); if (iVersion) iLen = iPYLen; for (i = 0; i < j; i++) { fread(strCode, sizeof(char), iLen + 1, fpDict); fcitx_utils_read_uint32(fpDict, &iTemp); if (iTemp > UTF8_MAX_LENGTH * 30) break; fread(strHZ, sizeof(unsigned char), iTemp, fpDict); if (iVersion) { fread(&iRule, sizeof(unsigned char), 1, fpDict); if (iRule == RECORDTYPE_PINYIN) printf("%c%s %s\n", cPinyin, strCode, strHZ); else if (iRule == RECORDTYPE_CONSTRUCT) { if (cPhrase == 0) { fprintf(stderr, "Could not find a valid char for construct phrase\n"); exit(1); } else printf("%c%s %s\n", cPhrase, strCode, strHZ); } else if (iRule == RECORDTYPE_PROMPT) if (cPrompt == 0) { fprintf(stderr, "Could not find a valid char for prompt\n"); exit(1); } else printf("%c%s %s\n", cPrompt, strCode, strHZ); else printf("%s %s\n", strCode, strHZ); } fcitx_utils_read_uint32(fpDict, &iTemp); fcitx_utils_read_uint32(fpDict, &iTemp); } fclose(fpDict); return 0; }