feat(capi): load embedded mini dictionary if system dictionaries were…

… not found

capi/src/io.rs

@@ -10,15 +10,18 @@ use std::{
 
 use chewing::{
     conversion::{ChewingEngine, Interval, SimpleEngine, Symbol},
-    dictionary::{Layered, SystemDictionaryLoader, UserDictionaryLoader},
+    dictionary::{
+        Dictionary, Layered, LoadDictionaryError, SystemDictionaryLoader, Trie,
+        UserDictionaryLoader,
+    },
     editor::{
         keyboard::{AnyKeyboardLayout, KeyCode, KeyboardLayout, Modifiers, Qwerty},
         zhuyin_layout::{
             DaiChien26, Et, Et26, GinYieh, Hsu, Ibm, KeyboardLayoutCompat, Pinyin, Standard,
             SyllableEditor,
         },
-        BasicEditor, CharacterForm, ConversionEngineKind, Editor, EditorKeyBehavior, LanguageMode,
-        LaxUserFreqEstimate, UserPhraseAddDirection,
+        AbbrevTable, BasicEditor, CharacterForm, ConversionEngineKind, Editor, EditorKeyBehavior,
+        LanguageMode, LaxUserFreqEstimate, SymbolSelector, UserPhraseAddDirection,
     },
     zhuyin::Syllable,
 };
@@ -130,24 +133,35 @@ pub unsafe extern "C" fn chewing_new2(
     let dictionaries = match dictionaries {
         Ok(d) => d,
         Err(e) => {
+            let builtin = Trie::new(&include_bytes!("../../data/mini.dat")[..]);
             error!("Failed to load system dict: {e}");
-            return null_mut();
+            error!("Loading builtin minimum dictionary...");
+            if builtin.is_err() {
+                error!(
+                    "Unable to load builtin dictionary: {}",
+                    builtin.unwrap_err()
+                );
+                return null_mut();
+            }
+            vec![Box::new(builtin.unwrap()) as Box<dyn Dictionary>]
         }
     };
     let abbrev = sys_loader.load_abbrev();
     let abbrev = match abbrev {
         Ok(abbr) => abbr,
         Err(e) => {
             error!("Failed to load abbrev table: {e}");
-            return null_mut();
+            error!("Loading empty table...");
+            AbbrevTable::new()
         }
     };
     let sym_sel = sys_loader.load_symbol_selector();
     let sym_sel = match sym_sel {
         Ok(sym_sel) => sym_sel,
         Err(e) => {
             error!("Failed to load symbol table: {e}");
-            return null_mut();
+            error!("Loading empty table...");
+            SymbolSelector::new(b"".as_slice()).unwrap()
         }
     };
     let user_dictionary = if userpath.is_null() {