Index: /lang/scheme/gauche/bindings/mecab/trunk/test.scm =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/test.scm (revision 117) +++ /lang/scheme/gauche/bindings/mecab/trunk/test.scm (revision 131) @@ -1,41 +1,198 @@ ;; -*- coding:euc-jp -*- ;; -;; test for mecab module +;; dictionary-independent tests for mecab module ;; (use gauche.test) -(test-start "mecab") +(test-start "mecab: dictionary-independent tests") (use text.mecab) (test-module 'text.mecab) -(define m (mecab-new2 "")) -(test* "mecab-new2" #t (is-a? m )) -(test* "mecab-destroy" #f (mecab-destroyed? m)) -(mecab-destroy m) -(test* "mecab-destroy" #t (mecab-destroyed? m)) +;; +;; write-object / ctor +;; +(define-macro (displayed-string obj) + `(with-output-to-string (lambda () (display ,obj)))) -(test* "mecab-sparse-tostr" #f - (mecab-sparse-tostr m "�Ϻ�ϼ�Ϻ���������Ҥ�Ϥ�����")) -(test* "mecab-strerror" #t (string? (mecab-strerror m))) +(test-section "write-object (display)") +(let1 m (mecab-new '()) + (test* "(mecab-new '())" "#" (displayed-string m)) + (mecab-destroy m)) +(let1 m (mecab-new '("-O" "chasen")) + (test* "(mecab-new '(\"-O\" \"chasen\"))" "#" (displayed-string m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "") + (test* "(mecab-new2 \"\")" "#" (displayed-string m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "-Ochasen") + (test* "(mecab-new2 \"-Ochasen\")" "#" (displayed-string m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "-O chasen") + (test* "(mecab-new2 \"-O chasen\")" "#" (displayed-string m)) + (mecab-destroy m)) -(define m (mecab-new2 "")) -(test* "mecab-sparse-tostr" - "�Ϻ ̾����,*,*,�Ϻ,ï¿½ï¿½ï¿½í¤¦,*\n\ - �������*,*,����*\n\ - ��Ϻ ̾����,*,*,��Ϻ,ï¿½ï¿½ï¿½í¤¦,*\n\ - �� ���ʽ�*,*,��,��,*\n\ - ��ư��,�Ҳ�ư�쥿���������Ʒ����ä��ɽɽ��:�� - �������������,���ư�����������\n\ - � ̾���̾��,*,�,�ۤ���:�� �ɽɽ��:�\n\ - ����ʽ�*,*,��,*\n\ - �ֻ�̾����,*,*,�ֻ��Ϥʤ�,*\n\ - �����ʽ�*,*,����*\n\ - ����� ư��,�Ҳ�ư�쥵���������,�錄����,�°ư����ʴ���ɽɽ��:���\n\ - �� ����,*,*,��,��,*\n\ - EOS\n" - (mecab-sparse-tostr m "�Ϻ�ϼ�Ϻ���������Ҥ�Ϥ�����")) - -(mecab-destroy m) +(test-section "reader-ctor") +(let1 m #,(mecab "") ;; with reader-ctor + (test* "#,(mecab \"\") : mecab?" #t (mecab? m)) + (test* "#,(mecab \"\") : options" '() (mecab-options m)) + (mecab-destroy m)) +(let1 m #,(mecab "-Ochasen") ;; with reader-ctor + (test* "#,(mecab \"-Ochasen\") : mecab?" #t (mecab? m)) + (test* "#,(mecab \"-Ochasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m #,(mecab :O chasen :l 1) ;; with reader-ctor + (test* "#,(mecab :O chasen :l 1) : mecab?" #t (mecab? m)) + (test* "#,(mecab :O chasen :l 1) : mecab-options" '((output-format-type chasen) (lattice-level 1)) (mecab-options m)) + (mecab-destroy m)) + +;; +;; mecab?, mecab-node?, mecab-dictionary-info? +;; +(let* ([m (mecab-new2 "")] + [node (mecab-sparse-tonode m "")] + [dinfo (mecab-dictionary-info m)]) + (test-section "mecab?, mecab-node?, mecab-dictionary-info?") + + (test* "is-a? m " #t (is-a? m )) + (test* "is-a? node " #t (is-a? node )) + (test* "is-a? dinfo " #t (is-a? dinfo )) + + (test* "mecab? m" #t (mecab? m)) + (test* "mecab? node" #f (mecab? node)) + (test* "mecab? dinfo" #f (mecab? dinfo)) + + (test* "mecab-node? m" #f (mecab-node? m)) + (test* "mecab-node? node" #t (mecab-node? node)) + (test* "mecab-node? dinfo" #f (mecab-node? dinfo)) + + (test* "mecab-dictionary-info? m" #f (mecab-dictionary-info? m)) + (test* "mecab-dictionary-info? node" #f (mecab-dictionary-info? node)) + (test* "mecab-dictionary-info? dinfo" #t (mecab-dictionary-info? dinfo)) + + (mecab-destroy m)) + +;; mecab, mecab-options +(test-section "mecab-options") +(let1 m (mecab-new '()) + (test* "(mecab-new '())" '() (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new '("-O" "chasen")) + (test* "(mecab-new '(\"-O\" \"chasen\"))" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "") + (test* "(mecab-new2 \"\"" '() (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "-Ochasen") + (test* "mecab?" #t (mecab? m)) + (test* "(mecab-new2 \"-Ochasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "-O chasen") + (test* "mecab?" #t (mecab? m)) + (test* "(mecab-new2 \"-O chasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "--output-format-type chasen") + (test* "mecab?" #t (mecab? m)) + (test* "(mecab-new2 \"--output-format-type chasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab-new2 "--output-format-type=chasen") + (test* "mecab?" #t (mecab? m)) + (test* "(mecab-new2 \"--output-format-type=chasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab "") + (test* "(mecab \"\") : mecab?" #t (mecab? m)) + (test* "(mecab \"\") : options" '() (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab "-Ochasen") + (test* "(mecab \"-Ochasen\") : mecab?" #t (mecab? m)) + (test* "(mecab \"-Ochasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab "-O chasen") + (test* "(mecab \"-O chasen\") : mecab?" #t (mecab? m)) + (test* "(mecab \"-O chasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab "-O" "chasen") + (test* "(mecab \"-O\" \"chasen\") : mecab?" #t (mecab? m)) + (test* "(mecab \"-O\" \"chasen\") : options" '((output-format-type chasen)) (mecab-options m)) + (mecab-destroy m)) +(let1 m (mecab :O 'chasen :l 1) + (test* "(mecab :O chasen :l 1) : mecab?" #t (mecab? m)) + (test* "(mecab :O chasen :l 1) : mecab-options" '((output-format-type chasen) (lattice-level 1)) (mecab-options m)) + (mecab-destroy m)) + +;; +;; APIs +;; +(test-section "mecab-new") +(let1 m (mecab-new '()) + (test* "is-a? " #t (is-a? m )) + (test* "mecab?" #t (mecab? m)) + + (test-section "mecab-destroy") + (test* "not destroyed yet" #f (mecab-destroyed? m)) + (mecab-destroy m) + (test* "destroyed" #t (mecab-destroyed? m)) + ) + +(test-section "mecab-new2") +(let1 m (mecab-new2 "") + (test* "is-a? " #t (is-a? m )) + (test* "mecab?" #t (mecab? m)) + (test* "options" '() (mecab-options m)) + (mecab-destroy m)) + +(test-section "mecab-version") +(test* "mecab-version" 1 + (rxmatch-num-matches + (#/^[0-9]+\.[0-9]+[.0-9A-Za-z]*$/ (mecab-version)))) + +(test-section "mecab-strerror") +(mecab-new2 "") +(test* "at mecab-new2 (ok)" "" (mecab-strerror #f)) + +(mecab-new2 "-d //") ;; => "tagger.cpp(149) [load_dictionary_resource(param)] param.cpp(71) [ifs] no such file or directory: //dicrc" +(test* "at mecab-new (err)" #f (string=? "" (mecab-strerror #f))) +(test* "no such file or directory" #f (not (#/no such file or directory/ (mecab-strerror #f)))) + +(let1 m (mecab-new2 "") + (mecab-sparse-tostr m "��Ĥ���") + (test* "noerr" "" (mecab-strerror m)) + (mecab-destroy m)) + +(let1 m (mecab-new2 "") + (test-section "mecab-get-partial / mecab-set-partial") + (test* "default partial mode [0|1]" #t + (and (memq (mecab-get-partial m) '(0 1)) #t)) + (mecab-set-partial m 1) + (test* "set to 1" 1 (mecab-get-partial m)) + (mecab-set-partial m 0) + (test* "set to 0" 0 (mecab-get-partial m)) + + (test-section "mecab-get-theta / mecab-set-theta") + (let1 theta (mecab-get-theta m) + (test* "default partial mode [0..1]" #t (and (number? theta) (<= 0.0 theta 1.0)))) + (mecab-set-theta m 1.0) + (test* "set to 1.0" 1.0 (mecab-get-theta m)) + (mecab-set-theta m 0.5) + (test* "set to 0.5" 0.5 (mecab-get-theta m)) + + (test-section "mecab-get-lattice-level / mecab-set-lattice-level") + (test* "default lattice-level [0|1|2]" #t + (and (memq (mecab-get-lattice-level m) '(0 1 2)) #t)) + (mecab-set-lattice-level m 1) + (test* "set to 1" 1 (mecab-get-lattice-level m)) + (mecab-set-lattice-level m 2) + (test* "set to 2" 2 (mecab-get-lattice-level m)) + (mecab-set-lattice-level m 0) + (test* "set to 0" 0 (mecab-get-lattice-level m)) + + (test-section "mecab-get-all-morphs / mecab-set-all-morphs") + (test* "default all-morphs [0|1]" #t + (and (memq (mecab-get-all-morphs m) '(0 1)) #t)) + (mecab-set-all-morphs m 1) + (test* "set to 1" 1 (mecab-get-all-morphs m)) + (mecab-set-all-morphs m 0) + (test* "set to 0" 0 (mecab-get-all-morphs m)) + ) (test-end) Index: /lang/scheme/gauche/bindings/mecab/trunk/Makefile.in =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/Makefile.in (revision 117) +++ /lang/scheme/gauche/bindings/mecab/trunk/Makefile.in (revision 131) @@ -1,4 +1,4 @@ # -# $Id: Makefile.in,v 1.3 2009/03/02 03:52:45 shirok Exp $ +# $Id: Makefile.in,v 1.4 2009/03/25 06:22:38 naoya_t Exp $ # @@ -55,4 +55,10 @@ $(GOSH) -I. -I$(srcdir) $(srcdir)/test.scm > test.log +# dictionary-dependent tests (optional) +check-dep : all + @rm -f test-dep-1.log test-dep-ipadic.log + $(GOSH) -I. -I$(srcdir) $(srcdir)/test-dep-1.scm > test-dep-1.log + $(GOSH) -I. -I$(srcdir) $(srcdir)/test-dep-ipadic.scm > test-dep-ipadic.log + install : all $(INSTALL) -m 444 -T $(GAUCHE_PKGINCDIR) $(HEADERS) Index: /lang/scheme/gauche/bindings/mecab/trunk/DIST =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/DIST (revision 131) +++ /lang/scheme/gauche/bindings/mecab/trunk/DIST (revision 131) @@ -0,0 +1,43 @@ +#!/bin/sh +# +# A helper script for developers. +# ./DIST gen : runs autoconf to generate 'configure' script. +# ./DIST tgz : creates a tarball. +# Assumes gnu tar. + +MODULE=Gauche-mecab + +while [ $# -gt 0 ]; do + case $1 in + gen) gen=yes; shift ;; + tgz) tgz=yes; shift ;; + *) echo "DIST gen|tgz"; exit 0;; + esac +done + +if [ "$gen" = "yes" ]; then + autoconf +fi + +if [ "$tgz" = "yes" ]; then + if [ -f Makefile ]; then make maintainer-clean; fi + ./DIST gen + ./configure + make distclean + + if [ ! -f VERSION ]; then echo "No VERSION; something wrong?"; exit 1; fi + VERSION=`cat VERSION` + + rm -f DIST_EXCLUDE_X + echo DIST > DIST_EXCLUDE_X + echo DIST_EXCLUDE_X >> DIST_EXCLUDE_X + if [ -f DIST_EXCLUDE ]; then cat DIST_EXCLUDE >> DIST_EXCLUDE_X; fi + find . -name CVS -print -prune >> DIST_EXCLUDE_X + + rm -rf ../$MODULE-$VERSION + + mkdir ../$MODULE-$VERSION + tar cvfX - DIST_EXCLUDE_X . | (cd ../$MODULE-$VERSION; tar xf -) + (cd ..; tar cvf - $MODULE-$VERSION | gzip -9 > $MODULE-$VERSION.tgz) + (cd ..; rm -rf $MODULE-$VERSION) +fi Index: /lang/scheme/gauche/bindings/mecab/trunk/test-dep-1.scm =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/test-dep-1.scm (revision 131) +++ /lang/scheme/gauche/bindings/mecab/trunk/test-dep-1.scm (revision 131) @@ -0,0 +1,37 @@ +;; -*- coding:euc-jp -*- +;; +;; dictionary-dependent tests for mecab module +;; + +(use gauche.test) + +(test-start "mecab: dictionary-dependent tests ") +(use text.mecab) +(test-module 'text.mecab) + +(define m (mecab-new2 "")) + +(test-section "mecab-sparse-tostr") +(test* "mecab-sparse-tostr" #f + (mecab-sparse-tostr m "�Ϻ�ϼ�Ϻ���������Ҥ�Ϥ�����")) +(test* "mecab-strerror" #t (string? (mecab-strerror m))) + +(test* "mecab-sparse-tostr" + "�Ϻ ̾����,*,*,�Ϻ,ï¿½ï¿½ï¿½í¤¦,*\n\ + �������*,*,����*\n\ + ��Ϻ ̾����,*,*,��Ϻ,ï¿½ï¿½ï¿½í¤¦,*\n\ + �� ���ʽ�*,*,��,��,*\n\ + ��ư��,�Ҳ�ư�쥿���������Ʒ����ä��ɽɽ��:�� + �������������,���ư�����������\n\ + � ̾���̾��,*,�,�ۤ���:�� �ɽɽ��:�\n\ + ����ʽ�*,*,��,*\n\ + �ֻ�̾����,*,*,�ֻ��Ϥʤ�,*\n\ + �����ʽ�*,*,����*\n\ + ����� ư��,�Ҳ�ư�쥵���������,�錄����,�°ư����ʴ���ɽɽ��:���\n\ + �� ����,*,*,��,��,*\n\ + EOS\n" + (mecab-sparse-tostr m "�Ϻ�ϼ�Ϻ���������Ҥ�Ϥ�����")) + +(mecab-destroy m) + +(test-end) Index: /lang/scheme/gauche/bindings/mecab/trunk/ChangeLog =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/ChangeLog (revision 119) +++ /lang/scheme/gauche/bindings/mecab/trunk/ChangeLog (revision 131) @@ -1,5 +1,12 @@ -2009-03-23 naoya_t +2009-03-25 Naoya Tozuka - * Merged naoya_t's MeCab binding. Supports almost all of MeCab APIs and Tagger class. + * Merged naoya_t's mecab-gauche-0.98pre1 (http://blog.livedoor.jp/naoya_t/archives/51131440.html) + * Supports: + * Tagger class + * Accessors for mecab_node_t structure members + * All MeCab APIs, except those which overwrite their argument: + mecab-sparse-tostr3, mecab-nbest-sparse-tostr3, mecab-nbest-next-tostr2 + * (mecab params ...) makes a new instance with parameter(s). The format is inspired by leque's (make-mecab :rcfile "mymecabrc") style. + * Separates dictionary-dependent tests from test.scm. 2009-03-01 Shiro Kawai @@ -10,3 +17,2 @@ - Index: /lang/scheme/gauche/bindings/mecab/trunk/mecab-lib.scm =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/mecab-lib.scm (revision 117) +++ /lang/scheme/gauche/bindings/mecab/trunk/mecab-lib.scm (revision 131) @@ -31,9 +31,10 @@ ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;; -;;; $Id: mecab-lib.scm,v 1.1 2009/03/02 03:52:45 shirok Exp $ +;;; $Id: mecab-lib.scm,v 1.3 2009/03/25 09:42:14 naoya_t Exp $ ;;; (define-module text.mecab (use srfi-1) + (use srfi-13) (use gauche.charconv) (export @@ -41,4 +42,5 @@ mecab-do mecab-new mecab-new2 mecab-version mecab-strerror mecab-destroy mecab-destroyed? + mecab mecab-options mecab-tagger ; message passing @@ -79,11 +81,12 @@ ;; This should be configurable, since mecab can be compiled to use utf-8. (define-constant MECAB_ENCODING 'euc-jp) -;(define-constant MECAB_ENCODING 'utf-8) - + +;; We need cv-send and cv-recv if MeCab is configured with --enable-utf8-only option. +;(define (cv-send str) +; (ces-convert str (gauche-character-encoding) MECAB_ENCODING)) +;(define (cv-recv str) +; (and str (ces-convert str MECAB_ENCODING))) (define (cv-send str) str) -; (ces-convert str (gauche-character-encoding) MECAB_ENCODING)) - (define (cv-recv str) str) -; (and str (ces-convert str MECAB_ENCODING))) (define (mecab-do args) @@ -95,36 +98,12 @@ (unless (every string? args) (error "mecab-new: list of strings required, but got:" args)) - (%mecab-new (map cv-send args))) + (%mecab-new (map cv-send args) (mecab-parse-options args))) (define (mecab-new2 str) - (%mecab-new2 (cv-send str))) + (%mecab-new2 (cv-send str) (mecab-parse-options str))) (define (mecab-strerror m) - (cv-recv (if m (%mecab-strerror m) - (%mecab-strerror-with-null)))) - -(define (mecab-get-partial m) - (%mecab-get-partial m)) - -(define (mecab-set-partial m partial) - (%mecab-set-partial m partial)) - -(define (mecab-get-theta m) - (%mecab-get-theta m)) - -(define (mecab-set-theta m theta) - (%mecab-set-theta m theta)) - -(define (mecab-get-lattice-level m) - (%mecab-get-lattice-level m)) - -(define (mecab-set-lattice-level m llevel) - (%mecab-set-lattice-level m llevel)) - -(define (mecab-get-all-morphs m) - (%mecab-get-all-morphs m)) - -(define (mecab-set-all-morphs m morphs) - (%mecab-set-all-morphs m morphs)) +; (cv-recv (%mecab-strerror m))) ;; m can be #f + (cv-recv (if m (%mecab-strerror m) (%mecab-strerror-with-null)))) (define (mecab-sparse-tostr m str) @@ -155,12 +134,6 @@ (cv-recv (%mecab-nbest-next-tostr m))) -(define (mecab-nbest-next-tonode m) - (%mecab-nbest-next-tonode m)) - (define (mecab-format-node m node) - (%mecab-format-node m node)) - -(define (mecab-dictionary-info m) - (%mecab-dictionary-info m)) + (cv-recv (%mecab-format-node m node))) (define (mecab-dict-index args) @@ -189,5 +162,5 @@ (%mecab-test-gen (map cv-send args))) -;; +;; mecab_node_t (define (mecab-node-surface n) (cv-recv (%mecab-node-surface n))) @@ -200,8 +173,10 @@ (%mecab-node-stat n))) +;; mecab_dictionary_info_t (define (mecab-dictionary-info-type dinfo) (vector-ref #(mecab-sys-dic mecab-usr-dic mecab-unk-dic) (%mecab-dictionary-info-type dinfo))) +;; (inline-stub "#include " @@ -211,14 +186,15 @@ SCM_HEADER; mecab_t *m; /* NULL if closed */ + ScmObj options; } ScmMeCab; typedef struct ScmMeCabNodeRec { SCM_HEADER; - mecab_node_t *node; + const mecab_node_t *node; } ScmMeCabNode; typedef struct ScmMeCabDictionaryInfoRec { SCM_HEADER; - mecab_dictionary_info_t *dic_info; + const mecab_dictionary_info_t *dic_info; } ScmMeCabDictionaryInfo;" @@ -240,18 +216,19 @@ (mecab-destroy (-> m m)) (set! (-> m m) NULL))) - + (define-cfn mecab-finalize (obj data::void*) ::void :static (mecab-cleanup (SCM_MECAB obj))) - (define-cfn make-mecab (m::mecab_t*) :static + (define-cfn make-mecab (m::mecab_t* options::ScmObj) :static (when (== m NULL) (mecab-strerror NULL)) (let* ([obj::ScmMeCab* (SCM_NEW ScmMeCab)]) (SCM_SET_CLASS obj (& Scm_MeCabClass)) (set! (-> obj m) m) + (set! (-> obj options) options) (Scm_RegisterFinalizer (SCM_OBJ obj) mecab-finalize NULL) (return (SCM_OBJ obj)))) - (define-cfn make-mecab-node (n::mecab_node_t*) :static -; (when (== node NULL) (mecab-strerror NULL)) + (define-cfn make-mecab-node (n::"const mecab_node_t*") :static + ;; returns #f when n==NULL ... for convenience of mecab_nbest_next_* (if (== n NULL) (return SCM_FALSE) (let* ([obj::ScmMeCabNode* (SCM_NEW ScmMeCabNode)]) @@ -260,6 +237,6 @@ (return (SCM_OBJ obj))))) - (define-cfn make-mecab-dictionary-info (dic_info::mecab_dictionary_info_t*) :static -; (when (== dic_info NULL) (mecab-strerror NULL)) + (define-cfn make-mecab-dictionary-info (dic_info::"const mecab_dictionary_info_t*") :static + ;; returns #f when dic_info==NULL ... for convenience of mecab-dictionary-info-next (if (== dic_info NULL) (return SCM_FALSE) (let* ([obj::ScmMeCabDictionaryInfo* (SCM_NEW ScmMeCabDictionaryInfo)]) @@ -278,11 +255,11 @@ (result (mecab-do argc argv)))) - (define-cproc %mecab-new (args::) + (define-cproc %mecab-new (args:: options) (let* ([argc::int (Scm_Length args)] [argv::char** (Scm_ListToCStringArray args TRUE NULL)]) - (result (make-mecab (mecab-new argc argv))))) - - (define-cproc %mecab-new2 (arg::) - (result (make-mecab (mecab-new2 (Scm_GetString arg))))) + (result (make-mecab (mecab-new argc argv) options)))) + + (define-cproc %mecab-new2 (arg:: options) + (result (make-mecab (mecab-new2 (Scm_GetString arg)) options))) (define-cproc mecab-version () :: mecab-version) @@ -294,8 +271,36 @@ (result (== (-> m m) NULL))) + (define-cproc mecab-options (m::) + (result (-> m options))) + (define-cproc %mecab-strerror (m::) :: (result (mecab-strerror (-> m m)))) + (define-cproc %mecab-strerror-with-null () :: (result (mecab-strerror NULL))) + + (define-cproc mecab-get-partial (m::) :: + (result (mecab-get-partial (-> m m)))) + + (define-cproc mecab-set-partial (m:: partial::) :: + (mecab-set-partial (-> m m) partial)) + + (define-cproc mecab-get-theta (m::) :: + (result (mecab-get-theta (-> m m)))) + + (define-cproc mecab-set-theta (m:: theta::) :: + (mecab-set-theta (-> m m) theta)) + + (define-cproc mecab-get-lattice-level (m::) :: + (result (mecab-get-lattice-level (-> m m)))) + + (define-cproc mecab-set-lattice-level (m:: level::) :: + (mecab-set-lattice-level (-> m m) level)) + + (define-cproc mecab-get-all-morphs (m::) :: + (result (mecab-get-all-morphs (-> m m)))) + + (define-cproc mecab-set-all-morphs (m:: all_morphs::) :: + (mecab-set-all-morphs (-> m m) all_morphs)) (define-cproc %mecab-sparse-tostr (m:: str::) @@ -315,21 +320,17 @@ (result (mecab-nbest-sparse-tostr2 (-> m m) n str len))) - (define-cproc %mecab-nbest-init (m:: str::) - :: + (define-cproc %mecab-nbest-init (m:: str::) :: (result (mecab-nbest-init (-> m m) str))) - (define-cproc %mecab-nbest-init2 (m:: str:: len::) - :: + (define-cproc %mecab-nbest-init2 (m:: str:: len::) :: (result (mecab-nbest-init2 (-> m m) str len))) - (define-cproc %mecab-nbest-next-tostr (m::) + (define-cproc %mecab-nbest-next-tostr (m::) ;; returns null at the end ; (result (mecab-nbest-next-tostr (-> m m)))) " const char *s = mecab_nbest_next_tostr(m->m); return s ? SCM_MAKE_STR_COPYING(s) : SCM_FALSE;") - (define-cproc %mecab-nbest-next-tonode (m::) + (define-cproc mecab-nbest-next-tonode (m::) ;; returns null at the end (result (make-mecab-node (mecab-nbest-next-tonode (-> m m))))) -;" mecab_node_t *node = mecab_nbest_next_tonode(m->m); -; return node ? make_mecab_node(node) : SCM_FALSE;") (define-cproc %mecab-sparse-tonode (m:: str::) @@ -339,41 +340,8 @@ (result (make-mecab-node (mecab-sparse-tonode2 (-> m m) str siz)))) - (define-cproc %mecab-dictionary-info (m::) + (define-cproc mecab-dictionary-info (m::) (result (make-mecab-dictionary-info (mecab-dictionary-info (-> m m))))) - (define-cproc %mecab-get-partial (m::) - :: - (result (mecab-get-partial (-> m m)))) - - (define-cproc %mecab-set-partial (m:: partial::) - :: - (mecab-set-partial (-> m m) partial)) - - (define-cproc %mecab-get-theta (m::) - :: - (result (mecab-get-theta (-> m m)))) - - (define-cproc %mecab-set-theta (m:: theta::) - :: - (mecab-set-theta (-> m m) theta)) - - (define-cproc %mecab-get-lattice-level (m::) - :: - (result (mecab-get-lattice-level (-> m m)))) - - (define-cproc %mecab-set-lattice-level (m:: level::) - :: - (mecab-set-lattice-level (-> m m) level)) - - (define-cproc %mecab-get-all-morphs (m::) - :: - (result (mecab-get-all-morphs (-> m m)))) - - (define-cproc %mecab-set-all-morphs (m:: all_morphs::) - :: - (mecab-set-all-morphs (-> m m) all_morphs)) - - (define-cproc %mecab-format-node (m:: n::) - ::? + (define-cproc %mecab-format-node (m:: n::) ::? (result (mecab-format-node (-> m m) (-> n node)))) @@ -407,85 +375,74 @@ ;; (define-cproc mecab-node-prev (n::) -" const mecab_node_t *prev_node = n->node->prev; - return prev_node ? make_mecab_node(prev_node) : SCM_FALSE;") + (result (make-mecab-node (-> (-> n node) prev)))) (define-cproc mecab-node-next (n::) -" const mecab_node_t *next_node = n->node->next; - return next_node ? make_mecab_node(next_node) : SCM_FALSE;") + (result (make-mecab-node (-> (-> n node) next)))) (define-cproc mecab-node-enext (n::) -" const mecab_node_t *enext_node = n->node->enext; - return enext_node ? make_mecab_node(enext_node) : SCM_FALSE;") + (result (make-mecab-node (-> (-> n node) enext)))) (define-cproc mecab-node-bnext (n::) -" const mecab_node_t *bnext_node = n->node->bnext; - return bnext_node ? make_mecab_node(bnext_node) : SCM_FALSE;") - -;; NULL terminate�������ޤ���������Ƽ��Ф��ˤ�;; strncpy(buf, node->feature, node->length) �Ȥ������������ + (result (make-mecab-node (-> (-> n node) bnext)))) + (define-cproc %mecab-node-surface (n::) - " char buf[n->node->length + 1]; - memcpy(buf, n->node->surface, n->node->length); - buf[n->node->length] = 0; - return SCM_MAKE_STR_COPYING(buf);"); - - (define-cproc %mecab-node-feature (n::) :: - (result (-> (-> n node) feature))) - - (define-cproc mecab-node-length (n::) :: - (result (-> (-> n node) length))) - - (define-cproc mecab-node-rlength (n::) :: - (result (-> (-> n node) rlength))) - - (define-cproc mecab-node-id (n::) :: - (result (-> (-> n node) id))) - - (define-cproc mecab-node-rc-attr (n::) :: - (result (-> (-> n node) rcAttr))) - - (define-cproc mecab-node-lc-attr (n::) :: - (result (-> (-> n node) lcAttr))) - - (define-cproc mecab-node-posid (n::) :: - (result (-> (-> n node) posid))) - - (define-cproc mecab-node-char-type (n::) :: - (result (-> (-> n node) char-type))) - - (define-cproc %mecab-node-stat (n::) :: - (result (-> (-> n node) stat))) - - (define-cproc mecab-node-best? (n::) :: - (result (-> (-> n node) isbest))) - - (define-cproc mecab-node-alpha (n::) :: - (result (-> (-> n node) alpha))) - - (define-cproc mecab-node-beta (n::) :: - (result (-> (-> n node) beta))) - - (define-cproc mecab-node-prob (n::) :: - (result (-> (-> n node) prob))) - - (define-cproc mecab-node-wcost (n::) :: - (result (-> (-> n node) wcost))) - - (define-cproc mecab-node-cost (n::) :: - (result (-> (-> n node) cost))) + (result (Scm-MakeString (-> (-> n node) surface) + (-> (-> n node) length) ;; size + -1 ;; Gauche will count the 'length' of this substring + SCM-STRING-COPYING))) + + (define-cproc %mecab-node-feature (n::) + :: (result (-> (-> n node) feature))) + + (define-cproc mecab-node-length (n::) + :: (result (-> (-> n node) length))) + + (define-cproc mecab-node-rlength (n::) + :: (result (-> (-> n node) rlength))) + + (define-cproc mecab-node-id (n::) + :: (result (-> (-> n node) id))) + + (define-cproc mecab-node-rc-attr (n::) + :: (result (-> (-> n node) rcAttr))) + + (define-cproc mecab-node-lc-attr (n::) + :: (result (-> (-> n node) lcAttr))) + + (define-cproc mecab-node-posid (n::) + :: (result (-> (-> n node) posid))) + + (define-cproc mecab-node-char-type (n::) + :: (result (-> (-> n node) char-type))) + + (define-cproc %mecab-node-stat (n::) + :: (result (-> (-> n node) stat))) + + (define-cproc mecab-node-best? (n::) + :: (result (-> (-> n node) isbest))) + + (define-cproc mecab-node-alpha (n::) + :: (result (-> (-> n node) alpha))) + + (define-cproc mecab-node-beta (n::) + :: (result (-> (-> n node) beta))) + + (define-cproc mecab-node-prob (n::) + :: (result (-> (-> n node) prob))) + + (define-cproc mecab-node-wcost (n::) + :: (result (-> (-> n node) wcost))) + + (define-cproc mecab-node-cost (n::) + :: (result (-> (-> n node) cost))) ;; ;; mecab_dictionary_info_t ;; -;; #define MECAB_USR_DIC 1 -;; #define MECAB_SYS_DIC 0 -;; #define MECAB_UNK_DIC 2 -;; (define-cproc mecab-dictionary-info-filename (dinfo::) - :: - (result (-> (-> dinfo dic_info) filename))) + :: (result (-> (-> dinfo dic_info) filename))) (define-cproc mecab-dictionary-info-charset (dinfo::) - :: - (result (-> (-> dinfo dic_info) charset))) + :: (result (-> (-> dinfo dic_info) charset))) (define-cproc mecab-dictionary-info-size (dinfo::) @@ -514,5 +471,5 @@ (define-method write-object ((m ) out) - (format out "#")); (mecab-version))) + (format out "#" (mecab-options m))) (define-method write-object ((m ) out) (format out "#")) @@ -520,32 +477,135 @@ (format out "#")) -(define-reader-ctor ' mecab-new2) - -(define (mecab-tagger paramstr) - (let1 mecabobj (mecab-new2 paramstr) +(define *mecab-options+* + '((r rcfile FILE) + (d dicdir DIR) + (u userdic FILE) + (l lattice-level INT) + (D dictionary-info) + (a all-morphs) + (O output-format-type TYPE) + (p partial) + (F node-format STR) + (U unk-format STR) + (B bos-format STR) + (E eos-format STR) + (x unk-feature STR) + (b input-buffer-size INT) + (P dump-config) + (M open-mutable-dictionary) + (C allocate-sentence) + (N nbest INT) + (t theta FLOAT) + (c cost-factor INT) + (o output FILE) + (v version) + (h help))) + +(define *mecab-options* (map cdr *mecab-options+*)) + +(define (cast argtype obj) + (case argtype + [(STR DIR FILE) (x->string obj)] + [(INT FLOAT) obj] + [(TYPE) (string->symbol (x->string obj))] + [else obj])) + +(define (requires-arg? option) + (let1 opt (assoc option *mecab-options*) + (if opt (= 2 (length opt)) #f))) + +(define (argtype option) + (cadr (or (assoc option *mecab-options*) (list #f #f)))) + +(define (long-option-name short-option-name) + (cadr (or (assoc short-option-name *mecab-options+*) (list #f #f)))) + +(define (keyword-length keyword) + (string-length (keyword->string keyword))) + +(define (keyword->symbol keyword) + (string->symbol (keyword->string keyword))) + +(define (mecab-parse-options args) + ;; eg. ("-Ochasen" :l 1 "--theta" "0.75") + ;; => (:output-format-type "chasen" :lattice-level 1 :theta "0.75") + (let1 args* (append-map + (lambda (arg) + (cond [(string? arg) + (if (string=? "" arg) '() + (append-map + (lambda (str) + (let1 len (string-length str) + (if (<= 2 len) + (if (eq? #\- (string-ref str 0)) + ;; --option, -X[arg] + (if (eq? #\- (string-ref str 1)) + ;; --option + (list (string->symbol (substring str 2 len))) + ;; -X[arg] + (let1 option (long-option-name (string->symbol (substring str 1 2))) + (if (= len 2) + ;; -X + (list option) + ;; -Xarg + (list option (cast (argtype option) (substring str 2 len)))))) + (list str)) + (list str)))) + (string-split arg #[ =])))] + [(keyword? arg) + (if (= 1 (keyword-length arg)) + (list (long-option-name (keyword->symbol arg))) + (list (keyword->symbol arg)))] + [else + (list arg)])) + (if (list? args) args (list args))) + ;; eg. (:output-format-type "chasen" :lattice-level 1 :theta "0.75") + ;; => ((output-format-type chasen) (lattice-level 1) (theta 0.75)) + (let loop ((rest args*) (options '())) + (if (null? rest) + (reverse! options) + (let1 option (car rest) + (if (symbol? option) + (if (requires-arg? option) + (loop (cddr rest) (cons (list option (cast (argtype option) (cadr rest))) options)) + (loop (cdr rest) (cons (list option (if #f #f)) options))) + (loop (cdr rest) options))))))) + +(define (mecab . args) ;; inspired by leque's make-mecab + (let* ([options (mecab-parse-options args)] + [options-str (append-map (lambda (option+arg) + (let* ([option (car option+arg)] + [option-str (format "--~a" option)]) + (if (requires-arg? option) + (list option-str (x->string (cadr option+arg))) + (list option-str) ))) + options)]) + (%mecab-new options-str options))) + +(define-reader-ctor 'mecab mecab) + +;; Tagger +(define (mecab-tagger . args) + (let1 m (apply mecab args) (define (parse-to-string str . args) (let-optionals* args ((len #f)) (if len - (mecab-sparse-tostr2 mecabobj str len) - (mecab-sparse-tostr mecabobj str) ))) - - (define (parse-to-node str) - (mecab-sparse-tonode mecabobj str)) - - ;; ���ε�ǽ������� ��ư�����ץ����Ȥ���-l 1 ��ꤹ����������� - (define (parse-nbest n str) - (mecab-nbest-sparse-tostr mecabobj n str)) - - (define (parse-nbest-init str) - (mecab-nbest-init mecabobj str)) - - (define (next) - (mecab-nbest-next-tostr mecabobj)) - - (define (next-node) - (mecab-nbest-next-tonode mecabobj)) - - (define (format-node node) - (mecab-format-node mecabobj node)) + (mecab-sparse-tostr2 m str len) + (mecab-sparse-tostr m str) ))) + + (define (parse-to-node str) (mecab-sparse-tonode m str)) + + ;; requires "-l 1" in option + (define (parse-nbest n str) (mecab-nbest-sparse-tostr m n str)) + + (define (parse-nbest-init str) (mecab-nbest-init m str)) + + (define (next) (mecab-nbest-next-tostr m)) + + (define (next-node) (mecab-nbest-next-tonode m)) + + (define (format-node node) (mecab-format-node m node)) + + (define (destroy) (mecab-destroy m)) (lambda (m) @@ -558,35 +618,50 @@ [(next-node) next-node] [(format-node) format-node] + [(destroy) destroy] )))) -;;; class -(define-class () (mecab #f)) +(define-class () (m #f)) + (define (mecab-make-tagger paramstr) - (make :mecab (mecab-new2 paramstr))) -(define (tagger-mecab tagger) (slot-ref tagger 'mecab)) + (make :mecab (mecab paramstr))) + +(define (tagger-mecab tagger) (slot-ref tagger 'm)) + (define-method parse ((tagger ) (str )) (mecab-sparse-tostr (tagger-mecab tagger) str)) + (define-method parse ((tagger ) (str ) (len )) (mecab-sparse-tostr2 (tagger-mecab tagger) str len)) + (define-method parse-to-string ((tagger ) (str )) (mecab-sparse-tostr (tagger-mecab tagger) str)) + (define-method parse-to-string ((tagger ) (str ) (len )) (mecab-sparse-tostr (tagger-mecab tagger) str len)) + (define-method parse-to-node ((tagger ) (str )) (mecab-sparse-tonode (tagger-mecab tagger) str)) + (define-method parse-to-node ((tagger ) (str ) (len )) (mecab-sparse-tonode2 (tagger-mecab tagger) str len)) + (define-method parse-nbest ((tagger ) (n ) (str )) (mecab-nbest-sparse-tostr (tagger-mecab tagger) str)) + (define-method parse-nbest ((tagger ) (n ) (str ) (len )) (mecab-nbest-sparse-tostr (tagger-mecab tagger) str len)) + (define-method parse-nbest-init ((tagger ) (str )) (mecab-nbest-init (tagger-mecab tagger) str)) + (define-method parse-nbest-init ((tagger ) (str ) (len )) (mecab-nbest-init (tagger-mecab tagger) str len)) + (define-method next ((tagger )) (mecab-nbest-next-tostr (tagger-mecab tagger))) + (define-method next-node ((tagger )) (mecab-nbest-next-tonode (tagger-mecab tagger))) + (define-method format-node ((tagger ) (node )) (mecab-format-node (tagger-mecab tagger) node)) Index: /lang/scheme/gauche/bindings/mecab/trunk/test-dep-ipadic.scm =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/test-dep-ipadic.scm (revision 131) +++ /lang/scheme/gauche/bindings/mecab/trunk/test-dep-ipadic.scm (revision 131) @@ -0,0 +1,325 @@ +;; -*- coding:euc-jp -*- +;; +;; dictionary-dependent tests for mecab module +;; +;; using mecab-0.98pre1 +;; + mecab-ipadic-2.7.0-20070801 +;; +;; written by naoya_t + +(use gauche.test) + +(test-start "mecab: dictionary-dependent tests : ipadic") +(use text.mecab) +(test-module 'text.mecab) + +(let1 m (mecab-new2 "") + (test-section "mecab-sparse-tostr") + (test* "��Ĥ���" + (string-join '("������,*,*,*,*,������� "��\t���ʽ���,*,*,*,��,��,��" + "���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������" + "��\t�����,*,*,*,*,��,��,��" + "EOS" + "") "\n") + (mecab-sparse-tostr m "��Ĥ���")) + + (test-section "mecab-sparse-tostr2") + (test* "\"��Ĥ���\", len=6" + (string-join '("������,*,*,*,*,������� "��\t���ʽ���,*,*,*,��,��,��" + "EOS" + "") "\n") + (mecab-sparse-tostr2 m "��Ĥ���" 6)) + + (test-section "mecab-sparse-tonode, mecab-node-***") + (let1 node (mecab-sparse-tonode m "��Ĥ���") + (test* "mecab-node?" #t (mecab-node? node)) + (test* "no previous node" #f (mecab-node-prev node)) + (test* "next node" #t (mecab-node? (mecab-node-next node))) + (test* "enext" #f (mecab-node? (mecab-node-enext node))) + (test* "bnext" #f (mecab-node? (mecab-node-bnext node))) + (test* "surface" "" (mecab-node-surface node)) + (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) + (test* "length" 0 (mecab-node-length node)) + (test* "rlength" 0 (mecab-node-rlength node)) + (test* "id" 0 (mecab-node-id node)) + (test* "rc-attr" 0 (mecab-node-rc-attr node)) + (test* "lc-attr" 0 (mecab-node-lc-attr node)) + (test* "posid" 0 (mecab-node-posid node)) + (test* "char-type" 0 (mecab-node-char-type node)) + (test* "stat" 'mecab-bos-node (mecab-node-stat node)) + (test* "best?" #t (mecab-node-best? node)) + (test* "alpha" 0.0 (mecab-node-alpha node)) + (test* "beta" 0.0 (mecab-node-beta node)) + (test* "prob" 0.0 (mecab-node-prob node)) + (test* "wcost" 0 (mecab-node-wcost node)) + (test* "cost" 0 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "previous node" #t (mecab-node? (mecab-node-prev node))) + (test* "next node" #t (mecab-node? (mecab-node-next node))) + (test* "enext" #t (mecab-node? (mecab-node-enext node))) + (test* "bnext" #f (mecab-node? (mecab-node-bnext node))) + (test* "surface" "��mecab-node-surface node)) + (test* "feature" "̾���,*,*,*,*,�������(mecab-node-feature node)) + (test* "length" 3 (mecab-node-length node)) + (test* "rlength" 3 (mecab-node-rlength node)) + (test* "id" 1 (mecab-node-id node)) + (test* "rc-attr" 1285 (mecab-node-rc-attr node)) + (test* "lc-attr" 1285 (mecab-node-lc-attr node)) + (test* "posid" 38 (mecab-node-posid node)) + (test* "char-type" 2 (mecab-node-char-type node)) + (test* "stat" 'mecab-nor-node (mecab-node-stat node)) + (test* "best?" #t (mecab-node-best? node)) + (test* "alpha" 0.0 (mecab-node-alpha node)) + (test* "beta" 0.0 (mecab-node-beta node)) + (test* "prob" 0.0 (mecab-node-prob node)) + (test* "wcost" 7439 (mecab-node-wcost node)) + (test* "cost" 7156 (mecab-node-cost node)) + ) + + (test-section "mecab-sparse-tonode2") + (let1 node (mecab-sparse-tonode2 m "��Ĥ���" 6) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) + (test* "stat" 'mecab-bos-node (mecab-node-stat node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "surface" "��mecab-node-surface node)) + (test* "feature" "̾���,*,*,*,*,�������(mecab-node-feature node)) + (test* "stat" 'mecab-nor-node (mecab-node-stat node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "surface" "��" (mecab-node-surface node)) + (test* "feature" "���ʽ���,*,*,*,��,��,��" (mecab-node-feature node)) + (test* "stat" 'mecab-nor-node (mecab-node-stat node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) + (test* "stat" 'mecab-eos-node (mecab-node-stat node)) + (test* "no next node" #f (mecab-node-next node)) + ) +; (test-section "mecab-format-node") +; (let1 node (mecab-sparse-tonode m "��Ĥ���") +; (test* "BOS" "" (mecab-format-node mecab node))) + (mecab-destroy m)) + +(let ([m (mecab-new2 "-l 1")] ;; + [input "��Ĥ���"]) + (test-section "mecab-nbest-sparse-tostr") + (test* #`",|input|, N=1" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-sparse-tostr m 1 input)) + (test* #`",|input|, N=2" + (string-append + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + ) + (mecab-nbest-sparse-tostr m 2 input)) + (test* #`",|input|, N=3" + (string-append + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + ) + (mecab-nbest-sparse-tostr m 3 input)) + + (test-section "mecab-nbest-sparse-tostr2") + (test* #`",|input|, N=1" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-sparse-tostr2 m 1 input 6)) + (test* #`",|input|, N=2" + (string-append + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + ) + (mecab-nbest-sparse-tostr2 m 2 input 6)) + (test* #`",|input|, N=3" + (string-append + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\nEOS\n" + ) + (mecab-nbest-sparse-tostr2 m 3 input 6)) + + (test-section "mecab-nbest-init") + (test* "init" 1 (mecab-nbest-init m input)) + (test-section "mecab-nbest-next-tostr") + (test* "#1" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#2" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#3" + "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#4" + "������,*,*,*,*,���������\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#5" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#6" + "������,*,*,*,*,���������\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#7" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#8" + "������,*,*,*,*,���������\t�³��,*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#9" + "������,*,*,*,*,����,����\n��\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#10" + "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (dotimes (i 733) + (mecab-nbest-next-tostr m)) + (test* "#744" + "������,*,*,*,*,����,����\n��\tư����,��ʡ���,�������죲,�����,��\n�\t̾����̾��ϰ��,*,*,�,����,����\n��\tư����,*,*,��,̤��������,��\n��\t̾�����³,*,*,*,*,*\nEOS\n" + (mecab-nbest-next-tostr m)) + ;; no more results... + (test* "#745" #f (mecab-nbest-next-tostr m)) + (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) + + (test-section "mecab-nbest-init2") + (test* "init2" 1 (mecab-nbest-init2 m input 6)) + (test* "#1" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#2" + "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (test* "#3" + "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\nEOS\n" + (mecab-nbest-next-tostr m)) + (dotimes (i 8) (mecab-nbest-next-tostr m)) + (test* "#12" + "������,*,*,*,*,����,����\n��\tư����,��ʡ���,�������죲,�����,��\nEOS\n" + (mecab-nbest-next-tostr m)) + ;; no more results... + (test* "#13" #f (mecab-nbest-next-tostr m)) + (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) + + (test-section "mecab-nbest-next-tonode") + (mecab-nbest-init m input) + (test* "#1" #t (mecab-node? (mecab-nbest-next-tonode m))) + (dotimes (i 742) (mecab-nbest-next-tonode m)) + (test* "#744" #t (mecab-node? (mecab-nbest-next-tonode m))); EOS + ;; no more results... + (test* "#745" #f (mecab-node? (mecab-nbest-next-tonode m))) + (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) + + (mecab-destroy m)) + +;; +;; these values below may differ !!! +(test-section "mecab-dictionary-info, mecab-dictionary-info-***") +(let* ([m (mecab-new2 "")] + [dinfo (mecab-dictionary-info m)]) + (test* "mecab-dictionary-info?" #t (mecab-dictionary-info? dinfo)) + (test* "mecab-dictionary-info-filename" + "/usr/local/lib/mecab/dic/ipadic/sys.dic" (mecab-dictionary-info-filename dinfo)) + (test* "mecab-dictionary-info-charset" + "utf8" (mecab-dictionary-info-charset dinfo)) + (test* "mecab-dictionary-info-size" + 392126 (mecab-dictionary-info-size dinfo)) + (test* "mecab-dictionary-info-type" 'mecab-sys-dic (mecab-dictionary-info-type dinfo)) + (test* "mecab-dictionary-info-lsize" + 1316 (mecab-dictionary-info-lsize dinfo)) + (test* "mecab-dictionary-info-rsize" + 1316 (mecab-dictionary-info-rsize dinfo)) + (test* "mecab-dictionary-info-version" + 102 (mecab-dictionary-info-version dinfo)) +; (let1 next-dinfo (mecab-dictionary-info-next dinfo) +; (test* "has next?" #t (mecab-dictionary-info? next-dinfo))) + (mecab-destroy m)) + + +;;;;;;;;;; +;; +;; TO DO +;; +;;(test-section "mecab-do") +;;(test-section "mecab-dict-index") +;;(test-section "mecab-dict-gen") +;;(test-section "mecab-cost-train") +;;(test-section "mecab-system-eval") +;;(test-section "mecab-test-gen") + +;;; +;;; tagger (message passing) +;;; +(test-section "tagger") +(let1 tagger (mecab-tagger "-l 1") + (test* "tagger'parse-to-string" + (string-join '("���\t̾���ǽ,*,*,*,*,���,���祦,���硼" + "��������*,*,*,*,���� "��\tư���Ω,*,*,������������������,��" + "�ʤ�\t���,*,*,��졦�ʥ�,����ʤ�,�ʥ�,�ʥ�" + "��t���³��*,*,*,*,������ + "��t������*,*,*,*,������ + "EOS" + "") "\n") + ([tagger'parse-to-string] "����⤷�ʤ��Ȥ�)) + + (let1 node ([tagger'parse-to-node] "����⤷�ʤ��Ȥ�) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "" (mecab-node-surface node)) + (test* "mecab-node-feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) + (test* "mecab-node-cost" 0 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "���" (mecab-node-surface node)) + (test* "mecab-node-feature" "̾���ǽ,*,*,*,*,���,���祦,���硼" (mecab-node-feature node)) + (test* "mecab-node-cost" 3947 (mecab-node-cost node)) + ;;(test* "format-node" "" ([tagger'format-node] node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "��(mecab-node-surface node)) + (test* "mecab-node-feature" "������*,*,*,*,����(mecab-node-feature node)) + (test* "mecab-node-cost" 5553 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "��" (mecab-node-surface node)) + (test* "mecab-node-feature" "ư���Ω,*,*,������������������,��" (mecab-node-feature node)) + (test* "mecab-node-cost" 11566 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "�ʤ�" (mecab-node-surface node)) + (test* "mecab-node-feature" "���,*,*,��졦�ʥ�,����ʤ�,�ʥ�,�ʥ�" (mecab-node-feature node)) + (test* "mecab-node-cost" 3601 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "�� (mecab-node-surface node)) + (test* "mecab-node-feature" "���³��*,*,*,*,������ (mecab-node-feature node)) + (test* "mecab-node-cost" 4716 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "�� (mecab-node-surface node)) + (test* "mecab-node-feature" "������*,*,*,*,������ (mecab-node-feature node)) + (test* "mecab-node-cost" 10676 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #t (mecab-node? node)) + (test* "mecab-node-surface" "" (mecab-node-surface node)) + (test* "mecab-node-feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) + (test* "mecab-node-cost" 8292 (mecab-node-cost node)) + + (set! node (mecab-node-next node)) + (test* "mecab-node?" #f (mecab-node? node)) + + (tagger'destroy) + )) + +(test-end) Index: /ng/scheme/gauche/bindings/mecab/trunk/configure =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/configure (revision 117) +++ (revision ) @@ -1,2892 +1,0 @@ -#! /bin/sh -# Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.61 for Gauche-mecab 1.0. -# -# Report bugs to . -# -# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. -# This configure script is free software; the Free Software Foundation -# gives unlimited permission to copy, distribute and modify it. -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## - -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' - else - PATH_SEPARATOR=: - fi - rm -f conf$$.sh -fi - -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -as_nl=' -' -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } -fi - -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - fi -done - -# Required to use basename. -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - - -# Name of the executable. -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# CDPATH. -$as_unset CDPATH - - -if test "x$CONFIG_SHELL" = x; then - if (eval ":") 2>/dev/null; then - as_have_required=yes -else - as_have_required=no -fi - - if test $as_have_required = yes && (eval ": -(as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test \$exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=\$LINENO - as_lineno_2=\$LINENO - test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" && - test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; } -") 2> /dev/null; then - : -else - as_candidate_shells= - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - case $as_dir in - /*) - for as_base in sh bash ksh sh5; do - as_candidate_shells="$as_candidate_shells $as_dir/$as_base" - done;; - esac -done -IFS=$as_save_IFS - - - for as_shell in $as_candidate_shells $SHELL; do - # Try only shells that exist, to save several forks. - if { test -f "$as_shell" || test -f "$as_shell.exe"; } && - { ("$as_shell") 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - -: -_ASEOF -}; then - CONFIG_SHELL=$as_shell - as_have_required=yes - if { "$as_shell" 2> /dev/null <<\_ASEOF -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - -: -(as_func_return () { - (exit $1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = "$1" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test $exitcode = 0) || { (exit 1); exit 1; } - -( - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; } - -_ASEOF -}; then - break -fi - -fi - - done - - if test "x$CONFIG_SHELL" != x; then - for as_var in BASH_ENV ENV - do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - done - export CONFIG_SHELL - exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"} -fi - - - if test $as_have_required = no; then - echo This script requires a shell more modern than all the - echo shells that I found on your system. Please install a - echo modern shell, or manually run the script under such a - echo shell if you do have one. - { (exit 1); exit 1; } -fi - - -fi - -fi - - - -(eval "as_func_return () { - (exit \$1) -} -as_func_success () { - as_func_return 0 -} -as_func_failure () { - as_func_return 1 -} -as_func_ret_success () { - return 0 -} -as_func_ret_failure () { - return 1 -} - -exitcode=0 -if as_func_success; then - : -else - exitcode=1 - echo as_func_success failed. -fi - -if as_func_failure; then - exitcode=1 - echo as_func_failure succeeded. -fi - -if as_func_ret_success; then - : -else - exitcode=1 - echo as_func_ret_success failed. -fi - -if as_func_ret_failure; then - exitcode=1 - echo as_func_ret_failure succeeded. -fi - -if ( set x; as_func_ret_success y && test x = \"\$1\" ); then - : -else - exitcode=1 - echo positional parameters were not saved. -fi - -test \$exitcode = 0") || { - echo No shell found that supports shell functions. - echo Please tell autoconf@gnu.org about your system, - echo including any error possibly output before this - echo message -} - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in --n*) - case `echo 'x\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; - esac;; -*) - ECHO_N='-n';; -esac - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - -if mkdir -p . 2>/dev/null; then - as_mkdir_p=: -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - - -exec 7<&0 &1 - -# Name of the host. -# hostname on some systems (SVR3.2, Linux) returns a bogus exit status, -# so uname gets run too. -ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` - -# -# Initializations. -# -ac_default_prefix=/usr/local -ac_clean_files= -ac_config_libobj_dir=. -LIBOBJS= -cross_compiling=no -subdirs= -MFLAGS= -MAKEFLAGS= -SHELL=${CONFIG_SHELL-/bin/sh} - -# Identity of this package. -PACKAGE_NAME='Gauche-mecab' -PACKAGE_TARNAME='gauche-mecab' -PACKAGE_VERSION='1.0' -PACKAGE_STRING='Gauche-mecab 1.0' -PACKAGE_BUGREPORT='shiro@acm.org' - -ac_subst_vars='SHELL -PATH_SEPARATOR -PACKAGE_NAME -PACKAGE_TARNAME -PACKAGE_VERSION -PACKAGE_STRING -PACKAGE_BUGREPORT -exec_prefix -prefix -program_transform_name -bindir -sbindir -libexecdir -datarootdir -datadir -sysconfdir -sharedstatedir -localstatedir -includedir -oldincludedir -docdir -infodir -htmldir -dvidir -pdfdir -psdir -libdir -localedir -mandir -DEFS -ECHO_C -ECHO_N -ECHO_T -LIBS -build_alias -host_alias -target_alias -LOCAL_PATHS -GOSH -GAUCHE_CONFIG -GAUCHE_PACKAGE -GAUCHE_INSTALL -GAUCHE_CESCONV -SOEXT -OBJEXT -EXEEXT -GAUCHE_PKGINCDIR -GAUCHE_PKGLIBDIR -GAUCHE_PKGARCHDIR -LIBOBJS -LTLIBOBJS' -ac_subst_files='' - ac_precious_vars='build_alias -host_alias -target_alias' - - -# Initialize some variables set by options. -ac_init_help= -ac_init_version=false -# The variables have the same names as the options, with -# dashes changed to underlines. -cache_file=/dev/null -exec_prefix=NONE -no_create= -no_recursion= -prefix=NONE -program_prefix=NONE -program_suffix=NONE -program_transform_name=s,x,x, -silent= -site= -srcdir= -verbose= -x_includes=NONE -x_libraries=NONE - -# Installation directory options. -# These are left unexpanded so users can "make install exec_prefix=/foo" -# and all the variables that are supposed to be based on exec_prefix -# by default will actually change. -# Use braces instead of parens because sh, perl, etc. also accept them. -# (The list follows the same order as the GNU Coding Standards.) -bindir='${exec_prefix}/bin' -sbindir='${exec_prefix}/sbin' -libexecdir='${exec_prefix}/libexec' -datarootdir='${prefix}/share' -datadir='${datarootdir}' -sysconfdir='${prefix}/etc' -sharedstatedir='${prefix}/com' -localstatedir='${prefix}/var' -includedir='${prefix}/include' -oldincludedir='/usr/include' -docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' -infodir='${datarootdir}/info' -htmldir='${docdir}' -dvidir='${docdir}' -pdfdir='${docdir}' -psdir='${docdir}' -libdir='${exec_prefix}/lib' -localedir='${datarootdir}/locale' -mandir='${datarootdir}/man' - -ac_prev= -ac_dashdash= -for ac_option -do - # If the previous option needs an argument, assign it. - if test -n "$ac_prev"; then - eval $ac_prev=\$ac_option - ac_prev= - continue - fi - - case $ac_option in - *=*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; - *) ac_optarg=yes ;; - esac - - # Accept the important Cygnus configure options, so we can diagnose typos. - - case $ac_dashdash$ac_option in - --) - ac_dashdash=yes ;; - - -bindir | --bindir | --bindi | --bind | --bin | --bi) - ac_prev=bindir ;; - -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) - bindir=$ac_optarg ;; - - -build | --build | --buil | --bui | --bu) - ac_prev=build_alias ;; - -build=* | --build=* | --buil=* | --bui=* | --bu=*) - build_alias=$ac_optarg ;; - - -cache-file | --cache-file | --cache-fil | --cache-fi \ - | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) - ac_prev=cache_file ;; - -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ - | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) - cache_file=$ac_optarg ;; - - --config-cache | -C) - cache_file=config.cache ;; - - -datadir | --datadir | --datadi | --datad) - ac_prev=datadir ;; - -datadir=* | --datadir=* | --datadi=* | --datad=*) - datadir=$ac_optarg ;; - - -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ - | --dataroo | --dataro | --datar) - ac_prev=datarootdir ;; - -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ - | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) - datarootdir=$ac_optarg ;; - - -disable-* | --disable-*) - ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=no ;; - - -docdir | --docdir | --docdi | --doc | --do) - ac_prev=docdir ;; - -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) - docdir=$ac_optarg ;; - - -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) - ac_prev=dvidir ;; - -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) - dvidir=$ac_optarg ;; - - -enable-* | --enable-*) - ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid feature name: $ac_feature" >&2 - { (exit 1); exit 1; }; } - ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'` - eval enable_$ac_feature=\$ac_optarg ;; - - -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ - | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ - | --exec | --exe | --ex) - ac_prev=exec_prefix ;; - -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ - | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ - | --exec=* | --exe=* | --ex=*) - exec_prefix=$ac_optarg ;; - - -gas | --gas | --ga | --g) - # Obsolete; use --with-gas. - with_gas=yes ;; - - -help | --help | --hel | --he | -h) - ac_init_help=long ;; - -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) - ac_init_help=recursive ;; - -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) - ac_init_help=short ;; - - -host | --host | --hos | --ho) - ac_prev=host_alias ;; - -host=* | --host=* | --hos=* | --ho=*) - host_alias=$ac_optarg ;; - - -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) - ac_prev=htmldir ;; - -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ - | --ht=*) - htmldir=$ac_optarg ;; - - -includedir | --includedir | --includedi | --included | --include \ - | --includ | --inclu | --incl | --inc) - ac_prev=includedir ;; - -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ - | --includ=* | --inclu=* | --incl=* | --inc=*) - includedir=$ac_optarg ;; - - -infodir | --infodir | --infodi | --infod | --info | --inf) - ac_prev=infodir ;; - -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) - infodir=$ac_optarg ;; - - -libdir | --libdir | --libdi | --libd) - ac_prev=libdir ;; - -libdir=* | --libdir=* | --libdi=* | --libd=*) - libdir=$ac_optarg ;; - - -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ - | --libexe | --libex | --libe) - ac_prev=libexecdir ;; - -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ - | --libexe=* | --libex=* | --libe=*) - libexecdir=$ac_optarg ;; - - -localedir | --localedir | --localedi | --localed | --locale) - ac_prev=localedir ;; - -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) - localedir=$ac_optarg ;; - - -localstatedir | --localstatedir | --localstatedi | --localstated \ - | --localstate | --localstat | --localsta | --localst | --locals) - ac_prev=localstatedir ;; - -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ - | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) - localstatedir=$ac_optarg ;; - - -mandir | --mandir | --mandi | --mand | --man | --ma | --m) - ac_prev=mandir ;; - -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) - mandir=$ac_optarg ;; - - -nfp | --nfp | --nf) - # Obsolete; use --without-fp. - with_fp=no ;; - - -no-create | --no-create | --no-creat | --no-crea | --no-cre \ - | --no-cr | --no-c | -n) - no_create=yes ;; - - -no-recursion | --no-recursion | --no-recursio | --no-recursi \ - | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) - no_recursion=yes ;; - - -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ - | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ - | --oldin | --oldi | --old | --ol | --o) - ac_prev=oldincludedir ;; - -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ - | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ - | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) - oldincludedir=$ac_optarg ;; - - -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) - ac_prev=prefix ;; - -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) - prefix=$ac_optarg ;; - - -program-prefix | --program-prefix | --program-prefi | --program-pref \ - | --program-pre | --program-pr | --program-p) - ac_prev=program_prefix ;; - -program-prefix=* | --program-prefix=* | --program-prefi=* \ - | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) - program_prefix=$ac_optarg ;; - - -program-suffix | --program-suffix | --program-suffi | --program-suff \ - | --program-suf | --program-su | --program-s) - ac_prev=program_suffix ;; - -program-suffix=* | --program-suffix=* | --program-suffi=* \ - | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) - program_suffix=$ac_optarg ;; - - -program-transform-name | --program-transform-name \ - | --program-transform-nam | --program-transform-na \ - | --program-transform-n | --program-transform- \ - | --program-transform | --program-transfor \ - | --program-transfo | --program-transf \ - | --program-trans | --program-tran \ - | --progr-tra | --program-tr | --program-t) - ac_prev=program_transform_name ;; - -program-transform-name=* | --program-transform-name=* \ - | --program-transform-nam=* | --program-transform-na=* \ - | --program-transform-n=* | --program-transform-=* \ - | --program-transform=* | --program-transfor=* \ - | --program-transfo=* | --program-transf=* \ - | --program-trans=* | --program-tran=* \ - | --progr-tra=* | --program-tr=* | --program-t=*) - program_transform_name=$ac_optarg ;; - - -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) - ac_prev=pdfdir ;; - -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) - pdfdir=$ac_optarg ;; - - -psdir | --psdir | --psdi | --psd | --ps) - ac_prev=psdir ;; - -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) - psdir=$ac_optarg ;; - - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - silent=yes ;; - - -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) - ac_prev=sbindir ;; - -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ - | --sbi=* | --sb=*) - sbindir=$ac_optarg ;; - - -sharedstatedir | --sharedstatedir | --sharedstatedi \ - | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ - | --sharedst | --shareds | --shared | --share | --shar \ - | --sha | --sh) - ac_prev=sharedstatedir ;; - -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ - | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ - | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ - | --sha=* | --sh=*) - sharedstatedir=$ac_optarg ;; - - -site | --site | --sit) - ac_prev=site ;; - -site=* | --site=* | --sit=*) - site=$ac_optarg ;; - - -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) - ac_prev=srcdir ;; - -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) - srcdir=$ac_optarg ;; - - -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ - | --syscon | --sysco | --sysc | --sys | --sy) - ac_prev=sysconfdir ;; - -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ - | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) - sysconfdir=$ac_optarg ;; - - -target | --target | --targe | --targ | --tar | --ta | --t) - ac_prev=target_alias ;; - -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) - target_alias=$ac_optarg ;; - - -v | -verbose | --verbose | --verbos | --verbo | --verb) - verbose=yes ;; - - -version | --version | --versio | --versi | --vers | -V) - ac_init_version=: ;; - - -with-* | --with-*) - ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=\$ac_optarg ;; - - -without-* | --without-*) - ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'` - # Reject names that are not valid shell variable names. - expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid package name: $ac_package" >&2 - { (exit 1); exit 1; }; } - ac_package=`echo $ac_package | sed 's/[-.]/_/g'` - eval with_$ac_package=no ;; - - --x) - # Obsolete; use --with-x. - with_x=yes ;; - - -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ - | --x-incl | --x-inc | --x-in | --x-i) - ac_prev=x_includes ;; - -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ - | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) - x_includes=$ac_optarg ;; - - -x-libraries | --x-libraries | --x-librarie | --x-librari \ - | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) - ac_prev=x_libraries ;; - -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ - | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) - x_libraries=$ac_optarg ;; - - -*) { echo "$as_me: error: unrecognized option: $ac_option -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } - ;; - - *=*) - ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` - # Reject names that are not valid shell variable names. - expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null && - { echo "$as_me: error: invalid variable name: $ac_envvar" >&2 - { (exit 1); exit 1; }; } - eval $ac_envvar=\$ac_optarg - export $ac_envvar ;; - - *) - # FIXME: should be removed in autoconf 3.0. - echo "$as_me: WARNING: you should use --build, --host, --target" >&2 - expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && - echo "$as_me: WARNING: invalid host type: $ac_option" >&2 - : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option} - ;; - - esac -done - -if test -n "$ac_prev"; then - ac_option=--`echo $ac_prev | sed 's/_/-/g'` - { echo "$as_me: error: missing argument to $ac_option" >&2 - { (exit 1); exit 1; }; } -fi - -# Be sure to have absolute directory names. -for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ - datadir sysconfdir sharedstatedir localstatedir includedir \ - oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ - libdir localedir mandir -do - eval ac_val=\$$ac_var - case $ac_val in - [\\/$]* | ?:[\\/]* ) continue;; - NONE | '' ) case $ac_var in *prefix ) continue;; esac;; - esac - { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2 - { (exit 1); exit 1; }; } -done - -# There might be people who depend on the old broken behavior: `$host' -# used to hold the argument of --host etc. -# FIXME: To remove some day. -build=$build_alias -host=$host_alias -target=$target_alias - -# FIXME: To remove some day. -if test "x$host_alias" != x; then - if test "x$build_alias" = x; then - cross_compiling=maybe - echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host. - If a cross compiler is detected then cross compile mode will be used." >&2 - elif test "x$build_alias" != "x$host_alias"; then - cross_compiling=yes - fi -fi - -ac_tool_prefix= -test -n "$host_alias" && ac_tool_prefix=$host_alias- - -test "$silent" = yes && exec 6>/dev/null - - -ac_pwd=`pwd` && test -n "$ac_pwd" && -ac_ls_di=`ls -di .` && -ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || - { echo "$as_me: error: Working directory cannot be determined" >&2 - { (exit 1); exit 1; }; } -test "X$ac_ls_di" = "X$ac_pwd_ls_di" || - { echo "$as_me: error: pwd does not report name of working directory" >&2 - { (exit 1); exit 1; }; } - - -# Find the source files, if location was not specified. -if test -z "$srcdir"; then - ac_srcdir_defaulted=yes - # Try the directory containing this script, then the parent directory. - ac_confdir=`$as_dirname -- "$0" || -$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$0" : 'X\(//\)[^/]' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X"$0" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - srcdir=$ac_confdir - if test ! -r "$srcdir/$ac_unique_file"; then - srcdir=.. - fi -else - ac_srcdir_defaulted=no -fi -if test ! -r "$srcdir/$ac_unique_file"; then - test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." - { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2 - { (exit 1); exit 1; }; } -fi -ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" -ac_abs_confdir=`( - cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2 - { (exit 1); exit 1; }; } - pwd)` -# When building in place, set srcdir=. -if test "$ac_abs_confdir" = "$ac_pwd"; then - srcdir=. -fi -# Remove unnecessary trailing slashes from srcdir. -# Double slashes in file names in object file debugging info -# mess up M-x gdb in Emacs. -case $srcdir in -*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; -esac -for ac_var in $ac_precious_vars; do - eval ac_env_${ac_var}_set=\${${ac_var}+set} - eval ac_env_${ac_var}_value=\$${ac_var} - eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} - eval ac_cv_env_${ac_var}_value=\$${ac_var} -done - -# -# Report the --help message. -# -if test "$ac_init_help" = "long"; then - # Omit some internal or obsolete options to make the list less imposing. - # This message is too long to be a string in the A/UX 3.1 sh. - cat <<_ACEOF -\`configure' configures Gauche-mecab 1.0 to adapt to many kinds of systems. - -Usage: $0 [OPTION]... [VAR=VALUE]... - -To assign environment variables (e.g., CC, CFLAGS...), specify them as -VAR=VALUE. See below for descriptions of some of the useful variables. - -Defaults for the options are specified in brackets. - -Configuration: - -h, --help display this help and exit - --help=short display options specific to this package - --help=recursive display the short help of all the included packages - -V, --version display version information and exit - -q, --quiet, --silent do not print \`checking...' messages - --cache-file=FILE cache test results in FILE [disabled] - -C, --config-cache alias for \`--cache-file=config.cache' - -n, --no-create do not create output files - --srcdir=DIR find the sources in DIR [configure dir or \`..'] - -Installation directories: - --prefix=PREFIX install architecture-independent files in PREFIX - [$ac_default_prefix] - --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX - [PREFIX] - -By default, \`make install' will install all the files in -\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify -an installation prefix other than \`$ac_default_prefix' using \`--prefix', -for instance \`--prefix=\$HOME'. - -For better control, use the options below. - -Fine tuning of the installation directories: - --bindir=DIR user executables [EPREFIX/bin] - --sbindir=DIR system admin executables [EPREFIX/sbin] - --libexecdir=DIR program executables [EPREFIX/libexec] - --sysconfdir=DIR read-only single-machine data [PREFIX/etc] - --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] - --localstatedir=DIR modifiable single-machine data [PREFIX/var] - --libdir=DIR object code libraries [EPREFIX/lib] - --includedir=DIR C header files [PREFIX/include] - --oldincludedir=DIR C header files for non-gcc [/usr/include] - --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] - --datadir=DIR read-only architecture-independent data [DATAROOTDIR] - --infodir=DIR info documentation [DATAROOTDIR/info] - --localedir=DIR locale-dependent data [DATAROOTDIR/locale] - --mandir=DIR man documentation [DATAROOTDIR/man] - --docdir=DIR documentation root [DATAROOTDIR/doc/gauche-mecab] - --htmldir=DIR html documentation [DOCDIR] - --dvidir=DIR dvi documentation [DOCDIR] - --pdfdir=DIR pdf documentation [DOCDIR] - --psdir=DIR ps documentation [DOCDIR] -_ACEOF - - cat <<\_ACEOF -_ACEOF -fi - -if test -n "$ac_init_help"; then - case $ac_init_help in - short | recursive ) echo "Configuration of Gauche-mecab 1.0:";; - esac - cat <<\_ACEOF - -Optional Packages: - --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] - --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) - --with-local=PATH:PATH... - For each PATH, add PATH/include to the include - search paths and PATH/lib to the library search - paths. Useful if you have some libraries installed - in non-standard places. - -Report bugs to . -_ACEOF -ac_status=$? -fi - -if test "$ac_init_help" = "recursive"; then - # If there are subdirs, report their specific --help. - for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue - test -d "$ac_dir" || continue - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - cd "$ac_dir" || { ac_status=$?; continue; } - # Check for guested configure. - if test -f "$ac_srcdir/configure.gnu"; then - echo && - $SHELL "$ac_srcdir/configure.gnu" --help=recursive - elif test -f "$ac_srcdir/configure"; then - echo && - $SHELL "$ac_srcdir/configure" --help=recursive - else - echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 - fi || ac_status=$? - cd "$ac_pwd" || { ac_status=$?; break; } - done -fi - -test -n "$ac_init_help" && exit $ac_status -if $ac_init_version; then - cat <<\_ACEOF -Gauche-mecab configure 1.0 -generated by GNU Autoconf 2.61 - -Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, -2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. -This configure script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it. -_ACEOF - exit -fi -cat >config.log <<_ACEOF -This file contains any messages produced by compilers while -running configure, to aid debugging if configure makes a mistake. - -It was created by Gauche-mecab $as_me 1.0, which was -generated by GNU Autoconf 2.61. Invocation command line was - - $ $0 $@ - -_ACEOF -exec 5>>config.log -{ -cat <<_ASUNAME -## --------- ## -## Platform. ## -## --------- ## - -hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` -uname -m = `(uname -m) 2>/dev/null || echo unknown` -uname -r = `(uname -r) 2>/dev/null || echo unknown` -uname -s = `(uname -s) 2>/dev/null || echo unknown` -uname -v = `(uname -v) 2>/dev/null || echo unknown` - -/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` -/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` - -/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` -/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` -/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` -/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` -/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` -/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` -/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` - -_ASUNAME - -as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - echo "PATH: $as_dir" -done -IFS=$as_save_IFS - -} >&5 - -cat >&5 <<_ACEOF - - -## ----------- ## -## Core tests. ## -## ----------- ## - -_ACEOF - - -# Keep a trace of the command line. -# Strip out --no-create and --no-recursion so they do not pile up. -# Strip out --silent because we don't want to record it for future runs. -# Also quote any args containing shell meta-characters. -# Make two passes to allow for proper duplicate-argument suppression. -ac_configure_args= -ac_configure_args0= -ac_configure_args1= -ac_must_keep_next=false -for ac_pass in 1 2 -do - for ac_arg - do - case $ac_arg in - -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil) - continue ;; - *\'*) - ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; - esac - case $ac_pass in - 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;; - 2) - ac_configure_args1="$ac_configure_args1 '$ac_arg'" - if test $ac_must_keep_next = true; then - ac_must_keep_next=false # Got value, back to normal. - else - case $ac_arg in - *=* | --config-cache | -C | -disable-* | --disable-* \ - | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ - | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ - | -with-* | --with-* | -without-* | --without-* | --x) - case "$ac_configure_args0 " in - "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; - esac - ;; - -* ) ac_must_keep_next=true ;; - esac - fi - ac_configure_args="$ac_configure_args '$ac_arg'" - ;; - esac - done -done -$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; } -$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; } - -# When interrupted or exit'd, cleanup temporary files, and complete -# config.log. We remove comments because anyway the quotes in there -# would cause problems or look ugly. -# WARNING: Use '\'' to represent an apostrophe within the trap. -# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. -trap 'exit_status=$? - # Save into config.log some information that might help in debugging. - { - echo - - cat <<\_ASBOX -## ---------------- ## -## Cache variables. ## -## ---------------- ## -_ASBOX - echo - # The following way of writing the cache mishandles newlines in values, -( - for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; - esac ;; - esac - done - (set) 2>&1 | - case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - sed -n \ - "s/'\''/'\''\\\\'\'''\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" - ;; #( - *) - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) - echo - - cat <<\_ASBOX -## ----------------- ## -## Output variables. ## -## ----------------- ## -_ASBOX - echo - for ac_var in $ac_subst_vars - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - echo "$ac_var='\''$ac_val'\''" - done | sort - echo - - if test -n "$ac_subst_files"; then - cat <<\_ASBOX -## ------------------- ## -## File substitutions. ## -## ------------------- ## -_ASBOX - echo - for ac_var in $ac_subst_files - do - eval ac_val=\$$ac_var - case $ac_val in - *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; - esac - echo "$ac_var='\''$ac_val'\''" - done | sort - echo - fi - - if test -s confdefs.h; then - cat <<\_ASBOX -## ----------- ## -## confdefs.h. ## -## ----------- ## -_ASBOX - echo - cat confdefs.h - echo - fi - test "$ac_signal" != 0 && - echo "$as_me: caught signal $ac_signal" - echo "$as_me: exit $exit_status" - } >&5 - rm -f core *.core core.conftest.* && - rm -f -r conftest* confdefs* conf$$* $ac_clean_files && - exit $exit_status -' 0 -for ac_signal in 1 2 13 15; do - trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal -done -ac_signal=0 - -# confdefs.h avoids OS command line length limits that DEFS can exceed. -rm -f -r conftest* confdefs.h - -# Predefined preprocessor variables. - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_NAME "$PACKAGE_NAME" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_TARNAME "$PACKAGE_TARNAME" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_VERSION "$PACKAGE_VERSION" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_STRING "$PACKAGE_STRING" -_ACEOF - - -cat >>confdefs.h <<_ACEOF -#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" -_ACEOF - - -# Let the site file select an alternate cache file if it wants to. -# Prefer explicitly selected file to automatically selected ones. -if test -n "$CONFIG_SITE"; then - set x "$CONFIG_SITE" -elif test "x$prefix" != xNONE; then - set x "$prefix/share/config.site" "$prefix/etc/config.site" -else - set x "$ac_default_prefix/share/config.site" \ - "$ac_default_prefix/etc/config.site" -fi -shift -for ac_site_file -do - if test -r "$ac_site_file"; then - { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5 -echo "$as_me: loading site script $ac_site_file" >&6;} - sed 's/^/| /' "$ac_site_file" >&5 - . "$ac_site_file" - fi -done - -if test -r "$cache_file"; then - # Some versions of bash will fail to source /dev/null (special - # files actually), so we avoid doing that. - if test -f "$cache_file"; then - { echo "$as_me:$LINENO: loading cache $cache_file" >&5 -echo "$as_me: loading cache $cache_file" >&6;} - case $cache_file in - [\\/]* | ?:[\\/]* ) . "$cache_file";; - *) . "./$cache_file";; - esac - fi -else - { echo "$as_me:$LINENO: creating cache $cache_file" >&5 -echo "$as_me: creating cache $cache_file" >&6;} - >$cache_file -fi - -# Check that the precious variables saved in the cache have kept the same -# value. -ac_cache_corrupted=false -for ac_var in $ac_precious_vars; do - eval ac_old_set=\$ac_cv_env_${ac_var}_set - eval ac_new_set=\$ac_env_${ac_var}_set - eval ac_old_val=\$ac_cv_env_${ac_var}_value - eval ac_new_val=\$ac_env_${ac_var}_value - case $ac_old_set,$ac_new_set in - set,) - { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,set) - { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5 -echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} - ac_cache_corrupted=: ;; - ,);; - *) - if test "x$ac_old_val" != "x$ac_new_val"; then - { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5 -echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} - { echo "$as_me:$LINENO: former value: $ac_old_val" >&5 -echo "$as_me: former value: $ac_old_val" >&2;} - { echo "$as_me:$LINENO: current value: $ac_new_val" >&5 -echo "$as_me: current value: $ac_new_val" >&2;} - ac_cache_corrupted=: - fi;; - esac - # Pass precious variables to config.status. - if test "$ac_new_set" = set; then - case $ac_new_val in - *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; - *) ac_arg=$ac_var=$ac_new_val ;; - esac - case " $ac_configure_args " in - *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. - *) ac_configure_args="$ac_configure_args '$ac_arg'" ;; - esac - fi -done -if $ac_cache_corrupted; then - { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5 -echo "$as_me: error: changes in the environment can compromise the build" >&2;} - { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5 -echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;} - { (exit 1); exit 1; }; } -fi - - - - - - - - - - - - - - - - - - - - - - - - - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - - - -# Check whether --with-local was given. -if test "${with_local+set}" = set; then - withval=$with_local; - case $with_local in - yes|no|"") ;; #no effect - *) LOCAL_PATHS=$with_local ;; - esac - -fi - - - -# Extract the first word of "gosh", so it can be a program name with args. -set dummy gosh; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_GOSH+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $GOSH in - [\\/]* | ?:[\\/]*) - ac_cv_path_GOSH="$GOSH" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_GOSH="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -GOSH=$ac_cv_path_GOSH -if test -n "$GOSH"; then - { echo "$as_me:$LINENO: result: $GOSH" >&5 -echo "${ECHO_T}$GOSH" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - -# Extract the first word of "gauche-config", so it can be a program name with args. -set dummy gauche-config; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_GAUCHE_CONFIG+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $GAUCHE_CONFIG in - [\\/]* | ?:[\\/]*) - ac_cv_path_GAUCHE_CONFIG="$GAUCHE_CONFIG" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_GAUCHE_CONFIG="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -GAUCHE_CONFIG=$ac_cv_path_GAUCHE_CONFIG -if test -n "$GAUCHE_CONFIG"; then - { echo "$as_me:$LINENO: result: $GAUCHE_CONFIG" >&5 -echo "${ECHO_T}$GAUCHE_CONFIG" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - -# Extract the first word of "gauche-package", so it can be a program name with args. -set dummy gauche-package; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_GAUCHE_PACKAGE+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $GAUCHE_PACKAGE in - [\\/]* | ?:[\\/]*) - ac_cv_path_GAUCHE_PACKAGE="$GAUCHE_PACKAGE" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_GAUCHE_PACKAGE="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -GAUCHE_PACKAGE=$ac_cv_path_GAUCHE_PACKAGE -if test -n "$GAUCHE_PACKAGE"; then - { echo "$as_me:$LINENO: result: $GAUCHE_PACKAGE" >&5 -echo "${ECHO_T}$GAUCHE_PACKAGE" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - -# Extract the first word of "gauche-install", so it can be a program name with args. -set dummy gauche-install; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_GAUCHE_INSTALL+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $GAUCHE_INSTALL in - [\\/]* | ?:[\\/]*) - ac_cv_path_GAUCHE_INSTALL="$GAUCHE_INSTALL" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_GAUCHE_INSTALL="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -GAUCHE_INSTALL=$ac_cv_path_GAUCHE_INSTALL -if test -n "$GAUCHE_INSTALL"; then - { echo "$as_me:$LINENO: result: $GAUCHE_INSTALL" >&5 -echo "${ECHO_T}$GAUCHE_INSTALL" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - -# Extract the first word of "gauche-cesconv", so it can be a program name with args. -set dummy gauche-cesconv; ac_word=$2 -{ echo "$as_me:$LINENO: checking for $ac_word" >&5 -echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } -if test "${ac_cv_path_GAUCHE_CESCONV+set}" = set; then - echo $ECHO_N "(cached) $ECHO_C" >&6 -else - case $GAUCHE_CESCONV in - [\\/]* | ?:[\\/]*) - ac_cv_path_GAUCHE_CESCONV="$GAUCHE_CESCONV" # Let the user override the test with a path. - ;; - *) - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - for ac_exec_ext in '' $ac_executable_extensions; do - if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then - ac_cv_path_GAUCHE_CESCONV="$as_dir/$ac_word$ac_exec_ext" - echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 - break 2 - fi -done -done -IFS=$as_save_IFS - - ;; -esac -fi -GAUCHE_CESCONV=$ac_cv_path_GAUCHE_CESCONV -if test -n "$GAUCHE_CESCONV"; then - { echo "$as_me:$LINENO: result: $GAUCHE_CESCONV" >&5 -echo "${ECHO_T}$GAUCHE_CESCONV" >&6; } -else - { echo "$as_me:$LINENO: result: no" >&5 -echo "${ECHO_T}no" >&6; } -fi - - - -SOEXT=`$GAUCHE_CONFIG --so-suffix` -OBJEXT=`$GAUCHE_CONFIG --object-suffix` -EXEEXT=`$GAUCHE_CONFIG --executable-suffix` - - - - -ac_default_prefix=`$GAUCHE_CONFIG --prefix` - -GAUCHE_PKGINCDIR=`$GAUCHE_CONFIG --pkgincdir` -GAUCHE_PKGLIBDIR=`$GAUCHE_CONFIG --pkglibdir` -GAUCHE_PKGARCHDIR=`$GAUCHE_CONFIG --pkgarchdir` - - - - - - - -GAUCHE_PACKAGE_CONFIGURE_ARGS="`echo ""$ac_configure_args"" | sed 's/\\""\`\$/\\\&/g'`" -{ echo "$as_me:$LINENO: creating ${PACKAGE_NAME}.gpd" >&5 -echo "$as_me: creating ${PACKAGE_NAME}.gpd" >&6;} -$GAUCHE_PACKAGE make-gpd "$PACKAGE_NAME" \ - -version "$PACKAGE_VERSION" \ - -configure "./configure $GAUCHE_PACKAGE_CONFIGURE_ARGS" - -echo $PACKAGE_VERSION > VERSION -ac_config_files="$ac_config_files Makefile" - -cat >confcache <<\_ACEOF -# This file is a shell script that caches the results of configure -# tests run on this system so they can be shared between configure -# scripts and configure runs, see configure's option --config-cache. -# It is not useful on other systems. If it contains results you don't -# want to keep, you may remove or edit it. -# -# config.status only pays attention to the cache file if you give it -# the --recheck option to rerun configure. -# -# `ac_cv_env_foo' variables (set or unset) will be overridden when -# loading this file, other *unset* `ac_cv_foo' will be assigned the -# following values. - -_ACEOF - -# The following way of writing the cache mishandles newlines in values, -# but we know of no workaround that is simple, portable, and efficient. -# So, we kill variables containing newlines. -# Ultrix sh set writes to stderr and can't be redirected directly, -# and sets the high bit in the cache file unless we assign to the vars. -( - for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do - eval ac_val=\$$ac_var - case $ac_val in #( - *${as_nl}*) - case $ac_var in #( - *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5 -echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;; - esac - case $ac_var in #( - _ | IFS | as_nl) ;; #( - *) $as_unset $ac_var ;; - esac ;; - esac - done - - (set) 2>&1 | - case $as_nl`(ac_space=' '; set) 2>&1` in #( - *${as_nl}ac_space=\ *) - # `set' does not quote correctly, so add quotes (double-quote - # substitution turns \\\\ into \\, and sed turns \\ into \). - sed -n \ - "s/'/'\\\\''/g; - s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" - ;; #( - *) - # `set' quotes correctly as required by POSIX, so do not add quotes. - sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" - ;; - esac | - sort -) | - sed ' - /^ac_cv_env_/b end - t clear - :clear - s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ - t end - s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ - :end' >>confcache -if diff "$cache_file" confcache >/dev/null 2>&1; then :; else - if test -w "$cache_file"; then - test "x$cache_file" != "x/dev/null" && - { echo "$as_me:$LINENO: updating cache $cache_file" >&5 -echo "$as_me: updating cache $cache_file" >&6;} - cat confcache >$cache_file - else - { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5 -echo "$as_me: not updating unwritable cache $cache_file" >&6;} - fi -fi -rm -f confcache - -test "x$prefix" = xNONE && prefix=$ac_default_prefix -# Let make expand exec_prefix. -test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' - -# Transform confdefs.h into DEFS. -# Protect against shell expansion while executing Makefile rules. -# Protect against Makefile macro expansion. -# -# If the first sed substitution is executed (which looks for macros that -# take arguments), then branch to the quote section. Otherwise, -# look for a macro that doesn't take arguments. -ac_script=' -t clear -:clear -s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g -t quote -s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g -t quote -b any -:quote -s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g -s/\[/\\&/g -s/\]/\\&/g -s/\$/$$/g -H -:any -${ - g - s/^\n// - s/\n/ /g - p -} -' -DEFS=`sed -n "$ac_script" confdefs.h` - - -ac_libobjs= -ac_ltlibobjs= -for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue - # 1. Remove the extension, and $U if already installed. - ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' - ac_i=`echo "$ac_i" | sed "$ac_script"` - # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR - # will be set to the directory where LIBOBJS objects are built. - ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext" - ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo' -done -LIBOBJS=$ac_libobjs - -LTLIBOBJS=$ac_ltlibobjs - - - -: ${CONFIG_STATUS=./config.status} -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files $CONFIG_STATUS" -{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5 -echo "$as_me: creating $CONFIG_STATUS" >&6;} -cat >$CONFIG_STATUS <<_ACEOF -#! $SHELL -# Generated by $as_me. -# Run this file to recreate the current configuration. -# Compiler output produced by configure, useful for debugging -# configure, is in config.log if it exists. - -debug=false -ac_cs_recheck=false -ac_cs_silent=false -SHELL=\${CONFIG_SHELL-$SHELL} -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -## --------------------- ## -## M4sh Initialization. ## -## --------------------- ## - -# Be more Bourne compatible -DUALCASE=1; export DUALCASE # for MKS sh -if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then - emulate sh - NULLCMD=: - # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which - # is contrary to our usage. Disable this feature. - alias -g '${1+"$@"}'='"$@"' - setopt NO_GLOB_SUBST -else - case `(set -o) 2>/dev/null` in - *posix*) set -o posix ;; -esac - -fi - - - - -# PATH needs CR -# Avoid depending upon Character Ranges. -as_cr_letters='abcdefghijklmnopqrstuvwxyz' -as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' -as_cr_Letters=$as_cr_letters$as_cr_LETTERS -as_cr_digits='0123456789' -as_cr_alnum=$as_cr_Letters$as_cr_digits - -# The user is always right. -if test "${PATH_SEPARATOR+set}" != set; then - echo "#! /bin/sh" >conf$$.sh - echo "exit 0" >>conf$$.sh - chmod +x conf$$.sh - if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then - PATH_SEPARATOR=';' - else - PATH_SEPARATOR=: - fi - rm -f conf$$.sh -fi - -# Support unset when possible. -if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then - as_unset=unset -else - as_unset=false -fi - - -# IFS -# We need space, tab and new line, in precisely that order. Quoting is -# there to prevent editors from complaining about space-tab. -# (If _AS_PATH_WALK were called with IFS unset, it would disable word -# splitting by setting IFS to empty value.) -as_nl=' -' -IFS=" "" $as_nl" - -# Find who we are. Look in the path if we contain no directory separator. -case $0 in - *[\\/]* ) as_myself=$0 ;; - *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH -do - IFS=$as_save_IFS - test -z "$as_dir" && as_dir=. - test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break -done -IFS=$as_save_IFS - - ;; -esac -# We did not find ourselves, most probably we were run as `sh COMMAND' -# in which case we are not to be found in the path. -if test "x$as_myself" = x; then - as_myself=$0 -fi -if test ! -f "$as_myself"; then - echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 - { (exit 1); exit 1; } -fi - -# Work around bugs in pre-3.0 UWIN ksh. -for as_var in ENV MAIL MAILPATH -do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var -done -PS1='$ ' -PS2='> ' -PS4='+ ' - -# NLS nuisances. -for as_var in \ - LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \ - LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \ - LC_TELEPHONE LC_TIME -do - if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then - eval $as_var=C; export $as_var - else - ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var - fi -done - -# Required to use basename. -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then - as_basename=basename -else - as_basename=false -fi - - -# Name of the executable. -as_me=`$as_basename -- "$0" || -$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ - X"$0" : 'X\(//\)$' \| \ - X"$0" : 'X\(/\)' \| . 2>/dev/null || -echo X/"$0" | - sed '/^.*\/\([^/][^/]*\)\/*$/{ - s//\1/ - q - } - /^X\/\(\/\/\)$/{ - s//\1/ - q - } - /^X\/\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - -# CDPATH. -$as_unset CDPATH - - - - as_lineno_1=$LINENO - as_lineno_2=$LINENO - test "x$as_lineno_1" != "x$as_lineno_2" && - test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || { - - # Create $as_me.lineno as a copy of $as_myself, but with $LINENO - # uniformly replaced by the line number. The first 'sed' inserts a - # line-number line after each line using $LINENO; the second 'sed' - # does the real work. The second script uses 'N' to pair each - # line-number line with the line containing $LINENO, and appends - # trailing '-' during substitution so that $LINENO is not a special - # case at line end. - # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the - # scripts with optimization help from Paolo Bonzini. Blame Lee - # E. McMahon (1931-1989) for sed's syntax. :-) - sed -n ' - p - /[$]LINENO/= - ' <$as_myself | - sed ' - s/[$]LINENO.*/&-/ - t lineno - b - :lineno - N - :loop - s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ - t loop - s/-\n.*// - ' >$as_me.lineno && - chmod +x "$as_me.lineno" || - { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2 - { (exit 1); exit 1; }; } - - # Don't try to exec as it changes $[0], causing all sort of problems - # (the dirname of $[0] is not the place where we might find the - # original and so on. Autoconf is especially sensitive to this). - . "./$as_me.lineno" - # Exit status is that of the last command. - exit -} - - -if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then - as_dirname=dirname -else - as_dirname=false -fi - -ECHO_C= ECHO_N= ECHO_T= -case `echo -n x` in --n*) - case `echo 'x\c'` in - *c*) ECHO_T=' ';; # ECHO_T is single tab character. - *) ECHO_C='\c';; - esac;; -*) - ECHO_N='-n';; -esac - -if expr a : '\(a\)' >/dev/null 2>&1 && - test "X`expr 00001 : '.*\(...\)'`" = X001; then - as_expr=expr -else - as_expr=false -fi - -rm -f conf$$ conf$$.exe conf$$.file -if test -d conf$$.dir; then - rm -f conf$$.dir/conf$$.file -else - rm -f conf$$.dir - mkdir conf$$.dir -fi -echo >conf$$.file -if ln -s conf$$.file conf$$ 2>/dev/null; then - as_ln_s='ln -s' - # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -p'. - ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || - as_ln_s='cp -p' -elif ln conf$$.file conf$$ 2>/dev/null; then - as_ln_s=ln -else - as_ln_s='cp -p' -fi -rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file -rmdir conf$$.dir 2>/dev/null - -if mkdir -p . 2>/dev/null; then - as_mkdir_p=: -else - test -d ./-p && rmdir ./-p - as_mkdir_p=false -fi - -if test -x / >/dev/null 2>&1; then - as_test_x='test -x' -else - if ls -dL / >/dev/null 2>&1; then - as_ls_L_option=L - else - as_ls_L_option= - fi - as_test_x=' - eval sh -c '\'' - if test -d "$1"; then - test -d "$1/."; - else - case $1 in - -*)set "./$1";; - esac; - case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in - ???[sx]*):;;*)false;;esac;fi - '\'' sh - ' -fi -as_executable_p=$as_test_x - -# Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" - -# Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" - - -exec 6>&1 - -# Save the log message, to keep $[0] and so on meaningful, and to -# report actual input values of CONFIG_FILES etc. instead of their -# values after options handling. -ac_log=" -This file was extended by Gauche-mecab $as_me 1.0, which was -generated by GNU Autoconf 2.61. Invocation command line was - - CONFIG_FILES = $CONFIG_FILES - CONFIG_HEADERS = $CONFIG_HEADERS - CONFIG_LINKS = $CONFIG_LINKS - CONFIG_COMMANDS = $CONFIG_COMMANDS - $ $0 $@ - -on `(hostname || uname -n) 2>/dev/null | sed 1q` -" - -_ACEOF - -cat >>$CONFIG_STATUS <<_ACEOF -# Files that config.status was made for. -config_files="$ac_config_files" - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -ac_cs_usage="\ -\`$as_me' instantiates files from templates according to the -current configuration. - -Usage: $0 [OPTIONS] [FILE]... - - -h, --help print this help, then exit - -V, --version print version number and configuration settings, then exit - -q, --quiet do not print progress messages - -d, --debug don't remove temporary files - --recheck update $as_me by reconfiguring in the same conditions - --file=FILE[:TEMPLATE] - instantiate the configuration file FILE - -Configuration files: -$config_files - -Report bugs to ." - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -ac_cs_version="\\ -Gauche-mecab config.status 1.0 -configured by $0, generated by GNU Autoconf 2.61, - with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" - -Copyright (C) 2006 Free Software Foundation, Inc. -This config.status script is free software; the Free Software Foundation -gives unlimited permission to copy, distribute and modify it." - -ac_pwd='$ac_pwd' -srcdir='$srcdir' -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -# If no file are specified by the user, then we need to provide default -# value. By we need to know if files were specified by the user. -ac_need_defaults=: -while test $# != 0 -do - case $1 in - --*=*) - ac_option=`expr "X$1" : 'X\([^=]*\)='` - ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` - ac_shift=: - ;; - *) - ac_option=$1 - ac_optarg=$2 - ac_shift=shift - ;; - esac - - case $ac_option in - # Handling of the options. - -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) - ac_cs_recheck=: ;; - --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) - echo "$ac_cs_version"; exit ;; - --debug | --debu | --deb | --de | --d | -d ) - debug=: ;; - --file | --fil | --fi | --f ) - $ac_shift - CONFIG_FILES="$CONFIG_FILES $ac_optarg" - ac_need_defaults=false;; - --he | --h | --help | --hel | -h ) - echo "$ac_cs_usage"; exit ;; - -q | -quiet | --quiet | --quie | --qui | --qu | --q \ - | -silent | --silent | --silen | --sile | --sil | --si | --s) - ac_cs_silent=: ;; - - # This is an error. - -*) { echo "$as_me: error: unrecognized option: $1 -Try \`$0 --help' for more information." >&2 - { (exit 1); exit 1; }; } ;; - - *) ac_config_targets="$ac_config_targets $1" - ac_need_defaults=false ;; - - esac - shift -done - -ac_configure_extra_args= - -if $ac_cs_silent; then - exec 6>/dev/null - ac_configure_extra_args="$ac_configure_extra_args --silent" -fi - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -if \$ac_cs_recheck; then - echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6 - CONFIG_SHELL=$SHELL - export CONFIG_SHELL - exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion -fi - -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -exec 5>>config.log -{ - echo - sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX -## Running $as_me. ## -_ASBOX - echo "$ac_log" -} >&5 - -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF - -# Handling of arguments. -for ac_config_target in $ac_config_targets -do - case $ac_config_target in - "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; - - *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5 -echo "$as_me: error: invalid argument: $ac_config_target" >&2;} - { (exit 1); exit 1; }; };; - esac -done - - -# If the user did not use the arguments to specify the items to instantiate, -# then the envvar interface is used. Set only those that are not. -# We use the long form for the default assignment because of an extremely -# bizarre bug on SunOS 4.1.3. -if $ac_need_defaults; then - test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files -fi - -# Have a temporary directory for convenience. Make it in the build tree -# simply because there is no reason against having it here, and in addition, -# creating and moving files from /tmp can sometimes cause problems. -# Hook for its removal unless debugging. -# Note that there is a small window in which the directory will not be cleaned: -# after its creation but before its name has been assigned to `$tmp'. -$debug || -{ - tmp= - trap 'exit_status=$? - { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status -' 0 - trap '{ (exit 1); exit 1; }' 1 2 13 15 -} -# Create a (secure) tmp directory for tmp files. - -{ - tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && - test -n "$tmp" && test -d "$tmp" -} || -{ - tmp=./conf$$-$RANDOM - (umask 077 && mkdir "$tmp") -} || -{ - echo "$me: cannot create a temporary directory in ." >&2 - { (exit 1); exit 1; } -} - -# -# Set up the sed scripts for CONFIG_FILES section. -# - -# No need to generate the scripts if there are no CONFIG_FILES. -# This happens for instance when ./config.status config.h -if test -n "$CONFIG_FILES"; then - -_ACEOF - - - -ac_delim='%!_!# ' -for ac_last_try in false false false false false :; do - cat >conf$$subs.sed <<_ACEOF -SHELL!$SHELL$ac_delim -PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim -PACKAGE_NAME!$PACKAGE_NAME$ac_delim -PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim -PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim -PACKAGE_STRING!$PACKAGE_STRING$ac_delim -PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim -exec_prefix!$exec_prefix$ac_delim -prefix!$prefix$ac_delim -program_transform_name!$program_transform_name$ac_delim -bindir!$bindir$ac_delim -sbindir!$sbindir$ac_delim -libexecdir!$libexecdir$ac_delim -datarootdir!$datarootdir$ac_delim -datadir!$datadir$ac_delim -sysconfdir!$sysconfdir$ac_delim -sharedstatedir!$sharedstatedir$ac_delim -localstatedir!$localstatedir$ac_delim -includedir!$includedir$ac_delim -oldincludedir!$oldincludedir$ac_delim -docdir!$docdir$ac_delim -infodir!$infodir$ac_delim -htmldir!$htmldir$ac_delim -dvidir!$dvidir$ac_delim -pdfdir!$pdfdir$ac_delim -psdir!$psdir$ac_delim -libdir!$libdir$ac_delim -localedir!$localedir$ac_delim -mandir!$mandir$ac_delim -DEFS!$DEFS$ac_delim -ECHO_C!$ECHO_C$ac_delim -ECHO_N!$ECHO_N$ac_delim -ECHO_T!$ECHO_T$ac_delim -LIBS!$LIBS$ac_delim -build_alias!$build_alias$ac_delim -host_alias!$host_alias$ac_delim -target_alias!$target_alias$ac_delim -LOCAL_PATHS!$LOCAL_PATHS$ac_delim -GOSH!$GOSH$ac_delim -GAUCHE_CONFIG!$GAUCHE_CONFIG$ac_delim -GAUCHE_PACKAGE!$GAUCHE_PACKAGE$ac_delim -GAUCHE_INSTALL!$GAUCHE_INSTALL$ac_delim -GAUCHE_CESCONV!$GAUCHE_CESCONV$ac_delim -SOEXT!$SOEXT$ac_delim -OBJEXT!$OBJEXT$ac_delim -EXEEXT!$EXEEXT$ac_delim -GAUCHE_PKGINCDIR!$GAUCHE_PKGINCDIR$ac_delim -GAUCHE_PKGLIBDIR!$GAUCHE_PKGLIBDIR$ac_delim -GAUCHE_PKGARCHDIR!$GAUCHE_PKGARCHDIR$ac_delim -LIBOBJS!$LIBOBJS$ac_delim -LTLIBOBJS!$LTLIBOBJS$ac_delim -_ACEOF - - if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 51; then - break - elif $ac_last_try; then - { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } - else - ac_delim="$ac_delim!$ac_delim _$ac_delim!! " - fi -done - -ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed` -if test -n "$ac_eof"; then - ac_eof=`echo "$ac_eof" | sort -nru | sed 1q` - ac_eof=`expr $ac_eof + 1` -fi - -cat >>$CONFIG_STATUS <<_ACEOF -cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end -_ACEOF -sed ' -s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g -s/^/s,@/; s/!/@,|#_!!_#|/ -:n -t n -s/'"$ac_delim"'$/,g/; t -s/$/\\/; p -N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n -' >>$CONFIG_STATUS >$CONFIG_STATUS <<_ACEOF -:end -s/|#_!!_#|//g -CEOF$ac_eof -_ACEOF - - -# VPATH may cause trouble with some makes, so we remove $(srcdir), -# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and -# trailing colons and then remove the whole line if VPATH becomes empty -# (actually we leave an empty line to preserve line numbers). -if test "x$srcdir" = x.; then - ac_vpsub='/^[ ]*VPATH[ ]*=/{ -s/:*\$(srcdir):*/:/ -s/:*\${srcdir}:*/:/ -s/:*@srcdir@:*/:/ -s/^\([^=]*=[ ]*\):*/\1/ -s/:*$// -s/^[^=]*=[ ]*$// -}' -fi - -cat >>$CONFIG_STATUS <<\_ACEOF -fi # test -n "$CONFIG_FILES" - - -for ac_tag in :F $CONFIG_FILES -do - case $ac_tag in - :[FHLC]) ac_mode=$ac_tag; continue;; - esac - case $ac_mode$ac_tag in - :[FHL]*:*);; - :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5 -echo "$as_me: error: Invalid tag $ac_tag." >&2;} - { (exit 1); exit 1; }; };; - :[FH]-) ac_tag=-:-;; - :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; - esac - ac_save_IFS=$IFS - IFS=: - set x $ac_tag - IFS=$ac_save_IFS - shift - ac_file=$1 - shift - - case $ac_mode in - :L) ac_source=$1;; - :[FH]) - ac_file_inputs= - for ac_f - do - case $ac_f in - -) ac_f="$tmp/stdin";; - *) # Look for the file first in the build tree, then in the source tree - # (if the path is not absolute). The absolute path cannot be DOS-style, - # because $ac_f cannot contain `:'. - test -f "$ac_f" || - case $ac_f in - [\\/$]*) false;; - *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; - esac || - { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5 -echo "$as_me: error: cannot find input file: $ac_f" >&2;} - { (exit 1); exit 1; }; };; - esac - ac_file_inputs="$ac_file_inputs $ac_f" - done - - # Let's still pretend it is `configure' which instantiates (i.e., don't - # use $as_me), people would be surprised to read: - # /* config.h. Generated by config.status. */ - configure_input="Generated from "`IFS=: - echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure." - if test x"$ac_file" != x-; then - configure_input="$ac_file. $configure_input" - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} - fi - - case $ac_tag in - *:-:* | *:-) cat >"$tmp/stdin";; - esac - ;; - esac - - ac_dir=`$as_dirname -- "$ac_file" || -$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$ac_file" : 'X\(//\)[^/]' \| \ - X"$ac_file" : 'X\(//\)$' \| \ - X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || -echo X"$ac_file" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - { as_dir="$ac_dir" - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } - ac_builddir=. - -case "$ac_dir" in -.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; -*) - ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'` - # A ".." for each directory in $ac_dir_suffix. - ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'` - case $ac_top_builddir_sub in - "") ac_top_builddir_sub=. ac_top_build_prefix= ;; - *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; - esac ;; -esac -ac_abs_top_builddir=$ac_pwd -ac_abs_builddir=$ac_pwd$ac_dir_suffix -# for backward compatibility: -ac_top_builddir=$ac_top_build_prefix - -case $srcdir in - .) # We are building in place. - ac_srcdir=. - ac_top_srcdir=$ac_top_builddir_sub - ac_abs_top_srcdir=$ac_pwd ;; - [\\/]* | ?:[\\/]* ) # Absolute name. - ac_srcdir=$srcdir$ac_dir_suffix; - ac_top_srcdir=$srcdir - ac_abs_top_srcdir=$srcdir ;; - *) # Relative name. - ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix - ac_top_srcdir=$ac_top_build_prefix$srcdir - ac_abs_top_srcdir=$ac_pwd/$srcdir ;; -esac -ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix - - - case $ac_mode in - :F) - # - # CONFIG_FILE - # - -_ACEOF - -cat >>$CONFIG_STATUS <<\_ACEOF -# If the template does not know about datarootdir, expand it. -# FIXME: This hack should be removed a few years after 2.60. -ac_datarootdir_hack=; ac_datarootdir_seen= - -case `sed -n '/datarootdir/ { - p - q -} -/@datadir@/p -/@docdir@/p -/@infodir@/p -/@localedir@/p -/@mandir@/p -' $ac_file_inputs` in -*datarootdir*) ac_datarootdir_seen=yes;; -*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 -echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} -_ACEOF -cat >>$CONFIG_STATUS <<_ACEOF - ac_datarootdir_hack=' - s&@datadir@&$datadir&g - s&@docdir@&$docdir&g - s&@infodir@&$infodir&g - s&@localedir@&$localedir&g - s&@mandir@&$mandir&g - s&\\\${datarootdir}&$datarootdir&g' ;; -esac -_ACEOF - -# Neutralize VPATH when `$srcdir' = `.'. -# Shell code in configure.ac might set extrasub. -# FIXME: do we really want to maintain this feature? -cat >>$CONFIG_STATUS <<_ACEOF - sed "$ac_vpsub -$extrasub -_ACEOF -cat >>$CONFIG_STATUS <<\_ACEOF -:t -/@[a-zA-Z_][a-zA-Z_0-9]*@/!b -s&@configure_input@&$configure_input&;t t -s&@top_builddir@&$ac_top_builddir_sub&;t t -s&@srcdir@&$ac_srcdir&;t t -s&@abs_srcdir@&$ac_abs_srcdir&;t t -s&@top_srcdir@&$ac_top_srcdir&;t t -s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t -s&@builddir@&$ac_builddir&;t t -s&@abs_builddir@&$ac_abs_builddir&;t t -s&@abs_top_builddir@&$ac_abs_top_builddir&;t t -$ac_datarootdir_hack -" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out - -test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && - { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && - { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined." >&5 -echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' -which seems to be undefined. Please make sure it is defined." >&2;} - - rm -f "$tmp/stdin" - case $ac_file in - -) cat "$tmp/out"; rm -f "$tmp/out";; - *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;; - esac - ;; - - - - esac - -done # for ac_tag - - -{ (exit 0); exit 0; } -_ACEOF -chmod +x $CONFIG_STATUS -ac_clean_files=$ac_clean_files_save - - -# configure is writing to config.log, and then calls config.status. -# config.status does its own redirection, appending to config.log. -# Unfortunately, on DOS this fails, as config.log is still kept open -# by configure, so config.status won't be able to write to it; its -# output is simply discarded. So we exec the FD to /dev/null, -# effectively closing config.log, so it can be properly (re)opened and -# appended to by config.status. When coming back to configure, we -# need to make the FD available again. -if test "$no_create" != yes; then - ac_cs_success=: - ac_config_status_args= - test "$silent" = yes && - ac_config_status_args="$ac_config_status_args --quiet" - exec 5>/dev/null - $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false - exec 5>>config.log - # Use ||, not &&, to avoid exiting from the if with $? = 1, which - # would make configure fail if this is the last instruction. - $ac_cs_success || { (exit 1); exit 1; } -fi - - Index: /ng/scheme/gauche/bindings/mecab/trunk/VERSION =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/VERSION (revision 117) +++ (revision ) @@ -1,1 +1,0 @@ -1.0 Index: /ng/scheme/gauche/bindings/mecab/trunk/test-naoyat.scm =================================================================== --- /lang/scheme/gauche/bindings/mecab/trunk/test-naoyat.scm (revision 117) +++ (revision ) @@ -1,423 +1,0 @@ -;; -*- coding:euc-jp -*- -;; -;; test for mecab module -;; - -(use gauche.test) - -(test-start "mecab") -(use text.mecab) -(test-module 'text.mecab) - -(test-section "naoya_t") -;; -;; primitive things -;; -(test-section "[gauche] write-object") -(let1 mecab (mecab-new2 "") - (test* "display" "#" (with-output-to-string (lambda () (display mecab))))) - -(test-section "[gauche] reader-ctor") -(let1 mecab #,( "") ;; with reader-ctor - (test* "#,( \"\")" #t (mecab? mecab)) - (mecab-destroy mecab)) -(let1 mecab #,( "-Ochasen") ;; with reader-ctor - (test* "#,( \"-Ochasen\")" #t (mecab? mecab)) - (mecab-destroy mecab)) - -(let* ([m (mecab-new2 "")] - [node (mecab-sparse-tonode m "")] - [dinfo (mecab-dictionary-info m)]) - (test-section "[gauche] mecab?") - (test* "" #t (mecab? m)) - (test* "" #f (mecab? node)) - (test* "" #f (mecab? dinfo)) - (test* "#f" #f (mecab? #f)) - - (test-section "[gauche] mecab-node?") - (test* "" #f (mecab-node? m)) - (test* "" #t (mecab-node? node)) - (test* "" #f (mecab-node? dinfo)) - (test* "#f" #f (mecab-node? #f)) - - (test-section "[gauche] mecab-dictionary-info?") - (test* "" #f (mecab-dictionary-info? m)) - (test* "" #f (mecab-dictionary-info? node)) - (test* "" #t (mecab-dictionary-info? dinfo)) - (test* "#f" #f (mecab-dictionary-info? #f)) - - (mecab-destroy m)) - -(test-section "mecab-new") -(let1 m (mecab-new '()) - (test* "is-a? " #t (is-a? m )) - (test* "mecab?" #t (mecab? m)) - - (test-section "mecab-destroy") - (test* "mecab-destroyed?" #f (mecab-destroyed? m)) - (mecab-destroy m) - (test* "mecab-destroyed?" #t (mecab-destroyed? m)) - ) - -(test-section "mecab-new2") -(let1 m (mecab-new2 "") - (test* "is-a? " #t (is-a? m )) - (test* "mecab?" #t (mecab? m)) - (mecab-destroy m)) - -(test-section "mecab-version") -(test* "mecab-version" "0.98pre1" (mecab-version)) - -(test-section "mecab-strerror") - -(mecab-new2 "") -(test* "at mecab-new2 (ok)" "" (mecab-strerror #f)) - -(mecab-new2 "-d //") -;; "tagger.cpp(149) [load_dictionary_resource(param)] param.cpp(71) [ifs] no such file or directory: //dicrc" -(test* "at mecab-new (err)" #f (string=? "" (mecab-strerror #f))) - -(let1 m (mecab-new2 "") - (mecab-sparse-tostr m "��Ĥ���") - (test* "noerr" "" (mecab-strerror m)) - (mecab-destroy m)) - -(let1 m (mecab-new2 "") - (test-section "mecab-sparse-tostr") - (test* "��Ĥ���" - (string-join '("������,*,*,*,*,������� "��\t���ʽ���,*,*,*,��,��,��" - "���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������" - "��\t�����,*,*,*,*,��,��,��" - "EOS" - "") "\n") - (mecab-sparse-tostr m "��Ĥ���")) - - (test-section "mecab-sparse-tostr2") - (test* "\"��Ĥ���\", len=6" - (string-join '("������,*,*,*,*,������� "��\t���ʽ���,*,*,*,��,��,��" - "EOS" - "") "\n") - (mecab-sparse-tostr2 m "��Ĥ���" 6)) - - (test-section "mecab-sparse-tonode, mecab-node-***") - (let1 node (mecab-sparse-tonode m "��Ĥ���") - (test* "mecab-node?" #t (mecab-node? node)) - (test* "no previous node" #f (mecab-node-prev node)) - (test* "next node" #t (mecab-node? (mecab-node-next node))) - (test* "enext" #f (mecab-node? (mecab-node-enext node))) - (test* "bnext" #f (mecab-node? (mecab-node-bnext node))) - (test* "surface" "" (mecab-node-surface node)) - (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) - (test* "length" 0 (mecab-node-length node)) - (test* "rlength" 0 (mecab-node-rlength node)) - (test* "id" 0 (mecab-node-id node)) - (test* "rc-attr" 0 (mecab-node-rc-attr node)) - (test* "lc-attr" 0 (mecab-node-lc-attr node)) - (test* "posid" 0 (mecab-node-posid node)) - (test* "char-type" 0 (mecab-node-char-type node)) - (test* "stat" 'mecab-bos-node (mecab-node-stat node)) - (test* "best?" #t (mecab-node-best? node)) - (test* "alpha" 0.0 (mecab-node-alpha node)) - (test* "beta" 0.0 (mecab-node-beta node)) - (test* "prob" 0.0 (mecab-node-prob node)) - (test* "wcost" 0 (mecab-node-wcost node)) - (test* "cost" 0 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "previous node" #t (mecab-node? (mecab-node-prev node))) - (test* "next node" #t (mecab-node? (mecab-node-next node))) - (test* "enext" #t (mecab-node? (mecab-node-enext node))) - (test* "bnext" #f (mecab-node? (mecab-node-bnext node))) - (test* "surface" "��mecab-node-surface node)) - (test* "feature" "̾���,*,*,*,*,�������(mecab-node-feature node)) - (test* "length" 3 (mecab-node-length node)) - (test* "rlength" 3 (mecab-node-rlength node)) - (test* "id" 1 (mecab-node-id node)) - (test* "rc-attr" 1285 (mecab-node-rc-attr node)) - (test* "lc-attr" 1285 (mecab-node-lc-attr node)) - (test* "posid" 38 (mecab-node-posid node)) - (test* "char-type" 2 (mecab-node-char-type node)) - (test* "stat" 'mecab-nor-node (mecab-node-stat node)) - (test* "best?" #t (mecab-node-best? node)) - (test* "alpha" 0.0 (mecab-node-alpha node)) - (test* "beta" 0.0 (mecab-node-beta node)) - (test* "prob" 0.0 (mecab-node-prob node)) - (test* "wcost" 7439 (mecab-node-wcost node)) - (test* "cost" 7156 (mecab-node-cost node)) - ) - - (test-section "mecab-sparse-tonode2") - (let1 node (mecab-sparse-tonode2 m "��Ĥ���" 6) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) - (test* "stat" 'mecab-bos-node (mecab-node-stat node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "surface" "��mecab-node-surface node)) - (test* "feature" "̾���,*,*,*,*,�������(mecab-node-feature node)) - (test* "stat" 'mecab-nor-node (mecab-node-stat node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "surface" "��" (mecab-node-surface node)) - (test* "feature" "���ʽ���,*,*,*,��,��,��" (mecab-node-feature node)) - (test* "stat" 'mecab-nor-node (mecab-node-stat node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) - (test* "stat" 'mecab-eos-node (mecab-node-stat node)) - (test* "no next node" #f (mecab-node-next node)) - ) -; (test-section "mecab-format-node") -; (let1 node (mecab-sparse-tonode m "��Ĥ���") -; (test* "BOS" "" (mecab-format-node mecab node))) - (mecab-destroy m)) - -(let ([m (mecab-new2 "-l 1")] ;; - [input "��Ĥ���"]) - (test-section "mecab-nbest-sparse-tostr") - (test* #`",|input|, N=1" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-sparse-tostr m 1 input)) - (test* #`",|input|, N=2" - (string-append - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - ) - (mecab-nbest-sparse-tostr m 2 input)) - (test* #`",|input|, N=3" - (string-append - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - ) - (mecab-nbest-sparse-tostr m 3 input)) - - (test-section "mecab-nbest-sparse-tostr2") - (test* #`",|input|, N=1" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-sparse-tostr2 m 1 input 6)) - (test* #`",|input|, N=2" - (string-append - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - ) - (mecab-nbest-sparse-tostr2 m 2 input 6)) - (test* #`",|input|, N=3" - (string-append - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\nEOS\n" - ) - (mecab-nbest-sparse-tostr2 m 3 input 6)) - - (test-section "mecab-nbest-init") - (test* "init" 1 (mecab-nbest-init m input)) - (test-section "mecab-nbest-next-tostr") - (test* "#1" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#2" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#3" - "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#4" - "������,*,*,*,*,���������\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#5" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#6" - "������,*,*,*,*,���������\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#7" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#8" - "������,*,*,*,*,���������\t�³��,*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#9" - "������,*,*,*,*,����,����\n��\t���³��*,*,*,*,��,��,��\n���\t��ƻ��Ω,*,*,��ƻ졦�������,������,������,������\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#10" - "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\n�\t��ƻ��Ω,*,*,��ƻ졦�������,����³,���,����,����\n��\tư����,*,*,��,Ϣ��������,��\n��\t�����,*,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (dotimes (i 733) - (mecab-nbest-next-tostr m)) - (test* "#744" - "������,*,*,*,*,����,����\n��\tư����,��ʡ���,�������죲,�����,��\n�\t̾����̾��ϰ��,*,*,�,����,����\n��\tư����,*,*,��,̤��������,��\n��\t̾�����³,*,*,*,*,*\nEOS\n" - (mecab-nbest-next-tostr m)) - ;; no more results... - (test* "#745" #f (mecab-nbest-next-tostr m)) - (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) - - (test-section "mecab-nbest-init2") - (test* "init2" 1 (mecab-nbest-init2 m input 6)) - (test* "#1" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#2" - "������,*,*,*,*,���������\t���ʽ���,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (test* "#3" - "������,*,*,*,*,����,����\n��\t���ʽ���,*,*,*,��,��,��\nEOS\n" - (mecab-nbest-next-tostr m)) - (dotimes (i 8) (mecab-nbest-next-tostr m)) - (test* "#12" - "������,*,*,*,*,����,����\n��\tư����,��ʡ���,�������죲,�����,��\nEOS\n" - (mecab-nbest-next-tostr m)) - ;; no more results... - (test* "#13" #f (mecab-nbest-next-tostr m)) - (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) - - (test-section "mecab-nbest-next-tonode") - (mecab-nbest-init m input) - (test* "#1" #t (mecab-node? (mecab-nbest-next-tonode m))) - (dotimes (i 742) (mecab-nbest-next-tonode m)) - (test* "#744" #t (mecab-node? (mecab-nbest-next-tonode m))); EOS - ;; no more results... - (test* "#745" #f (mecab-node? (mecab-nbest-next-tonode m))) - (test* "mecab-strerror" #f (string=? "" (mecab-strerror m))) - - (mecab-destroy m)) - -;; -;; these values below may differ !!! -(test-section "mecab-dictionary-info, mecab-dictionary-info-***") -(let* ([m (mecab-new2 "")] - [dinfo (mecab-dictionary-info m)]) - (test* "mecab-dictionary-info?" #t (mecab-dictionary-info? dinfo)) - (test* "mecab-dictionary-info-filename" - "/usr/local/lib/mecab/dic/ipadic/sys.dic" (mecab-dictionary-info-filename dinfo)) - (test* "mecab-dictionary-info-charset" - "utf8" (mecab-dictionary-info-charset dinfo)) - (test* "mecab-dictionary-info-size" - 392126 (mecab-dictionary-info-size dinfo)) - (test* "mecab-dictionary-info-type" 'mecab-sys-dic (mecab-dictionary-info-type dinfo)) - (test* "mecab-dictionary-info-lsize" - 1316 (mecab-dictionary-info-lsize dinfo)) - (test* "mecab-dictionary-info-rsize" - 1316 (mecab-dictionary-info-rsize dinfo)) - (test* "mecab-dictionary-info-version" - 102 (mecab-dictionary-info-version dinfo)) -; (let1 next-dinfo (mecab-dictionary-info-next dinfo) -; (test* "has next?" #t (mecab-dictionary-info? next-dinfo))) - (mecab-destroy m)) - -(let1 m (mecab-new2 "") - (test-section "mecab-get[set]-partial: �ʬ��θ��ߤΥ⡼��0/1)") - (test* "default partial mode" 0 (mecab-get-partial m)) - (mecab-set-partial m 1) - (test* "set to 1" 1 (mecab-get-partial m)) - (mecab-set-partial m 0) - (test* "set to 0" 0 (mecab-get-partial m)) - - (test-section "mecab-get[set]-theta: ���ե������ñ¤­¤Î²ï¿½ï¿½ï¿½Ñ¥ï¿½ï¿½ï¿½ï¿½ï¿½") - (test* "default theta" 0.75 (mecab-get-theta m)) - (mecab-set-theta m 1.0) - (test* "set to 1.0" 1.0 (mecab-get-theta m)) - (mecab-set-theta m 0.5) - (test* "set to 0.5" 0.5 (mecab-get-theta m)) - - (test-section "mecab-get[set]-lattice-level: ����������0/1/2)") - (test* "default lattice level" 0 (mecab-get-lattice-level m)) - (mecab-set-lattice-level m 1) - (test* "set to 1" 1 (mecab-get-lattice-level m)) - (mecab-set-lattice-level m 2) - (test* "set to 2" 2 (mecab-get-lattice-level m)) - (mecab-set-lattice-level m 0) - (test* "set to 0" 0 (mecab-get-lattice-level m)) - - (test-section "mecab-get[set]-all-morphs: ��ϥ⡼��0/1)") - (test* "default all-morphs" 0 (mecab-get-all-morphs m)) - (mecab-set-all-morphs m 1) - (test* "set to 1" 1 (mecab-get-all-morphs m)) - (mecab-set-all-morphs m 0) - (test* "set to 0" 0 (mecab-get-all-morphs m)) - ) - -;;;;;;;;;; -;; -;; TO DO -;; -;;(test-section "mecab-do") -;;(test-section "mecab-dict-index") -;;(test-section "mecab-dict-gen") -;;(test-section "mecab-cost-train") -;;(test-section "mecab-system-eval") -;;(test-section "mecab-test-gen") - -;;; -;;; tagger (message passing) -;;; -(test-section "tagger") -(let1 tagger (mecab-tagger "") - (test* "tagger'parse-to-string" - (string-join '("���\t̾���ǽ,*,*,*,*,���,���祦,���硼" - "��������*,*,*,*,���� "��\tư���Ω,*,*,������������������,��" - "�ʤ�\t���,*,*,��졦�ʥ�,����ʤ�,�ʥ�,�ʥ�" - "��t���³��*,*,*,*,������ - "��t������*,*,*,*,������ - "EOS" - "") "\n") - ([tagger'parse-to-string] "����⤷�ʤ��Ȥ�)) - - (let1 node ([tagger'parse-to-node] "����⤷�ʤ��Ȥ�) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "" (mecab-node-surface node)) - (test* "mecab-node-feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) - (test* "mecab-node-cost" 0 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "���" (mecab-node-surface node)) - (test* "mecab-node-feature" "̾���ǽ,*,*,*,*,���,���祦,���硼" (mecab-node-feature node)) - (test* "mecab-node-cost" 3947 (mecab-node-cost node)) - ;;(test* "format-node" "" ([tagger'format-node] node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "��(mecab-node-surface node)) - (test* "mecab-node-feature" "������*,*,*,*,����(mecab-node-feature node)) - (test* "mecab-node-cost" 5553 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "��" (mecab-node-surface node)) - (test* "mecab-node-feature" "ư���Ω,*,*,������������������,��" (mecab-node-feature node)) - (test* "mecab-node-cost" 11566 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "�ʤ�" (mecab-node-surface node)) - (test* "mecab-node-feature" "���,*,*,��졦�ʥ�,����ʤ�,�ʥ�,�ʥ�" (mecab-node-feature node)) - (test* "mecab-node-cost" 3601 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "�� (mecab-node-surface node)) - (test* "mecab-node-feature" "���³��*,*,*,*,������ (mecab-node-feature node)) - (test* "mecab-node-cost" 4716 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "�� (mecab-node-surface node)) - (test* "mecab-node-feature" "������*,*,*,*,������ (mecab-node-feature node)) - (test* "mecab-node-cost" 10676 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #t (mecab-node? node)) - (test* "mecab-node-surface" "" (mecab-node-surface node)) - (test* "mecab-node-feature" "BOS/EOS,*,*,*,*,*,*,*,*" (mecab-node-feature node)) - (test* "mecab-node-cost" 8292 (mecab-node-cost node)) - - (set! node (mecab-node-next node)) - (test* "mecab-node?" #f (mecab-node? node)) - )) - -(test-end)