X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=ids-find.el;h=eb404b356120a895f36e8ce2b53f9cdf86d1ddc4;hb=a4df808060fee8ed01ec25f81ac14f1b5eb2ddfc;hp=d21bd7b063795f8637d71db84a6bf888499453a5;hpb=c1d56df216de11a6224e2dc7d99de5f5e9f2e395;p=chise%2Fids.git

diff --git a/ids-find.el b/ids-find.el
index d21bd7b..eb404b3 100644
--- a/ids-find.el
+++ b/ids-find.el
@@ -1,11 +1,11 @@
 ;;; ids-find.el --- search utility based on Ideographic-structures
 
-;; Copyright (C) 2002,2003,2005 MORIOKA Tomohiko
+;; Copyright (C) 2002,2003,2005,2006,2007,2017 MORIOKA Tomohiko
 
 ;; Author: MORIOKA Tomohiko <tomo@kanji.zinbun.kyoto-u.ac.jp>
 ;; Keywords: Kanji, Ideographs, search, IDS, CHISE, UCS, Unicode
 
-;; This file is a part of Tomoyo-Tools.
+;; This file is a part of CHISE IDS.
 
 ;; This program is free software; you can redistribute it and/or
 ;; modify it under the terms of the GNU General Public License as
@@ -25,13 +25,13 @@
 ;;; Code:
 
 (defun ids-index-store-char (product component)
-  (let ((ret (char-feature ; get-char-attribute
-	      component 'ideographic-products)))
+  (let ((ret (get-char-attribute component 'ideographic-products)))
     (unless (memq product ret)
       (put-char-attribute component 'ideographic-products
-			  (cons product ret)))
-    (when (setq ret (char-feature component 'ideographic-structure))
-      (ids-index-store-structure product ret))))
+			  (cons product ret))
+      (when (setq ret (char-feature component 'ideographic-structure))
+	(ids-index-store-structure product ret)))
+    ))
 
 (defun ids-index-store-structure (product structure)
   (let (ret)
@@ -68,65 +68,140 @@
       (setq dest (union dest (ids-find-all-products cell))))
     dest))
 
+(defun of-component-features ()
+  (let (dest)
+    (dolist (feature (char-attribute-list))
+      (when (string-match "^<-.*[@/]component\\(/[^*/]+\\)*$"
+			  (symbol-name feature))
+	(push feature dest)))
+    (list* '<-mistakable '->mistakable
+	   '<-formed '->formed
+	   '<-same '->same
+	   '<-original '->original
+	   '<-ancient '->ancient
+	   dest)))
+
+(defun to-component-features ()
+  (let (dest)
+    (dolist (feature (char-attribute-list))
+      (when (string-match "^->.*[@/]component\\(/[^*/]+\\)*$"
+			  (symbol-name feature))
+	(push feature dest)))
+    dest))
+
 ;;;###autoload
 (defun char-component-variants (char)
-  (let (dest ret uchr)
+  (let ((dest (list char))
+	ret uchr)
+    (dolist (feature (to-component-features))
+      (if (setq ret (get-char-attribute char feature))
+	  (dolist (c ret)
+	    (setq dest (union dest (char-component-variants c))))))
     (cond
-     ((setq ret (char-feature char '<-ideographic-component-forms))
-      (dolist (c ret)
-	(setq dest (union dest (char-component-variants c)))))
+     ;; ((setq ret (some (lambda (feature)
+     ;;                    (get-char-attribute char feature))
+     ;;                  (to-component-features)))
+     ;;  (dolist (c ret)
+     ;;    (setq dest (union dest (char-component-variants c))))
+     ;;  )
      ((setq ret (get-char-attribute char '->ucs-unified))
       (setq dest (cons char ret))
       (dolist (c dest)
 	(setq dest (union dest
-			  (get-char-attribute
-			   c '->ideographic-component-forms))))
+                          (some (lambda (feature)
+				  (get-char-attribute c feature))
+				(of-component-features))
+			  )))
       )
      ((and (setq ret (get-char-attribute char '=>ucs))
 	   (setq uchr (decode-char '=ucs ret)))
       (setq dest (cons uchr (char-variants uchr)))
       (dolist (c dest)
 	(setq dest (union dest
-			  (get-char-attribute
-			   c '->ideographic-component-forms))))
+                          (some (lambda (feature)
+				  (get-char-attribute c feature))
+				(of-component-features))
+			  )))
       )
      (t
-      (map-char-family (lambda (c)
-			 (unless (memq c dest)
-			   (setq dest (cons c dest)))
-			 (setq dest
-			       (union dest
-				      (get-char-attribute
-				       c '->ideographic-component-forms)))
-			 nil)
-		       char)))
+      (map-char-family
+       (lambda (c)
+	 (unless (memq c dest)
+	   (setq dest (cons c dest)))
+	 (setq dest
+	       (union dest
+		      (some (lambda (feature)
+			      (char-feature c feature))
+			    (of-component-features))
+		      ))
+	 nil)
+       char)
+      ))
     dest))
 
 ;;;###autoload
 (defun ideographic-products-find (&rest components)
   (if (stringp (car components))
-      (setq components (car components)))
-  (let ((len (length components))
-	(i 1)
-	dest products)
-    (dolist (variant (char-component-variants (elt components 0)))
-      (dolist (product (get-char-attribute variant 'ideographic-products))
-	(unless (memq product products)
-	  (setq products (cons product products)))))
+      (setq components (string-to-char-list (car components))))
+  (let (dest products)
+    (dolist (variant (char-component-variants (car components)))
+      (setq products
+	    (union products
+		   (get-char-attribute variant 'ideographic-products))))
     (setq dest products)
-    (while (and
-	    (< i len)
-	    (progn
-	      (setq products nil)
-	      (dolist (variant (char-component-variants (elt components i)))
-		(dolist (product (get-char-attribute
-				  variant 'ideographic-products))
-		  (unless (memq product products)
-		    (when (memq product dest)
-		      (setq products (cons product products))))))
-	      (setq dest products)))
-      (setq i (1+ i)))
-    products))
+    (while (and dest
+		(setq components (cdr components)))
+      (setq products nil)
+      (dolist (variant (char-component-variants (car components)))
+	(setq products
+	      (union products
+		     (get-char-attribute variant 'ideographic-products))))
+      (setq dest (intersection dest products)))
+    dest))
+
+(defun ideograph-find-products-with-variants (components &optional ignored-chars)
+  (if (stringp components)
+      (setq components (string-to-char-list components)))
+  (let (dest products)
+    (dolist (variant (char-component-variants (car components)))
+      (setq products
+	    (union products
+		   (set-difference
+		    (get-char-attribute variant 'ideographic-products)
+		    ignored-chars))))
+    (setq dest products)
+    (while (and dest
+		(setq components (cdr components)))
+      (setq products nil)
+      (dolist (variant (char-component-variants (car components)))
+	(setq products
+	      (union products
+		     (set-difference
+		      (get-char-attribute variant 'ideographic-products)
+		      ignored-chars))))
+      (setq dest (intersection dest products)))
+    dest))
+
+(defun ideograph-find-products (components &optional ignored-chars)
+  (if (stringp components)
+      (setq components (string-to-char-list components)))
+  (let (dest products)
+    ;; (dolist (variant (char-component-variants (car components)))
+    ;;   (setq products
+    ;;         (union products
+    ;;                (get-char-attribute variant 'ideographic-products))))
+    ;; (setq dest products)
+    (setq dest (get-char-attribute (car components) 'ideographic-products))
+    (while (and dest
+		(setq components (cdr components)))
+      ;; (setq products nil)
+      ;; (dolist (variant (char-component-variants (car components)))
+      ;;   (setq products
+      ;;         (union products
+      ;;                (get-char-attribute variant 'ideographic-products))))
+      (setq products (get-char-attribute (car components) 'ideographic-products))
+      (setq dest (intersection dest products)))
+    dest))
 
 
 (defun ideographic-structure-char= (c1 c2)
@@ -136,22 +211,7 @@
 		 (m2 (char-ucs c2)))
 	     (or (and m1 m2
 		      (eq m1 m2))
-		 (some (lambda (b2)
-			 (unless (characterp b2)
-			   (setq b2 (find-char b2)))
-			 (and b2
-			      (ideographic-structure-char= c1 b2)))
-		       (get-char-attribute
-			c2 '<-ideographic-component-forms))
-		 (progn
-		   (setq m1 (car (get-char-attribute c1 '<-radical))
-			 m2 (car (get-char-attribute c2 '<-radical)))
-		   (unless (characterp m1)
-		     (setq m1 (find-char m1)))
-		   (unless (characterp m2)
-		     (setq m2 (find-char m2)))
-		   (when (or m1 m2)
-		     (ideographic-structure-char= m1 m2))))))))
+		 (memq c1 (char-component-variants c2)))))))
 
 (defun ideographic-structure-member-compare-components (component s-component)
   (let (ret)
@@ -223,6 +283,83 @@
 	  (or (ideographic-structure-to-ids v)
 	      v)))
 
+(defun ids-insert-chars-including-components* (components
+					       &optional level ignored-chars)
+  (unless level
+    (setq level 0))
+  (let (is i as bs)
+    (dolist (c (sort (copy-tree (ideograph-find-products components
+							 ignored-chars))
+		     (lambda (a b)
+		       (if (setq as (char-total-strokes a))
+			   (if (setq bs (char-total-strokes b))
+			       (if (= as bs)
+				   (ideograph-char< a b)
+				 (< as bs))
+			     t)
+			 (ideograph-char< a b)))))
+      (unless (memq c ignored-chars)
+	(setq is (char-feature c 'ideographic-structure))
+	(setq i 0)
+	(while (< i level)
+	  (insert "\t")
+	  (setq i (1+ i)))
+	(insert (ids-find-format-line c is))
+	(setq ignored-chars
+	      (ids-insert-chars-including-components*
+	       (char-to-string c) (1+ level)
+	       (cons c ignored-chars))))
+      )
+    )
+  ignored-chars)
+
+(defun ids-insert-chars-including-components (components
+					      &optional level ignored-chars)
+  (unless level
+    (setq level 0))
+  (setq ignored-chars
+	(nreverse
+	 (ids-insert-chars-including-components* components
+						 level ignored-chars)))
+  (let (is i as bs)
+    (dolist (c ignored-chars)
+      (dolist (vc (char-component-variants c))
+	(unless (memq vc ignored-chars)
+	  (when (setq is (get-char-attribute vc 'ideographic-structure))
+	    (setq i 0)
+	    (while (< i level)
+	      (insert "\t")
+	      (setq i (1+ i)))
+	    (insert (ids-find-format-line vc is))
+	    (setq ignored-chars
+		  (ids-insert-chars-including-components*
+		   (char-to-string vc) (1+ level)
+		   (cons vc ignored-chars)))))))
+    (dolist (c (sort (copy-tree (ideograph-find-products-with-variants
+				 components ignored-chars))
+		     (lambda (a b)
+		       (if (setq as (char-total-strokes a))
+			   (if (setq bs (char-total-strokes b))
+			       (if (= as bs)
+				   (ideograph-char< a b)
+				 (< as bs))
+			     t)
+			 (ideograph-char< a b)))))
+      (unless (memq c ignored-chars)
+	(setq is (get-char-attribute c 'ideographic-structure))
+	(setq i 0)
+	(while (< i level)
+	  (insert "\t")
+	  (setq i (1+ i)))
+	(insert (ids-find-format-line c is))
+	(setq ignored-chars
+	      (ids-insert-chars-including-components*
+	       (char-to-string c) (1+ level)
+	       (cons c ignored-chars))))
+      )
+    )
+  ignored-chars)
+
 ;;;###autoload
 (defun ids-find-chars-including-components (components)
   "Search Ideographs whose structures have COMPONENTS."
@@ -230,36 +367,23 @@
   (with-current-buffer (get-buffer-create ids-find-result-buffer)
     (setq buffer-read-only nil)
     (erase-buffer)
-    (let (is)
-      (dolist (c (ideographic-products-find components))
-	(setq is (char-feature c 'ideographic-structure))
-	;; to avoid problems caused by wrong indexes
-	(when (every (lambda (c)
-		       (ideographic-structure-member c is))
-		     components)
-	  (insert (ids-find-format-line c is))
-	  )
-	)
-      ;; (forward-line -1)
-      )
+    (ids-insert-chars-including-components components 0 nil)
+    ;; (let ((ignored-chars
+    ;;        (nreverse
+    ;;         (ids-insert-chars-including-components components 0 nil
+    ;;                                                #'ideograph-find-products)))
+    ;;       rest)
+    ;;   (setq rest ignored-chars)
+    ;;   ;; (dolist (c rest)
+    ;;   ;;   (setq ignored-chars
+    ;;   ;;         (union ignored-chars
+    ;;   ;;                (ids-insert-chars-including-components
+    ;;   ;;                 (list c) 0 ignored-chars
+    ;;   ;;                 #'ideograph-find-products-with-variants))))
+    ;;   (ids-insert-chars-including-components components 0 ignored-chars
+    ;;                                          #'ideograph-find-products-with-variants))
     (goto-char (point-min)))
   (view-buffer ids-find-result-buffer))
-;; (defun ids-find-chars-including-components (components)
-;;   "Search Ideographs whose structures have COMPONENTS."
-;;   (interactive "sComponents : ")
-;;   (with-current-buffer (get-buffer-create ids-find-result-buffer)
-;;     (setq buffer-read-only nil)
-;;     (erase-buffer)
-;;     (map-char-attribute
-;;      (lambda (c v)
-;;        (when (every (lambda (p)
-;;                       (ideographic-structure-member p v))
-;;                     components)
-;;          (insert (ids-find-format-line c v)))
-;;        nil)
-;;      'ideographic-structure)
-;;     (goto-char (point-min)))
-;;   (view-buffer ids-find-result-buffer))
 
 ;;;###autoload
 (define-obsolete-function-alias 'ideographic-structure-search-chars
@@ -274,12 +398,11 @@
   (with-current-buffer (get-buffer-create ids-find-result-buffer)
     (setq buffer-read-only nil)
     (erase-buffer)
-    (let (ucs jis)
-      (map-char-attribute
-       (lambda (c v)
-	 (when (ideographic-structure-repertoire-p v components)
-	   (insert (ids-find-format-line c v))))
-       'ideographic-structure))
+    (map-char-attribute
+     (lambda (c v)
+       (when (ideographic-structure-repertoire-p v components)
+	 (insert (ids-find-format-line c v))))
+     'ideographic-structure)
     (goto-char (point-min)))
   (view-buffer ids-find-result-buffer))