sekka 0.8.8 → 0.9.0

data/bin/sekka-jisyo

@@ -55,7 +55,10 @@ core.evalStr( <<";;END-OF-SCRIPT" )
   (with-open
    sekka-file
    (lambda (f)
-     (load-sekka-jisyo-f f target))))
+     (load-sekka-jisyo-f
+      f
+      (target.gsub #/[.]db$/ "") ;; drop ".db" suffix
+      ))))
 
 
 (define (dump-sekka-jisyo sekka-file)
@@ -65,9 +68,19 @@ core.evalStr( <<";;END-OF-SCRIPT" )
 (define (display-help)
   (print "Usage : ")
   (print "  sekka-jisyo convert SKK-JISYO.X  > SEKKA-JISYO.X       ... output SEKKA-JISYO to STDOUT")
-  (print "  sekka-jisyo load    SEKKA-JISYO.X  SEKKA-JISYO.X.tch   ... load   SEKKA-JISYO to DB(*.tch)")
-  (print "  sekka-jisyo dump    SEKKA-JISYO.X.tch                  ... dump   DB(*.tch) to SEKKA-JISYO(STDOUT)"))
+  (print "  sekka-jisyo load    SEKKA-JISYO.X  SEKKA-JISYO.X.tch   ... load   SEKKA-JISYO to Tokyo Cabinet DB")
+  (print "  sekka-jisyo load    SEKKA-JISYO.X  SEKKA-JISYO.X.db    ... load   SEKKA-JISYO to ndbm          DB")
+  (print "  sekka-jisyo dump    SEKKA-JISYO.X.tch                  ... dump   Tokyo Cabinet DB to SEKKA-JISYO(STDOUT)")
+  (print "  sekka-jisyo dump    SEKKA-JISYO.X.db                   ... dump   ndbm          DB to SEKKA-JISYO(STDOUT)"))
 
+(define (analyze-kvs-type filename)
+  (cond
+   ((rxmatch #/[.]tch$/ filename)
+    'tokyocabinet)
+   ((rxmatch #/[.]db$/ filename)
+    'dbm)
+   (else
+    (errorf "Error: analyze-kvs-type() got unsupported filename [%s] \n" filename))))
 
 (define (main argv)
   (cond
@@ -81,13 +94,17 @@ core.evalStr( <<";;END-OF-SCRIPT" )
             (display-help)
             (convert-skk-jisyo (second argv))))
        ((eq? 'load command)
-        (if (< (length argv) 3)
-            (display-help)
-            (load-sekka-jisyo (second argv) (third argv))))
+        (let1 filename (third argv)
+          (set-kvs-type (analyze-kvs-type filename))
+          (if (< (length argv) 3)
+              (display-help)
+              (load-sekka-jisyo (second argv) filename))))
        ((eq? 'dump command)
-        (if (< (length argv) 2)
-            (display-help)
-            (dump-sekka-jisyo (second argv))))
+        (let1 filename (second argv)
+          (set-kvs-type (analyze-kvs-type filename))
+          (if (< (length argv) 2)
+              (display-help)
+              (dump-sekka-jisyo filename))))
        (else
         (errorf "Error: no such command [%s] \n" command )))))))
 

data/emacs/sekka.el

@@ -104,6 +104,12 @@ non-nil で明示的に呼びだすまでGoogleIMEは起動しない。"
   :type  'boolean
   :group 'sekka)
 
+(defcustom sekka-kakutei-with-spacekey t
+  "*Non-nil であれば、リアルタイムガイド表示中のSPACEキーでの確定動作を有効にする"
+  :type  'boolean
+  :group 'sekka)
+
+
 
 (defface sekka-guide-face
   '((((class color) (background light)) (:background "#E0E0E0" :foreground "#F03030")))
@@ -695,7 +701,7 @@ non-nil で明示的に呼びだすまでGoogleIMEは起動しない。"
 (define-key sekka-select-mode-map "\C-p"                   'sekka-select-prev)
 (define-key sekka-select-mode-map "\C-n"                   'sekka-select-next)
 (define-key sekka-select-mode-map sekka-rK-trans-key       'sekka-select-next)
-(define-key sekka-select-mode-map " "                      'sekka-select-next)
+(define-key sekka-select-mode-map (kbd "SPC")              'sekka-select-next)
 (define-key sekka-select-mode-map "\C-u"                   'sekka-select-hiragana)
 (define-key sekka-select-mode-map "\C-i"                   'sekka-select-katakana)
 (define-key sekka-select-mode-map "\C-k"                   'sekka-select-katakana)
@@ -714,6 +720,7 @@ non-nil で明示的に呼びだすまでGoogleIMEは起動しない。"
 
     (define-key map "\C-n"      'popup-next)
     (define-key map "\C-j"      'popup-next)
+    (define-key map (kbd "SPC") 'popup-next)
     (define-key map [down]      'popup-next)
     (define-key map "\C-p"      'popup-previous)
     (define-key map [up]        'popup-previous)
@@ -978,8 +985,8 @@ non-nil で明示的に呼びだすまでGoogleIMEは起動しない。"
      (lambda (alist)
        (let ((markers  (sekka-assoc-ref 'markers  alist nil)))
 	 (sekka-debug-print (format "markers=%S\n" markers))
-	 (sekka-debug-print (format "marker-position car=%d\n" (marker-position (car markers))))
-	 (sekka-debug-print (format "marker-position cdr=%d\n" (marker-position (cdr markers))))
+	 (sekka-debug-print (format "marker-position car=%S\n" (marker-position (car markers))))
+	 (sekka-debug-print (format "marker-position cdr=%S\n" (marker-position (cdr markers))))
 	 (when (and (marker-position (car markers))	 ;; 存在するバッファを指しているか
 		    (marker-position (cdr markers)))
 	   (if (= (marker-position (car markers))
@@ -1287,6 +1294,31 @@ non-nil で明示的に呼びだすまでGoogleIMEは起動しない。"
 	  sticky-list)
   (define-key sticky-map sticky-key '(lambda ()(interactive)(insert sticky-key))))
 
+
+(defun sekka-spacekey-init-function ()
+  (define-key global-map (kbd "SPC")
+    '(lambda (&optional arg)(interactive "P")
+       (cond ((and (< 0 sekka-timer-rest) 
+		   sekka-kakutei-with-spacekey)
+	      (cond
+	       ((string= " " (char-to-string (preceding-char)))
+		(insert " "))
+	       ((eq       10                 (preceding-char))   ;; 直前に改行があった
+		(insert " "))
+	       ((string= "/" (char-to-string (preceding-char)))
+		(delete-region (- (point) 1) (point))
+		(insert " "))
+	       (t
+		(sekka-rK-trans))))
+	     (t
+	      (cond
+	       ((null arg)
+		(insert " "))
+	       (t
+		(dotimes(i arg)
+		  (insert " ")))))))))
+
+
 (defun sekka-realtime-guide ()
   "リアルタイムで変換中のガイドを出す
 sekka-modeがONの間中呼び出される可能性がある。"
@@ -1410,6 +1442,9 @@ point から行頭方向に同種の文字列が続く間を漢字変換しま
 			(> (prefix-numeric-value arg) 0))))
   (when sekka-sticky-shift
     (add-hook 'sekka-mode-hook 'sekka-sticky-shift-init-function))
+
+  (add-hook 'sekka-mode-hook 'sekka-spacekey-init-function)
+
   (when sekka-mode (run-hooks 'sekka-mode-hook))
 
   (sekka-debug-print "sekka-mode-internal :2\n")
@@ -1455,7 +1490,7 @@ point から行頭方向に同種の文字列が続く間を漢字変換しま
 (setq default-input-method "japanese-sekka")
 
 (defconst sekka-version
-  "0.8.8" ;;SEKKA-VERSION
+  "0.9.0" ;;SEKKA-VERSION
   )
 (defun sekka-version (&optional arg)
   "入力モード変更"

data/lib/sekka/approximatesearch.rb

@@ -49,19 +49,23 @@ class ApproximateSearch
     }.select { |v| v }.sort_by {|item| 1.0 - item[0]}
   end
 
-  def search( userid, kvs, keyword, okuri_ari )
-    readymade_key = if okuri_ari
-                      keyword.slice( 0, 2 ).upcase
+  def search( userid, kvs, keyword, type )
+    readymade_key = case type
+                    when 'k' # okuri nashi kanji entry
+                      "(" + keyword.slice( 0, 2 ).downcase + ")"
+                    when 'K' # okuri ari   kanji entry
+                      "(" + keyword.slice( 0, 2 ).upcase   + ")"
+                    when 'h' # hiragana phrase entry
+                      "{" + keyword.slice( 1, 2 ).downcase + "}"
                     else
-                      keyword.slice( 0, 2 ).downcase
+                      raise sprintf( "Error: ApproximateSearch#search unknown type %s ", type )
                     end
-    readymade_key = "(" + readymade_key + ")"
-    
+
     str = kvs.get( userid + "::" + readymade_key, false )
-    if not str 
+    if not str
       str = kvs.get( "MASTER::" + readymade_key )
     end
-    
+
     #printf( "#readymade_key %s : %s\n", readymade_key, str )
     if str
       filtering( keyword, str.split( /[ ]+/ ))

data/lib/sekka/convert-jisyo.nnd

@@ -38,6 +38,17 @@
 (use sekka.roman-lib)
 
 
+(define (expand-hiragana-phrase-entry key)
+  (let1 roman-list (gen-hiragana->roman-list key)
+    (if (< 1000 (length roman-list))
+        (begin
+          (STDERR.printf " Warning: ignored entry [%s] (hiragana phrase), because too many pattens.\n" key)
+          #f) ;; パターン数が爆発した単語は無視する
+        (map
+         (lambda (x)
+           (cons (+ "=" x) key))
+         roman-list))))
+
 (define (expand-okuri-nashi-entry key value)
   (let1 roman-list (gen-hiragana->roman-list key)
     (if (< 1000 (length roman-list))
@@ -79,7 +90,7 @@
 
   (define (display-progress line)
     (set! current (+ current 1))
-    (when (= 0 (% current 10000))
+    (when (= 0 (% current 1000))
       (STDERR.printf "  %7d/%7d (%3.3f％)\n" current total (* (/ current (total.to_f)) 100.0))))
 
   (define (gen-sekka-entries line)
@@ -94,6 +105,13 @@
        ((not fields)
         ;; フォーマットエラー
         #f)
+       ((rxmatch #/\;\;/ line)
+        ;; フォーマットエラー
+        #f)
+       ((and (is-hiragana (first fields))
+             (rxmatch #/^\/$/ (second fields)))
+        ;; 平仮名フレーズ
+        (expand-hiragana-phrase-entry (first fields)))
        ((or (is-hiragana (first fields))
             (rxmatch #/^([>#あ-んー]+)$/ (first fields)))
         ;; 送り仮名なしデータ
@@ -113,20 +131,25 @@
        (else
         (list (cons (first fields) (second fields)))))))
 
-  (let* ((lines
+  (let* ([lines
           (map
            (lambda (line)
              (line.chomp))
-           (f.readlines.to_list)))
-         (_ (set! total (length lines)))
-         (entry-list
-          (filter
-           (lambda (x) x)
-           (map gen-sekka-entries lines))))
-    (map
-     (lambda (entry)
-       (sprintf "%s %s" (car entry) (cdr entry)))
-     (apply append! entry-list))))
+           (f.readlines))]
+         [_ (set! total (lines.size))]
+         [result '#()])
+    (for-each
+     (lambda (x)
+       (let1 entries (gen-sekka-entries x)
+         (when entries
+           (for-each
+            (lambda (entry)
+              (result.push (sprintf "%s %s" (car entry) (cdr entry))))
+            entries))))
+     lines)
+
+    (to-list result)))
+   
 
 
 

data/lib/sekka/henkan.nnd

@@ -68,40 +68,39 @@
    lst))
 
 
-(define (my-append-many lst)
-  (let1 result '()
-    (for-each
-     (lambda (x)
-       (set! result (append result x)))
-     lst)
-    result))
+(define (flatten-vector vec)
+  (vec.flatten))
 
 
 ;; 曖昧検索
 ;;  リストで返す。 (ソート済み検索結果)
-(define (approximate-search userid kvs keyword okuri-ari-flag limit)
-  (define jarow-shikii 0.94)
-  (let* ((a-search (ApproximateSearch.new jarow-shikii))
-         (lst      (my-append-many
-                    (map
-                     (lambda (x)
-                      (let* ((val (vector-ref x 0))
-                             (k   (vector-ref x 1))
-                             (v   (dict-get userid kvs k ""))
-                             (v-pair (string-split-first-and-rest v))
-                             (v-first (car v-pair))
-                             (v-rest  (cdr v-pair)))
-                        (map
-                         (lambda (element)
-                           (list val k (+ v-first element)))
-                         (to-list (v-rest.split "/")))))
-                     (to-list (a-search.search userid kvs keyword okuri-ari-flag)))))
-         (nn-heuristics-result (nn-heuristics keyword lst))
-         (sorted-lst  (sort-by nn-heuristics-result (lambda (item) (- 1.0 (car item))))))
-    (if (= limit 0)
-        sorted-lst
-        (take* sorted-lst limit))))
-
+(define (approximate-search userid kvs keyword type limit)
+  (let ([jarow-threshold
+         (if (= "h" type)
+             0.975
+             0.94)])
+
+    (let* ((a-search (ApproximateSearch.new jarow-threshold))
+           (lst      (to-list
+                      (flatten-vector
+                       (map
+                        (lambda (x)
+                          (let* ((val (vector-ref x 0))
+                                 (k   (vector-ref x 1))
+                                 (v   (dict-get userid kvs k ""))
+                                 (v-pair (string-split-first-and-rest v))
+                                 (v-first (car v-pair))
+                                 (v-rest  (cdr v-pair)))
+                            (map
+                             (lambda (element)
+                               (list val k (+ v-first element)))
+                             (v-rest.split "/"))))
+                        (a-search.search userid kvs keyword type)))))
+           (nn-heuristics-result (nn-heuristics keyword lst))
+           (sorted-lst  (sort-by nn-heuristics-result (lambda (item) (- 1.0 (car item))))))
+      (if (= limit 0)
+          sorted-lst
+          (take* sorted-lst limit)))))
 
 
 ;; 厳密検索
@@ -143,7 +142,7 @@
 
 ;; 送り仮名なしの変換
 (define (henkan-okuri-nashi userid kvs keyword limit)
-  (let* ((result (approximate-search userid kvs keyword #f limit))
+  (let* ((result (approximate-search userid kvs keyword "k" limit))
          (kouho  (uniq (map
                         (lambda (x)
                           (third x))
@@ -204,7 +203,7 @@
                                            (+ (rxmatch-substring m 1)
                                               (rxmatch-substring m 2)
                                               (rxmatch-substring m 3))
-                                           #t
+                                           "K"
                                            limit))
                (okurigana-lst  (gen-roman->hiragana (sekka-downcase
                                                      (+
@@ -236,19 +235,45 @@
                 (take* lst limit)))))))
 
 
+;; 平仮名フレーズ辞書を使った曖昧検索
+(define (henkan-hiragana-phrase userid kvs keyword limit roman-method)
+  (let* ([result (approximate-search userid kvs
+                                     (+ "=" (sekka-downcase keyword))
+                                     "h"
+                                     limit)]
+         [uniq-result
+          (delete-duplicates
+           (map
+            (lambda (x) (third x))
+            result))]
+          
+         [lst (map
+               (lambda (x)
+                 (list x #f keyword 'h))
+               uniq-result)])
+
+    (if (= limit 0)
+        lst
+        (take* lst limit))))
+
+  
+  
 ;; 平仮名の変換
-(define (henkan-hiragana kvs keyword roman-method)
-  (let* ((str  (sekka-downcase keyword))
-         (hira (gen-roman->hiragana str roman-method))
-         (kata (gen-roman->katakana str roman-method)))
-    (if (null? hira)
-        `((,keyword #f ,keyword j))
-        (append-map (lambda (h k)
-                      `(
-                        (,h #f ,keyword h)
-                        (,k #f ,keyword k)))
-                    hira
-                    kata))))
+(define (henkan-hiragana userid kvs keyword roman-method)
+  (let* ([phrase-limit  3]
+         [str  (sekka-downcase keyword)]
+         [hira (gen-roman->hiragana str roman-method)]
+         [kata (gen-roman->katakana str roman-method)])
+    (append
+     (henkan-hiragana-phrase userid kvs keyword phrase-limit roman-method)
+     (if (null? hira)
+         `((,keyword #f ,keyword j))
+         (append-map (lambda (h k)
+                       `(
+                         (,h #f ,keyword h)
+                         (,k #f ,keyword k)))
+                     hira
+                     kata)))))
 
 
 ;; アルファベットの単純変換
@@ -303,23 +328,21 @@
        (cond
         ((rxmatch #/[a-z][A-Z`+]/ k)
          ;; 送りあり
-         ;;(let1 result (approximate-search db k #t)  (disp-search-result result))
          (append
           (append
            (henkan-okuri-ari userid kvs k limit roman-method)
            (if (null? (gen-roman->hiragana (sekka-downcase k) roman-method))
                '()
-              (henkan-hiragana kvs (sekka-downcase k) roman-method)))
+              (henkan-hiragana userid kvs (sekka-downcase k) roman-method)))
           (henkan-alphabet kvs keyword)))
         (else
          ;; 送りなし
-         ;;(let1 result (approximate-search db k #f)  (disp-search-result result))
          (append
           (append
            (henkan-okuri-nashi userid kvs k limit)
            (if (null? (gen-roman->hiragana (sekka-downcase k) roman-method))
                '()
-               (henkan-hiragana kvs (sekka-downcase k) roman-method)))
+               (henkan-hiragana userid kvs (sekka-downcase k) roman-method)))
           (henkan-alphabet kvs keyword))))))
     ;; 10進数数値のみで構成されるキーワード
     ((rxmatch #/^[0-9]+$/ keyword)
@@ -332,7 +355,7 @@
     ((not (null? (gen-roman->hiragana keyword roman-method)))
      (append
       (append
-       (henkan-hiragana kvs keyword roman-method)
+       (henkan-hiragana userid kvs keyword roman-method)
        (henkan-alphabet kvs keyword))
       (henkan-okuri-nashi userid kvs keyword limit)))
     (else
@@ -468,7 +491,8 @@
     
   (define (_create-ready-made-keylist keylist)
     (receive (okuri-ari-hash
-              okuri-nashi-hash)
+              okuri-nashi-hash
+              hiragana-phrase-hash)
         (create-2char-hash keylist)
       
       ;; OKURI-ARI
@@ -491,8 +515,19 @@
                      (string-join (uniq (sort (append (to-list (fetched.split #/[ ]+/))
                                                       (hash-table-get okuri-nashi-hash key))))
                                   " "))))
-       (hash-table-keys okuri-nashi-hash))))
-         
+       (hash-table-keys okuri-nashi-hash))
+
+      ;; HIRAGANA-PHRASE
+      (for-each
+       (lambda (key)
+         (let1 fetched (kvs.get  (+ userid "::" "{" (sekka-downcase key) "}")
+                                 (kvs.get  (+ masterid "::" "{" (sekka-downcase key) "}") ""))
+           (kvs.put! (+ userid "::" "{" (sekka-downcase key) "}")
+                     (string-join (uniq (sort (append (to-list (fetched.split #/[ ]+/))
+                                                      (hash-table-get hiragana-phrase-hash key))))
+                                  " "))))
+       (hash-table-keys hiragana-phrase-hash))))
+
   ;; "ユーザー語彙を"(stored)"にpush!する"
   (define (kvs-push! userid kvs entry-str)
     (let* ((orig (kvs.get (+ userid "::(stored)") "()"))

data/lib/sekka/jisyo-db.nnd

@@ -72,21 +72,29 @@
       opt)))
 
 (define (create-2char-hash keylist)
-  (define okuri-ari-hash   (make-hash-table))
-  (define okuri-nashi-hash (make-hash-table))
+  (define okuri-ari-hash         (make-hash-table))
+  (define okuri-nashi-hash       (make-hash-table))
+  (define hiragana-phrase-hash   (make-hash-table))
   (define (create-hash keylist)
     (for-each
      (lambda (k)
-       (when (rxmatch #/^[a-zA-Z#^>-@`\;+:'\-]+$/ k)
-         (let1 sliced (sekka-downcase (k.slice 0 2))
-           (when (= 2 sliced.size)
-             (if (rxmatch #/[A-Z`+]$/ k)
-                 (hash-table-push! okuri-ari-hash   sliced k)
-                 (hash-table-push! okuri-nashi-hash sliced k))))))
+       (when (rxmatch #/^[=a-zA-Z#^>-@`\;+:'\-]+$/ k)
+         (if (rxmatch #/^=/ k)
+             ;; HIRAGANA-PHRASE
+             (let1 sliced (sekka-downcase (k.slice 1 2))
+               (when (= 2 sliced.size)
+                 (hash-table-push! hiragana-phrase-hash   sliced k)))
+             ;; OKURI-ARI and OKURI-NASHI
+             (let1 sliced (sekka-downcase (k.slice 0 2))
+               (when (= 2 sliced.size)
+                 (if (rxmatch #/[A-Z`+]$/ k)
+                     (hash-table-push! okuri-ari-hash   sliced k)
+                     (hash-table-push! okuri-nashi-hash sliced k)))))))
      keylist))
   (create-hash keylist)
   (values okuri-ari-hash
-          okuri-nashi-hash))
+          okuri-nashi-hash
+          hiragana-phrase-hash))
 
 (define (setup-ready-made-keylist kvs keylist)
   (for-each
@@ -97,7 +105,8 @@
    alphabet-pairs)
   
   (receive (okuri-ari-hash
-            okuri-nashi-hash)
+            okuri-nashi-hash
+            hiragana-phrase-hash)
       (create-2char-hash keylist)
 
     ;; OKURI-ARI
@@ -112,49 +121,61 @@
      (lambda (key)
        (kvs.put! (+ masterid "::" "(" (sekka-downcase key) ")")
                  (string-join (uniq (sort (hash-table-get okuri-nashi-hash key))) " ")))
-     (hash-table-keys okuri-nashi-hash))))
-
-
-(define (append-entry userid kvs key value)
-  (let1 key (+ userid "::" key)
-    (if-let1 got (kvs.get key #f)
-      (let* ((trimmed-a-first1 (car (string-split-first-and-rest  got)))
-             (trimmed-a        (if-let1 m (rxmatch #/^[C\/](.+)$/ got)
-                                 (rxmatch-substring m 1)
-                                 got))
-             (trimmed-b-first1 (car (string-split-first-and-rest  value)))
-             (trimmed-b        (if-let1 m (rxmatch #/^[C\/](.+)$/ value)
-                                 (rxmatch-substring m 1)
-                                 value))
-             (lst (delete-duplicates (append (to-list (trimmed-a.split "/"))
-                                             (to-list (trimmed-b.split "/"))))))
-        (if (= trimmed-a-first1 trimmed-b-first1)
-            (kvs.put! key (+ trimmed-a-first1 (string-join lst "/")))
-            (begin
-              ;; "/" よりも "C" を優先する
-              (cond
-               ((= "C" trimmed-a-first1) ;; aを優先
-                (kvs.put! key got))
-               ((= "C" trimmed-b-first1) ;; bを優先
-                (kvs.put! key value))
-               (else
-                (errorf "Error: [%s] entry is wrong format" value))))))
-      (kvs.put! key value))))
+     (hash-table-keys okuri-nashi-hash))
+
+    ;; HIRAGANA-PHRASE
+    (for-each
+     (lambda (key)
+       (kvs.put! (+ masterid "::" "{" (sekka-downcase key) "}")
+                 (string-join (uniq (sort (hash-table-get hiragana-phrase-hash key))) " ")))
+     (hash-table-keys hiragana-phrase-hash))))
+
+
+(define (append-entry userid kvs _key value)
+  (let1 key (+ userid "::" _key)
+    (cond
+     ((rxmatch #/^=/ _key)
+      ;; hiragana-phrase entry
+      (kvs.put! key value))
+     (else
+      (if-let1 got (kvs.get key #f)
+        (let* ((trimmed-a-first1 (car (string-split-first-and-rest  got)))
+               (trimmed-a        (if-let1 m (rxmatch #/^[C\/](.+)$/ got)
+                                   (rxmatch-substring m 1)
+                                   got))
+               (trimmed-b-first1 (car (string-split-first-and-rest  value)))
+               (trimmed-b        (if-let1 m (rxmatch #/^[C\/](.+)$/ value)
+                                     (rxmatch-substring m 1)
+                                     value))
+               (lst (delete-duplicates (append (to-list (trimmed-a.split "/"))
+                                               (to-list (trimmed-b.split "/"))))))
+          (if (= trimmed-a-first1 trimmed-b-first1)
+              (kvs.put! key (+ trimmed-a-first1 (string-join lst "/")))
+              (begin
+                ;; "/" よりも "C" を優先する
+                (cond
+                 ((= "C" trimmed-a-first1) ;; aを優先
+                  (kvs.put! key got))
+                 ((= "C" trimmed-b-first1) ;; bを優先
+                  (kvs.put! key value))
+                 (else
+                  (errorf "Error: [%s][%s] entry is wrong format" key value))))))
+        (kvs.put! key value))))))
 
 
 (define (load-sekka-jisyo-f f filename)
   (define keylist '())
-  (define (create-keylist kvs lines)
+  (define (create-keylist kvs f)
     (for-each
      (lambda (line)
        (let1 fields (split-dict-line line)
          (set! keylist (cons (first fields) keylist))
          (append-entry masterid kvs (first fields) (second fields))))
-     lines))
+     (f.readlines)))
   (let1 kvs (Kvs.new (get-kvs-type))
     (kvs.open filename)
     (kvs.clear)
-    (create-keylist kvs (f.readlines.to_list))
+    (create-keylist kvs f)
     (setup-ready-made-keylist kvs keylist)
     (kvs.close)))
 
@@ -165,7 +186,7 @@
     (for-each
      (lambda (key)
        (f.puts (+ key " " (kvs.get key))))
-     (to-list (kvs.keys)))
+     (kvs.keys.sort))
     (kvs.close)))