Index: lang/gauche/cabocha-gauche-0.60pre4/cabocha.c
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/cabocha.c (revision 88)
+++ lang/gauche/cabocha-gauche-0.60pre4/cabocha.c (revision 89)
@@ -9,4 +9,6 @@
 #include <gauche/extend.h>
 
+#include <mecab.h>
+#include "mecab.h"
 #include <cabocha.h>
 #include "cabocha.h"
@@ -25,4 +27,55 @@
 }
 
+// cabocha_tree_t
+cabocha_tree_t* unwrap_cabocha_tree_t(ScmObj obj)
+{
+  return SCM_CABOCHA_TREE(obj)->ctree;
+}
+ScmObj wrap_cabocha_tree_t(cabocha_tree_t *ctree)
+{
+  ScmCaboChaTree *obj = SCM_NEW(ScmCaboChaTree);
+  SCM_SET_CLASS(obj, SCM_CLASS_CABOCHA_TREE);
+  obj->ctree = ctree;
+  return SCM_OBJ(obj);
+}
+
+// cabocha_chunk_t
+cabocha_chunk_t* unwrap_cabocha_chunk_t(ScmObj obj)
+{
+  return SCM_CABOCHA_CHUNK(obj)->cchunk;
+}
+ScmObj wrap_cabocha_chunk_t(cabocha_chunk_t *cchunk)
+{
+  ScmCaboChaChunk *obj = SCM_NEW(ScmCaboChaChunk);
+  SCM_SET_CLASS(obj, SCM_CLASS_CABOCHA_CHUNK);
+  obj->cchunk = cchunk;
+  return SCM_OBJ(obj);
+}
+
+// cabocha_token_t
+cabocha_token_t* unwrap_cabocha_token_t(ScmObj obj)
+{
+  return SCM_CABOCHA_TOKEN(obj)->ctok;
+}
+ScmObj wrap_cabocha_token_t(cabocha_token_t *ctok)
+{
+  ScmCaboChaToken *obj = SCM_NEW(ScmCaboChaToken);
+  SCM_SET_CLASS(obj, SCM_CLASS_CABOCHA_TOKEN);
+  obj->ctok = ctok;
+  return SCM_OBJ(obj);
+}
+
+/* mecab_node_t */
+const mecab_node_t* unwrap_mecab_node_t(ScmObj obj)
+{
+  return SCM_MECAB_NODE(obj)->mn;
+}
+ScmObj wrap_mecab_node_t(const mecab_node_t *mn)
+{
+  ScmMeCabNode *obj = SCM_NEW(ScmMeCabNode);
+  SCM_SET_CLASS(obj, SCM_CLASS_MECAB_NODE);
+  obj->mn = mn;
+  return SCM_OBJ(obj);
+}
 
 /* APIs with (int argc, char **argv) */
@@ -67,4 +120,14 @@
 }
 
+ScmObj Scm_MakeStringList(const char **strs, int size)
+{
+  if (size==0) return SCM_NIL;
+  ScmObj p = Scm_Cons(SCM_MAKE_STR_COPYING(strs[size-1]),SCM_NIL);
+  for (int i=size-2; i>=0; i--) {
+    p = Scm_Cons(SCM_MAKE_STR_COPYING(strs[i]), p);
+  }
+  return p;
+}
+
 /*
  * Module initialization function.
Index: lang/gauche/cabocha-gauche-0.60pre4/cabocha.scm
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/cabocha.scm (revision 88)
+++ lang/gauche/cabocha-gauche-0.60pre4/cabocha.scm (revision 89)
@@ -8,10 +8,52 @@
   (export <cabocha>
 		  cabocha?
+		  cabocha-do
 		  cabocha-new cabocha-new2
-		  cabocha-destroy
-		  cabocha-destroyed?
-
 		  cabocha-sparse-tostr cabocha-sparse-tostr2
 		  cabocha-strerror
+		  cabocha-destroy cabocha-destroyed?
+		  cabocha-sparse-totree cabocha-sparse-totree2
+
+		  cabocha-tree-new
+		  cabocha-tree-destroy
+		  cabocha-tree-empty
+		  cabocha-tree-clear
+		  cabocha-tree-clear-chunk
+		  cabocha-tree-size
+		  cabocha-tree-chunk-size
+		  cabocha-tree-token-size
+		  cabocha-tree-sentence
+		  cabocha-tree-sentence-size
+		  cabocha-tree-set-sentence
+		  cabocha-tree-read
+		  cabocha-tree-read-from-mecab-node
+		  cabocha-tree-token
+		  cabocha-tree-chunk
+		  cabocha-tree-add-token
+		  cabocha-tree-add-chunk
+		  cabocha-tree-strdup
+		  cabocha-tree-alloc
+		  cabocha-tree-tostr
+		  cabocha-tree-set-charset cabocha-tree-charset
+		  cabocha-tree-set-posset cabocha-tree-posset
+		  cabocha-tree-set-output-layer cabocha-tree-output-layer
+
+		  cabocha-learn
+		  cabocha-system-eval
+		  cabocha-model-index
+
+		  cabocha-chunk-link
+		  cabocha-chunk-head-pos cabocha-chunk-func-pos
+		  cabocha-chunk-token-size cabocha-chunk-token-pos
+		  cabocha-chunk-score
+		  cabocha-chunk-feature-list cabocha-chunk-feature-list-size
+
+		  cabocha-token-surface
+		  cabocha-token-normalized-surface
+		  cabocha-token-feature
+		  cabocha-token-feature-list
+		  cabocha-token-feature-list-size
+		  cabocha-token-ne
+		  cabocha-token-chunk
           ))
 
Index: lang/gauche/cabocha-gauche-0.60pre4/Makefile.in
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/Makefile.in (revision 88)
+++ lang/gauche/cabocha-gauche-0.60pre4/Makefile.in (revision 89)
@@ -49,5 +49,5 @@
 cabocha.$(SOEXT): $(cabocha_SRCS)
 	$(GAUCHE_PACKAGE) compile \
-	  --local=$(LOCAL_PATHS) --ldflags=-lcabocha --verbose cabocha $(cabocha_SRCS)
+	  --local=$(LOCAL_PATHS) --ldflags="-lmecab -lcabocha" --verbose cabocha $(cabocha_SRCS)
 
 check : all
Index: lang/gauche/cabocha-gauche-0.60pre4/cabochalib.stub
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/cabochalib.stub (revision 88)
+++ lang/gauche/cabocha-gauche-0.60pre4/cabochalib.stub (revision 89)
@@ -9,4 +9,6 @@
 #include <gauche/extend.h>
 
+#include <mecab.h>
+#include \"mecab.h\"
 #include <cabocha.h>
 #include \"cabocha.h\"
@@ -16,9 +18,34 @@
 
 (define-cclass <cabocha> "ScmCaboCha*" "Scm_CaboChaClass" () ())
-
 (define-type <cabocha-t> "cabocha_t*" "cabocha_t"
   "SCM_CABOCHAP" "unwrap_cabocha_t" "wrap_cabocha_t")
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define-cclass <cabocha-tree> "ScmCaboChaTree*" "Scm_CaboChaTreeClass" () ())
+(define-type <cabocha-tree-t> "cabocha_tree_t*" "cabocha_tree_t"
+  "SCM_CABOCHA_TREEP" "unwrap_cabocha_tree_t" "wrap_cabocha_tree_t")
+
+(define-cclass <cabocha-chunk> "ScmCaboChaChunk*" "Scm_CaboChaChunkClass" () ())
+(define-type <cabocha-chunk-t> "cabocha_chunk_t*" "cabocha_chunk_t"
+  "SCM_CABOCHA_CHUNKP" "unwrap_cabocha_chunk_t" "wrap_cabocha_chunk_t")
+
+(define-cclass <cabocha-token> "ScmCaboChaToken*" "Scm_CaboChaTokenClass" () ())
+(define-type <cabocha-token-t> "cabocha_token_t*" "cabocha_token_t"
+  "SCM_CABOCHA_TOKENP" "unwrap_cabocha_token_t" "wrap_cabocha_token_t")
+
+;;;
+;(define-cclass <mecab> "ScmMeCab*" "Scm_MeCabClass" () ())
+(define-cclass <mecab-node> "ScmMeCabNode*" "Scm_MeCabNodeClass" () ())
+;(define-cclass <mecab-dictionary-info> "ScmMeCabDictionaryInfo*" "Scm_MeCabDictionaryInfoClass" () ())
+(define-type <const-mecab-node-t> "const mecab_node_t*" "const mecab_node_t"
+  "SCM_MECAB_NODEP" "unwrap_mecab_node_t" "wrap_mecab_node_t")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-cproc cabocha-do (&rest args)
+  (expr <int> "cabocha_call_int_func(&cabocha_do,args)"))
+
+;;
+;; parser
+;;
 
 ;;cabocha_t *cabocha_new(int argc, char **argv)
@@ -73,4 +100,117 @@
 "  SCM_RETURN(SCM_MAKE_BOOL(c == NULL)); ")
 
+;;
+(define-cproc cabocha-sparse-totree (c::<cabocha-t> str::<const-cstring>)
+  (call <cabocha-tree-t> "cabocha_sparse_totree"))
+
+(define-cproc cabocha-sparse-totree2 (c::<cabocha-t> str::<const-cstring> len::<uint>)
+  (call <cabocha-tree-t> "cabocha_sparse_totree2"))
+
+;;
+;; tree
+;;
+(define-cproc cabocha-tree-new ()
+  (call <cabocha-tree-t> "cabocha_tree_new"))
+(define-cproc cabocha-tree-destroy (tree::<cabocha-tree-t>)
+  (call <void> "cabocha_tree_destroy"))
+(define-cproc cabocha-tree-empty (tree::<cabocha-tree-t>)
+  (call <int> "cabocha_tree_empty"))
+(define-cproc cabocha-tree-clear (tree::<cabocha-tree-t>)
+  (call <void> "cabocha_tree_clear"))
+(define-cproc cabocha-tree-clear-chunk (tree::<cabocha-tree-t>)
+  (call <void> "cabocha_tree_clear_chunk"))
+(define-cproc cabocha-tree-size (tree::<cabocha-tree-t>)
+  (call <uint> "cabocha_tree_size"))
+(define-cproc cabocha-tree-chunk-size (tree::<cabocha-tree-t>)
+  (call <uint> "cabocha_tree_chunk_size"))
+(define-cproc cabocha-tree-token-size (tree::<cabocha-tree-t>)
+  (call <uint> "cabocha_tree_token_size"))
+(define-cproc cabocha-tree-sentence (tree::<cabocha-tree-t>)
+  (call <const-cstring> "cabocha_tree_sentence"))
+(define-cproc cabocha-tree-sentence-size (tree::<cabocha-tree-t>)
+  (call <uint> "cabocha_tree_sentence_size"))
+(define-cproc cabocha-tree-set-sentence (tree::<cabocha-tree-t> sentence::<const-cstring> length::<uint>)
+  (call <void> "cabocha_tree_set_sentence"))
+(define-cproc cabocha-tree-read (tree::<cabocha-tree-t> input::<const-cstring> length::<uint> input-layer::<int>)
+  ;; cabocha_input_layer_t : enum { INPUT_RAW_SENTENCE, _POS, _CHUNK, _SELECTION, _DEP }
+  (call <int> "cabocha_tree_read"))
+(define-cproc cabocha-tree-read-from-mecab-node (tree::<cabocha-tree-t> node::<const-mecab-node-t>)
+  (call <int> "cabocha_tree_read_from_mecab_node"))
+
+(define-cproc cabocha-tree-token (tree::<cabocha-tree-t> i::<uint>)
+  (call <cabocha-token-t> "cabocha_tree_token")) ;; const
+(define-cproc cabocha-tree-chunk (tree::<cabocha-tree-t> i::<uint>)
+  (call <cabocha-chunk-t> "cabocha_tree_chunk")) ;; const
+
+(define-cproc cabocha-tree-add-token (tree::<cabocha-tree-t>)
+  (call <cabocha-token-t> "cabocha_tree_add_token"))
+(define-cproc cabocha-tree-add-chunk (tree::<cabocha-tree-t>)
+  (call <cabocha-chunk-t> "cabocha_tree_add_chunk"))
+
+(define-cproc cabocha-tree-strdup (tree::<cabocha-tree-t> str::<const-cstring>)
+  (call <const-cstring> "cabocha_tree_strdup"))
+(define-cproc cabocha-tree-alloc (tree::<cabocha-tree-t> size::<uint>)
+  (call <const-cstring> "cabocha_tree_alloc"))
+
+(define-cproc cabocha-tree-tostr (tree::<cabocha-tree-t> format::<int>) ;; cabocha_format_t : ENUM { FORMAT-TREE -LATTICE -TREE_LATTICE -XML -NONE }
+  (call <const-cstring> "cabocha_tree_tostr"))
+;(define-cproc cabocha-tree-tostr2 (tree::<cabocha-tree-t> format::<cabocha-format-t str::<const-cstring> length::<uint>)
+;  const char            *cabocha_tree_tostr2(cabocha_tree_t* tree, cabocha_format_t format,
+;                                                                char *str, size_t length);
+(define-cproc cabocha-tree-set-charset (tree::<cabocha-tree-t> charset::<int>) ;; cabocha_charset_t : enum { EUC_JP, CP932, UTF8, ASCII }
+  (call <void> "cabocha_tree_set_charset"))
+(define-cproc cabocha-tree-charset (tree::<cabocha-tree-t>)
+  (call <int> "cabocha_tree_charset")) ;; cabocha_charset_t
+(define-cproc cabocha-tree-set-posset (tree::<cabocha-tree-t> posset::<int>) ;; cabocha_posset_t : enum { IPA, JUMAN }
+  (call <void> "cabocha_tree_set_posset"))
+(define-cproc cabocha-tree-posset (tree::<cabocha-tree-t>)
+  (call <int> "cabocha_tree_posset")) ;; cabocha_posset_t
+(define-cproc cabocha-tree-set-output-layer (tree::<cabocha-tree-t> output-layer::<int>)
+  ;; cabocha_output_layer_t : enum { OUTPUT*_RAW_SENTENCE, _POS, _CHUNK, _SELECTION, _DEP }
+  (call <void> "cabocha_tree_set_output_layer"))
+(define-cproc cabocha-tree-output-layer (tree::<cabocha-tree-t>)
+  (call <int> "cabocha_tree_output_layer")) ;; cabocha_output_layer_t
+
+(define-cproc cabocha-learn (&rest args)
+  (expr <int> "cabocha_call_int_func(&cabocha_learn,args)"))
+(define-cproc cabocha-system-eval (&rest args)
+  (expr <int> "cabocha_call_int_func(&cabocha_system_eval,args)"))
+(define-cproc cabocha-model-index (&rest args)
+  (expr <int> "cabocha_call_int_func(&cabocha_model_index,args)"))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define-cproc cabocha-chunk-link (chunk::<cabocha-chunk-t>)
+  (expr <int> "chunk->link"))
+(define-cproc cabocha-chunk-head-pos (chunk::<cabocha-chunk-t>)
+  (expr <uint> "chunk->head_pos"))
+(define-cproc cabocha-chunk-func-pos (chunk::<cabocha-chunk-t>)
+  (expr <uint> "chunk->func_pos"))
+(define-cproc cabocha-chunk-token-size (chunk::<cabocha-chunk-t>)
+  (expr <uint> "chunk->token_size"))
+(define-cproc cabocha-chunk-token-pos (chunk::<cabocha-chunk-t>)
+  (expr <uint> "chunk->token_pos"))
+(define-cproc cabocha-chunk-score (chunk::<cabocha-chunk-t>)
+  (expr <float> "chunk->score"))
+(define-cproc cabocha-chunk-feature-list (chunk::<cabocha-chunk-t>)
+" return Scm_MakeStringList(chunk->feature_list,chunk->feature_list_size);")
+(define-cproc cabocha-chunk-feature-list-size (chunk::<cabocha-chunk-t>)
+  (expr <uint> "chunk->feature_list_size"))
+
+(define-cproc cabocha-token-surface (token::<cabocha-token-t>)
+  (expr <const-cstring> "token->surface"))
+(define-cproc cabocha-token-normalized-surface (token::<cabocha-token-t>)
+  (expr <const-cstring> "token->normalized_surface"))
+(define-cproc cabocha-token-feature (token::<cabocha-token-t>)
+  (expr <const-cstring> "token->feature"))
+(define-cproc cabocha-token-feature-list (token::<cabocha-token-t>)
+" return Scm_MakeStringList(token->feature_list,token->feature_list_size);")
+(define-cproc cabocha-token-feature-list-size (token::<cabocha-token-t>)
+  (expr <uint> "token->feature_list_size"))
+(define-cproc cabocha-token-ne (token::<cabocha-token-t>)
+  (expr <const-cstring> "token->ne"))
+(define-cproc cabocha-token-chunk (token::<cabocha-token-t>)
+  (expr <cabocha-chunk-t> "token->chunk"))
+
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
Index: lang/gauche/cabocha-gauche-0.60pre4/cabocha.h
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/cabocha.h (revision 88)
+++ lang/gauche/cabocha-gauche-0.60pre4/cabocha.h (revision 89)
@@ -15,5 +15,5 @@
 SCM_DECL_BEGIN
 
-/* CaboCha_t wrapper */
+/* cabocha_t wrapper */
 typedef struct ScmCaboChaRec {
   SCM_HEADER;
@@ -27,7 +27,44 @@
 extern ScmObj wrap_cabocha_t(cabocha_t *m);
 
+/* cabocha_tree_t wrapper */
+typedef struct ScmCaboChaTreeRec {
+  SCM_HEADER;
+  cabocha_tree_t *ctree; /* NULL if closed */
+} ScmCaboChaTree;
+SCM_CLASS_DECL(Scm_CaboChaTreeClass);
+#define SCM_CLASS_CABOCHA_TREE       (&Scm_CaboChaTreeClass)
+#define SCM_CABOCHA_TREE(obj)        ((ScmCaboChaTree*)(obj))
+#define SCM_CABOCHA_TREEP(obj)       (SCM_XTYPEP(obj, SCM_CLASS_CABOCHA_TREE))
+extern cabocha_tree_t* unwrap_cabocha_tree_t(ScmObj obj);
+extern ScmObj wrap_cabocha_tree_t(cabocha_tree_t *m);
+
+/* cabocha_chunk_t wrapper */
+typedef struct ScmCaboChaChunkRec {
+  SCM_HEADER;
+  cabocha_chunk_t *cchunk; /* NULL if closed */
+} ScmCaboChaChunk;
+SCM_CLASS_DECL(Scm_CaboChaChunkClass);
+#define SCM_CLASS_CABOCHA_CHUNK       (&Scm_CaboChaChunkClass)
+#define SCM_CABOCHA_CHUNK(obj)        ((ScmCaboChaChunk*)(obj))
+#define SCM_CABOCHA_CHUNKP(obj)       (SCM_XTYPEP(obj, SCM_CLASS_CABOCHA_CHUNK))
+extern cabocha_chunk_t* unwrap_cabocha_chunk_t(ScmObj obj);
+extern ScmObj wrap_cabocha_chunk_t(cabocha_chunk_t *m);
+
+/* cabocha_token_t wrapper */
+typedef struct ScmCaboChaTokenRec {
+  SCM_HEADER;
+  cabocha_token_t *ctok; /* NULL if closed */
+} ScmCaboChaToken;
+SCM_CLASS_DECL(Scm_CaboChaTokenClass);
+#define SCM_CLASS_CABOCHA_TOKEN       (&Scm_CaboChaTokenClass)
+#define SCM_CABOCHA_TOKEN(obj)        ((ScmCaboChaToken*)(obj))
+#define SCM_CABOCHA_TOKENP(obj)       (SCM_XTYPEP(obj, SCM_CLASS_CABOCHA_TOKEN))
+extern cabocha_token_t* unwrap_cabocha_token_t(ScmObj obj);
+extern ScmObj wrap_cabocha_token_t(cabocha_token_t *m);
+
+
 /* APIs with (int argc, char **argv) */
 typedef cabocha_t *(*cabocha_func_with_args)(int argc, char **argv);
-typedef int (*int_func_with_args)(int argc, char **argv);
+// typedef int (*int_func_with_args)(int argc, char **argv);
 extern cabocha_t *cabocha_call_cabocha_func(cabocha_func_with_args fn, ScmObj args);
 extern int cabocha_call_int_func(int_func_with_args fn, ScmObj args);
Index: lang/gauche/cabocha-gauche-0.60pre4/mecab.h
===================================================================
--- lang/gauche/cabocha-gauche-0.60pre4/mecab.h (revision 89)
+++ lang/gauche/cabocha-gauche-0.60pre4/mecab.h (revision 89)
@@ -0,0 +1,62 @@
+/*
+ * mecab.h
+ *
+ *  2009.3.13 by naoya_t
+ *
+ */
+
+/* Prologue */
+#ifndef GAUCHE_MECAB_H
+#define GAUCHE_MECAB_H
+
+#include <gauche.h>
+#include <gauche/extend.h>
+
+SCM_DECL_BEGIN
+
+/* mecab_t wrapper */
+typedef struct ScmMeCabRec {
+  SCM_HEADER;
+  mecab_t *m; /* NULL if closed */
+} ScmMeCab;
+SCM_CLASS_DECL(Scm_MeCabClass);
+#define SCM_CLASS_MECAB       (&Scm_MeCabClass)
+#define SCM_MECAB(obj)        ((ScmMeCab*)(obj))
+#define SCM_MECABP(obj)       (SCM_XTYPEP(obj, SCM_CLASS_MECAB))
+extern mecab_t* unwrap_mecab_t(ScmObj obj);
+extern ScmObj wrap_mecab_t(mecab_t *m);
+
+/* mecab_node_t wrapper */
+typedef struct ScmMeCabNodeRec {
+  SCM_HEADER;
+  const mecab_node_t *mn; /* NULL if closed */
+} ScmMeCabNode;
+SCM_CLASS_DECL(Scm_MeCabNodeClass);
+#define SCM_CLASS_MECAB_NODE  (&Scm_MeCabNodeClass)
+#define SCM_MECAB_NODE(obj)   ((ScmMeCabNode*)(obj))
+#define SCM_MECAB_NODEP(obj)  (SCM_XTYPEP(obj, SCM_CLASS_MECAB_NODE))
+extern const mecab_node_t* unwrap_mecab_node_t(ScmObj obj);
+extern ScmObj wrap_mecab_node_t(const mecab_node_t *m);
+
+/* mecab_dictionary_info_t wrapper */
+typedef struct ScmMeCabDictionaryInfoRec {
+  SCM_HEADER;
+  const mecab_dictionary_info_t *mdi; /* NULL if closed */
+} ScmMeCabDictionaryInfo;
+SCM_CLASS_DECL(Scm_MeCabDictionaryInfoClass);
+#define SCM_CLASS_MECAB_DICTIONARY_INFO  (&Scm_MeCabDictionaryInfoClass)
+#define SCM_MECAB_DICTIONARY_INFO(obj)   ((ScmMeCabDictionaryInfo*)(obj))
+#define SCM_MECAB_DICTIONARY_INFOP(obj)  (SCM_XTYPEP(obj, SCM_CLASS_MECAB_DICTIONARY_INFO))
+extern const mecab_dictionary_info_t* unwrap_mecab_dictionary_info_t(ScmObj obj);
+extern ScmObj wrap_mecab_dictionary_info_t(const mecab_dictionary_info_t *m);
+
+/* APIs with (int argc, char **argv) */
+typedef mecab_t *(*mecab_func_with_args)(int argc, char **argv);
+typedef int (*int_func_with_args)(int argc, char **argv);
+extern mecab_t *mecab_call_mecab_func(mecab_func_with_args fn, ScmObj args);
+extern int mecab_call_int_func(int_func_with_args fn, ScmObj args);
+
+/* Epilogue */
+SCM_DECL_END
+
+#endif  /* GAUCHE_MECAB_H */