Programming in Gauche
*********************

Invoking Gosh
=============

Gauche can be used either as an independent Scheme interpreter or as an embedded Scheme library.   The interpreter which comes with Gauche distribution is a program named gosh. Gaucheは独立したSchemeインタプリタとしても、組み込みのSchemeライブラリとしても使うことができます。Gaucheのディストリビューションには、goshというインタプリタが附属しています。

 -- Program: gosh [options] [scheme-file arg ...]
     Gauche's interpreter.   Without SCHEME-FILE, gosh works interactively, i.e. it reads a Scheme expression from the standard input, evaluates it, and prints the result, and repeat that until it reads EOF or is terminated. Gaucheのインタプリタです。  SCHEME-FILEが与えられなければ、 goshはインタラクティブに動作します。すなわち、標準入力からScheme式を読み込み、それを評価して結果をプリントするという動作を、EOFを読むか明示的に終了させられるまで続けます。

     If gosh is invoked without SCHEME-FILE, but the input is not a terminal, it enters read-eval-print loop but not writes out a prompt while waiting input form.  This is useful when you pipe Scheme program into gosh.  You can force this behavior or suppress this behavior by -b and -i options. もしSCHEME-FILEが与えられておらず、しかし入力が端末でない場合、 goshはread-eval-printループに入りますが、入力待ちの際にプロンプトを表示しません。これはScheme式をパイプでGOSHに処理させる場合に便利です。 -bまたは-iオプションでこの動作を強制的にonまたはoffできます。

     If SCHEME-FILE is specified, gosh runs it as a Scheme program and exit. See Writing Scheme scripts, for details. SCHEME-FILEが与えられた場合、goshはそれをSchemeプログラムとしてロードし、終了します。この動作に関してはWriting Scheme scriptsを参照して下さい。

Command-line options
--------------------

コマンドラインオプション
------------

The following command line options are recognized by gosh. The first command line argument which doesn't begin with `-' is recognized as the script file.  If you want to specify a file that begins with a minus sign, use a dummy option `--'. 以下のコマンドラインオプションがgoshに認識されます。 `-' で始まらない最初のコマンドライン引数がスクリプトファイルと認識されます。スクリプトファイル名が `-' で始まっている可能性がある場合は、ダミーオプション `--' をスクリプトファイル名の前に置いて下さい。

 -- Command Option: -I path
     Prepends PATH to the load path list. You can specify this option more than once to add multiple paths. PATHをロードパスのリストの最初に加えます。このオプションは複数指定できます。

 -- Command Option: -A path
     Appends PATH to the tail of the load path list. You can specify this option more than once to add multiple paths. PATHをロードパスのリストの末尾に加えます。このオプションは複数指定できます。

 -- Command Option: -q
     Makes gosh not to load the default initialization file. goshが起動時にシステムの初期化ファイルを読まないようにします。

 -- Command Option: -V
     Prints the gosh version and exits. goshのバージョンを表示して終了します。

 -- Command Option: -u module
     Use MODULE.  Before starting execution of SCHEME-FILE or entering the read-eval-print loop, the specified module is USEd, i.e. it is loaded and imported (see Defining and selecting modules, for details of use). You can specify this option more than once to use multiple modules. 起動後、インタラクティブなread-eval-printループに入る前、もしくはSCHEME-FILE をロードする前にMODULEを``use''します。つまりそのモジュールがロードされインポートされます。(useの詳細についてはDefining and selecting modulesを参照して下さい)。このオプションは複数回指定できます。

 -- Command Option: -l file
     Load FILE before starting execution of SCHEME-FILE or entering the read-eval-print loop.   The file is loaded in the same way as load (see Loading Scheme file). You can specify this option more than once to load multiple files. 起動後、インタラクティブなread-eval-printループに入る前、もしくはSCHEME-FILE をロードする前にFILEをロードします(ロードの詳細についてはLoading Scheme file を参照して下さい)。このオプションは複数回指定できます。

 -- Command Option: -e scheme-expression
     Evaluate SCHEME-EXPRESSION before starting execution of SCHEME-FILE or entering the read-eval-print loop.   Evaluation is done in the INTERACTION-ENVIRONMENT (see Eval and repl). You can specify this option more than once to evaluate multiple experssions. 起動後、インタラクティブなread-eval-printループに入る前、もしくはSCHEME-FILE をロードする前にSCHEME-EXPRESSIONを評価します。評価は INTERACTION-ENVIRONMENT中で行われます(Eval and repl参照)。このオプションは複数回指定できます。

 -- Command Option: -E scheme-expression
     Same as -e, except the SCHEME-EXPERSSION is read as if it is surrounded by parenthesis.  For example: オプション-eとほぼ同じですが、SCHEME-EXPRESSIONはそれが括弧で囲まれているかのように読まれます。このオプションは複数回指定できます。例：

          % gosh -umath.const -E"print (sin (* pi/180 15))" -Eexit
          0.25881904510252074

 -- Command Option: -b
     Batch. Does not print prompts in read-eval-print loop even if the input is a terminal. バッチ。入力が端末であっても、read-eval-printループがプロンプトを出さないようにします。

 -- Command Option: -i
     Interactive. Print prompts in read-eval-print loop even if the input is not a terminal. インタラクティブ。入力が端末で無くても、read-eval-printループがプロンプトを出すようにします。

 -- Command Option: -f compiler-option
     This option controls compiler and runtime behavior.  For now we have following options available:

     no-inline
          Prohibits the compiler from inilining primitive Scheme procedures.

     no-source-info
          Don't keep source information for debugging.  Consumes less memory.

     load-verbose
          Reports whenever a file is loaded.

     case-fold
          Ignore case for symbols as specified in R5RS. (It is distinguished by default).  See Case-sensitivity.

     test
          Adds "../src" and "../lib" to the load path before loading initialization file.  This is useful when you want to test the compiled gosh interpreter inside source tree, without installing it.

     このオプションはコンパイラとランタイムの動作に影響を与えます。今のところ、次のオプションのみがCOMPILER-OPTIONとして有効です。

     no-inline
          Schemeの基本関数のインライン展開を行いません。

     no-source-info
          デバッグのためのソースファイル情報を保持しません。メモリの使用量は小さくなります。

     load-verbose
          ファイルがロードされる時にそれを報告します。

     case-fold
          R5RSに示される通り、シンボルの大文字小文字を区別しません。 (デフォルトではこれらは区別されます)。 Case-sensitivity を参照して下さい。

     test
          "../src" と "../lib" を、初期化ファイルを読む前にロードパスに加えます。これは、作成されたgoshをインストールせずにソースツリーの中で実行してみるのに便利です。

 -- Command Option: --
     When gosh sees this option, it stops processing the options and takes next command line argument as a script file.  It is useful in case if you have a script file that begins with a minus sign, although it is not generally recommended. このオプションに出会うと、goshはオプションの解析を止めて、その次の引数を無条件にSCHEME-FILEであると見倣します。SCHEME-FILEがマイナス記号で始まっている場合に必要です。

The options -I, -A, -l, -u, -e and -E are processes in the order of appearance.  For example, adding a load path by -I affects the -l and -u option after it but not before it. オプション-I, -A, -l, -u, -e 及び -E は、それらがコマンドライン引数として出現した順に処理されます。例えば、-Iにより追加されるロードパスはそれ以降の-lや-uオプションに影響を与えますが、それ以前のものには影響を与えません。

Environment variables
---------------------

環境変数
----

The following enviornment variables are recognized: 以下の環境変数を認識します。

 -- Environment variable: GAUCHE_LOAD_PATH
     You can specify additional load paths by this environment variable, delimiting the paths by ':'. The paths are appended before the system default load paths. この環境変数によって、追加するロードパスを指定できます。パスは ':' で区切ります。この変数によって指定されたパスはシステムのデフォルトのロードパスの前に連結されます。

 -- Environment variable: GAUCHE_DYNLOAD_PATH
     You can specify additional load paths for dynamically loaded objects by this environment variable, delimiting the paths by ':'. The paths are appended before the system default load paths. この変数によって、動的にロードするオブジェクト用の追加ロードパスを指定できます。パスは ':' で区切ります。この変数によって指定されたパスはシステムのデフォルトのロードパスの前に連結されます。

Interactive development
=======================

When gosh is invoked without any script files, it goes into interactive read-eval-print loop. スクリプトファイルが与えられなかった場合、 goshはインタラクティブなread-eval-printループに入ります。

To exit the interpreter, type EOF (usually Control-D in Unix termials) or evaluate (exit). インタプリタを終了するには、EOF文字(Unix端末では通常Control-D)をタイプするか、 (exit)を評価します。

In interactive session, gosh loads gauche.interactive module (see Interactive session) for the convenience.  The module also loads a file .gaucherc under the user's home directory if it exists. You may put settings there that would help interactive debugging. (As of Gauche release 0.7.3, .gauchrc is no longer loaded when gosh is run in script mode.) インタラクティブセッションでは、goshは gauche.interactiveモジュールをロードします (Interactive session参照)。このモジュールはまた、ユーザーのホームディレクトリに.gauchercというファイルがあればをれをロードします。インタラクティブデバッグに便利な設定をそこに書いておくことができます。 (Gauche release 0.7.3から、.gauchercはgoshがスクリプトモードで起動された時は読まれなくなりました)。

I recommend you to run gosh inside Emacs, for it has rich features useful to interact with internal Scheme process. Put the following line to your .emacs file:

     (setq scheme-program-name "gosh")

And you can run gosh by M-x run-scheme. goshをEmacs内部で走らせることをお勧めします。 EmacsはSchemeサブプロセスを操作するための豊富な機能を持っています。次の行を.emacsに加えておくと、M-x run-scheme で Emacsのバッファ内でgoshが走ります。

     (setq scheme-program-name "gosh")

If you want to use multibyte characters in the interaction, make sure your terminal's settings is in sync with gosh's internal character encodings. 対話環境でマルチバイト文字を使う場合は、端末の文字エンコーディングをgoshの内部エンコーディングと合わせるようにして下さい。

Currently gosh has no fancy features such as line-editing or command history.   They'll be added in future. 今のところ、goshは行編集やコマンドヒストリなどの便利な機能を備えていません。将来はこのへんも充実してゆくでしょう。

Debugging
=========

Gauche doesn't have much support for debugging yet. The idea of good debugging interfaces are welcome. Gaucheにはまだデバッグをサポートする機能があまり実装されていません。デバッギングのインタフェースに関して良いアイディアがあればお寄せください。

For now, the author uses the classic 'debug print stub' technique when necessary.  A special reader syntax #?=EXPR is defined, which is read as (debug-print EXPR). The macro debug-print evaluates and returns the result(s), printing messages before and after evaluation of EXPR. 今のところ、作者は必要な時は古典的な「プリントスタブ」方式を使っています。そのためのリーダーマクロ #?=EXPR が定義されています。これは (debug-print EXPR) のように読まれ、マクロ debug-print はEXPRを評価してその値を返しますが、評価前と評価後にメッセージを出力します。

     gosh> #?=(+ 2 3)
     #?="(stdin)":1:(+ 2 3)
     #?-    5
     5
     gosh> #?=(begin (print "foo") (values 'a 'b 'c))
     #?="(stdin)":2:(begin (print "foo") (values 'a 'b 'c))
     foo
     #?-    a
     #?+    b
     #?+    c
     a
     b
     c
     gosh> (define (fact n)
             (if (zero? n)
                 1
                 (* n #?=(fact (- n 1)))))
     fact
     gosh> (fact 5)
     #?="(stdin)":6:(fact (- n 1))
     #?="(stdin)":6:(fact (- n 1))
     #?="(stdin)":6:(fact (- n 1))
     #?="(stdin)":6:(fact (- n 1))
     #?="(stdin)":6:(fact (- n 1))
     #?-    1
     #?-    1
     #?-    2
     #?-    6
     #?-    24
     120

You can also use trace/untrace macros in Gauche, written by Shigenobu Kimura: http://homepage.mac.com/skimu/ggc/. また、木村栄伸さんがGauche用のtrace/untraceマクロを書いてくれました： http://homepage.mac.com/skimu/ggc/.

Writing Scheme scripts
======================

When a Scheme program file is given to gosh, it bounds a global varialbe *argv* to the list of the remaining command-line arguments, then loads the Scheme program. If the first line of SCHEME-FILE begins with two character sequence ``#!'', the entire line is ignored by gosh. This is useful to write a Scheme program that works as an executable script in unix-like systems. goshのコマンドラインにSchemeプログラムのファイル名が渡された場合、 goshはそれ以降のコマンドライン引数のリストをグローバル変数*argv*に束縛し、 Schemeプログラムをロードします。もしSCHEME-FILEの最初の行が``#!''で始まっていたら、その行は無視されます。これにより、Unix系のシステムで実行可能なSchemeスクリプトを書くことが出来ます。

Typical Gauche script has the first line like these

     #!/usr/local/bin/gosh
       or,
     #!/usr/bin/env gosh
       or,
     #!/bin/sh
     :; exec gosh -- $0 "$@"

The second and third form uses a ``shell trampoline'' technique so that the script works as far as gosh is in the PATH. The third form is useful when you want to pass extra arguments to gosh, for typically #!-magic of executable scripts has limitations for the number of arguments to pass the interpreter. 典型的なGaucheスクリプトの最初の行は次のようなものです。

     #!/usr/local/bin/gosh
       または,
     #!/usr/bin/env gosh
       または,
     #!/bin/sh
     :; exec gosh -- $0 "$@"

後の2つは「シェルトランポリン」テクニックを用いて、goshがPATHにあるディレクトリのどこかにあれば起動できるようにしています。3番目の方法は、 goshにいくつかコマンドラインオプションを渡したい時に便利です。

After the file is successfully loaded, gosh calls a procedure named `main' if it is defined in the user module. Main receives a single argument, a list of command line arguments.  Its first element is the script name itself.

When main returns, and its value is an integer, gosh uses it for exit code of the program. Otherwise, gosh exits with exit code 70 (EX_SOFTWARE). This behavior is compatible with the SRFI-22.

If the main procedure is not defined, gosh exits after loading the script file. ファイルが正常にロードされたら、goshは userモジュールに `main' という手続きが定義されているかどうか調べ、定義されていればそれを呼びます。mainには、スクリプトへの引数のリストが唯一の引数として渡されます。リストの最初の要素はスクリプトファイル名です。

mainが整数の値を返したら、goshはその値を終了ステータスとして終了します。 mainが整数以外の値を返した場合はgoshは終了ステータス70 (EX_SOFTWARE)で終了します。このふるまいはSRFI-22と互換です。

mainが定義されていなければgoshはロード後にそのままステータス0で終了します。

Although you can still write the program main body as toplevel expressions, like shell scripts or Perl scripts, it is much convenient to use this `main' convention, for you can load the script file interactively to debug. シェルスクリプトやPerlスクリプトと同じように、スクリプトのボディに直接実行される式を書くこともできますが、なるべく `main' を使った方法を使うことをお薦めします。そうすると、スクリプトをインタプリタにインタラクティブにロードしてデバッグすることもできます。

 -- Variable: *argv*
     The program arguments passed to the Scheme script is bound to this variable.  If gosh is invoked in an interactive mode, this variable always contains ().

     STk uses this variable to pass the command line argument as well, but other Scheme implementations use different ways.  It is better to define main procedure and uses its argument to receive command line arguments, for it is expected to be more portable. Schemeスクリプト以降のコマンドライン引数のリストは、スクリプトのロードの前にこの変数に束縛されます。goshがインタラクティブモードで起動された場合はこの変数は()となります。

     この変数はSTkと互換性がありますが、他のScheme実装は違った方法を使ってコマンドライン引数を得ます。ポータブルなスクリプトを書くには、main手続きを使う方法をお薦めします。

 -- Variable: *program-name*
     This variable is bound to the script file name passed to gosh. If gosh is invoked in the interactive mode, this variable contains the pathname of gosh itself.

     STk uses the same variable to access the program/script name. Other Scheme implementations use different ways. この変数はスクリプトファイル名に束縛されます。インタラクティブモードではこの変数はgosh自身の名前を持っています。

     この変数はSTkと互換性がありますが、他の実装は違った方法を使います。

Now I show several simple examples below. First, this script works like cat(1), without any command-line option processing and error handling. いくつか簡単な例を示します。最初の例はUnixのcat(1)コマンドを模するものです。エラー処理やコマンドラインオプションの処理は行っていません。

     #!/usr/bin/env gosh

     (define (main args)   ;entry point
       (if (null? (cdr args))
           (copy-port (current-input-port) (current-output-port))
           (for-each (lambda (file)
                       (call-with-input-file file
                         (lambda (in)
                           (copy-port in (current-output-port)))))
                     (cdr args)))
       0)

The following script is a simple grep command. 次のスクリプトは簡単なgrepコマンドです。

     #!/usr/bin/env gosh

     (define (usage)
       (format (current-error-port)
               "Usage: ~a regexp file ...\n" *program-name*)
       (exit 2))

     (define (grep rx port)
       (with-input-from-port port
         (lambda ()
           (port-for-each
            (lambda (line)
              (when (rxmatch rx line)
                (format #t "~a:~a: ~a\n"
                        (port-name port)
                        (- (port-current-line port) 1)
                        line)))
            read-line))))

     (define (main args)
       (if (null? (cdr args))
           (usage)
           (let ((rx (string->regexp (cadr args))))
             (if (null? (cddr args))
                 (grep rx (current-input-port))
                 (for-each (lambda (f)
                             (call-with-input-file f
                               (lambda (p) (grep rx p))))
                           (cddr args)))))
       0)

See also Parsing command-line options, for a convenient way to parse command-line options. コマンドライン引数を処理するモジュールがあります。 Parsing command-line optionsを参照してください。

Writing Gauche modules
======================

Gauche's libraries are organized by modules.   Although Gauche can load any valid Scheme programs, there is a convention that Gauche library follows.    When you write a chunk of Scheme code for Gauche, it is convenient to make it a module, so that it can be shared and/or reused. Gaucheのライブラリはモジュール毎に整理されています。Gaucheはどんな形式でも、有効なScheme式が書かれてさえいればロードすることができますが、 Gaucheのライブラリは一定の形式を保って書かれています。 Gauche用にまとまったSchemeコードを書いたら、それをモジュール形式にしておくと再利用がしやすくなるでしょう。

Usually a module is contained in a file, but you can make a multi-file module. First I explain the structure of a single-file module. The following template is the convention used in Gauche's libraries. 通常ひとつのファイルでひとつのモジュールを定義しますが、モジュールを複数のファイルに分けることもできます。まずひとつのファイルでモジュールを定義する方法を説明します。 Gaucheのライブラリで使われているテンプレートは次のような形式です。

     ;; Define the module interface
     ;; モジュールのインタフェースの定義
     (define-module foo
       (use xxx)
       (use yyy)
       (export foo1 foo2 foo3)
       )
     ;; Enter the module
     ;; モジュール本体
     (select-module foo)

     ... module body ...

     ;; Make `require' happy
     ;; `require' に対応するprovide
     (provide "foo")

This file must be saved as ``foo.scm'' in some directory in the *load-path*. このファイルは``foo.scm''という名で、*load-path*にあるディレクトリのいずれかに置かれなければなりません。

The define-module form creates a module foo. It also loads and imports some other modules by `use' macros, and declares which symbols the foo module exports, by `export' syntax. (See section Defining and selecting modules, for detailed specification of those syntaxes). まず、define-moduleフォームがモジュールfooを作成します。 define-moduleフォーム内で、このモジュールが依存している他のモジュールを `use' マクロを使ってロードし、このモジュールがエクスポートするシンボルを `export' 構文を使って指定します。(これらの構文の詳細はDefining and selecting modulesを参照して下さい)。

Those use forms or export forms are not required to appeare in the define-module form, but it is a good convention to keep them in there at the head of the file so that it is visually recognizable which modules foo depends and which symbols it exports. これらのuseフォームやexportフォームは必ずしもdefine-module フォームの先頭に置く必要はありませんが、このようにファイルの最初の方に固めておくことで、 fooが依存しているモジュール群やfooが提供するシンボル等が一覧しやすくなります。

The second form, `select-module', specifies the rest of the file is evaluated in the module foo you just defined.   Again, this is just a convention; you can write entire module body inside define-module. However, I think it is error-prone, for the closing parenthesis can be easily forgotten or the automatic indentation mechanism of editor will be confused. 次の、`select-module' フォームにより、それ以降のScheme式がモジュールfooの中で評価されます。モジュールの内容を全てdefine-moduleの中に書いてしまうことも出来ますが、最後の括弧を閉じ忘れやすいことや、エディタのインデントが狂うことなどから、あまりお薦めしません。

After select-module you can write whatever Scheme expression. It is evaluated in the selected module, foo.   Only the bindings of the exported symbols will be directly accessible from outside. select-moduleフォームの後には、モジュールの内容であるScheme式を自由に書けます。それらはモジュールfooの中で評価されます。モジュール内で定義するトップレベルの束縛のうち、明示的に`export'で指定されたシンボルのみが、このモジュールをインポートする他のモジュールから見えます。

The last provide form is just a cliche.  It is needed since the `use' mechanism uses traditional require-provide mechanism (if you don't know about it, it's ok--just put it as a magic spell). 最後のprovideは一種の定型句です。`use'がrequire-provideメカニズムを利用しているために必要です。

So, that's it.   Other programs can use your module by just saying
`(use foo)'.   If you want to make your module available on your site,
you can put it to the site library location, which can be obtained by

     (gauche-site-library-directory)

in gosh, or

     gauche-config --sitelibdir

from shell. これで、他のプログラムは `(use foo)' とするだけでこのモジュールの機能が利用可能になります。もしモジュールをサイト全体で利用できるようにしたければ、gosh内で

     (gauche-site-library-directory)

を評価して得られるディレクトリにfoo.scmを置いて下さい。

If you feel like to conserve global module name space, you can organize modules hierarchically.   Some Gauche libraries already does so. See Library modules - Overview, for examples. For example, text.tr module is implemented in ``text/tr.scm'' file. Note that the pathname separator `/' in the file becomes a period in the module name. モジュールの名前空間のトップに新たなモジュールを追加するのに気が引ける場合は、モジュールを階層的に構成することもできます。Gaucheのモジュールの多くは既に階層的に構成されています。具体的なモジュール例はLibrary modules - Overviewを参照して下さい。例えば、text.trモジュールは ``text/tr.scm'' ファイルに実装されています。パス名の区切り文字`/'がモジュール名ではピリオドになることに注意して下さい。

Using extension packages
========================

Building and installing packages
--------------------------------

パッケージの構築とインストール
---------------

Gauche comes with some amount of libraries, but they aren't enough at all to use Gauche in the production environment. There are number of additional libraries available.   We call them extention packages, or simply packages.  Each package usually provides one or more modules that adds extra functionality.   Most of the packages provide binding to other C libraries, such as graphics libraries or database clients.   If the package has some C code, it is likely that you need to compile it on your machine with the installed Gauche system. Gauche にはまとまったライブラリが付属していますが、 Gauche をプロダクション環境で利用するのにはとても十分とはいえません。利用可能な追加ライブラリもいくつもあります。こうしたライブラリを拡張パッケージ、あるいは単にパッケージといいます。それぞれのパッケージは追加機能を提供するひとつあるいはそれ以上のモジュールを提供します。ほとんどのパッケージは別のCのライブラリへのバインディングを提供しています。たとえば、グラフィックスライブラリとかデータベースクライアントなどです。もし、パッケージがいくぶんでもCのコードを含む場合は、利用するマシン上で、既にインストールされている Gauche システムを使って、そのコードをコンパイルする必要があります。

Usually a package is in the form of compressed tarball, and the standard "ungzip + untar + configure + make + make install" sequence does the job. Read the package's document, for you may be able to tailor the library for your own needs by giving command-line options to the configure script. 通常、パッケージは圧縮 tarball の形式になっています。標準的には、「gzの解凍 + tarの展開 + configure + make + make install」とやればよいようになっています。パッケージのドキュメントを読めば、必要に応じて、 configure スクリプトに与えるコマンドラインオプションでライブラリを調整できるようになっています。

From Gauche 0.8, an utility script called gauche-package is installed for the convenience.  It automates the build and install process of packages. Gauche 0.8 より、gauche-package というユーティリティスクリプトがインストールされるようになっています。これはパッケージの構築とインストールを自動化します。

Suppose you have downloaded a package Package-1.0.tar.gz. If the package follows the convention, all you have to do is to type this: Package-1.0.tar.gz というパッケージをダウンロードしてきたとしましょう。もし、このパッケージが慣例に従っていれば、やることは

     $ gauche-package install Package-1.0.tar.gz

It ungzips and untars the package, cd into the Package-1.0 subdirectory, run configure, make, and make install. By default, gauche-package untars the tarball in the current working directory.  You can change it by a customization file; see below. とタイプするだけです。これで、gzip圧縮ファイルの解凍、tarアーカイブファイルの展開、 Package-1.0 サブディレクトリへの移動、configure スクリプトの実行、make、make install が行われます。デフォルトでは、 gauche-package はカレントディレクトリに tarball を展開します。これをカスタマイズファイル(後述)で変更することができます。

If you need a special priviledge to install the files, you can use --install-as option which runs make install part via the sudo program. ファイルをインストールするのに特別な権限が必要な場合には、 --install-as というオプションを使うと、make install 部分が、sudo を使って実行されます。

     $ gauche-package install --install-as=root Package-1.0.tar.gz

If it doesn't work for you, you can just build the package by gauche-package build Package-1.0.tar.gz, then manually cd to the Package-1.0 directory and run make install. 上手くいかない場合には、gauche-package build Package-1.0.tar.gz とやってパッケージの構築だけすることもできます。この場合、手で Package-1.0 ディレクトリに移動して、make install を実行します。

You can give configuration optoins via -C or --configure-options command-line argument, like this: 設定オプションを -C あるいは --configure-options というコマンドライン引数で与えられます。たとえば、

     $ gauche-package install -C "--prefix=/usr/local" Package-1.0.tar.gz

If the package has adopted the new package description file, it can remember the configuration options you have specified, and it will automatically reuse them when you install the package again.  (If you're a package developer, check out examples/spigot/README file in the Gauche source tree to see how to cooperate with Gauche's package management system.) もしパッケージがこの新しい記述ファイルを採用しているなら、以前に指定した設定オプションを記憶していて、そのパッケージを再度インストールするときには、自動的にそれを再利用します。 (パッケージ開発者の方は、Gauche のソースツリーにある、 examples/spigot/README ファイルをチェックアウトすれば、どのように Gauche のパッケージマネージメントシステムがやっているかを見られます。)

If you don't have a tarball in your local directory, but you know the URL where you can download it, you can directly give the URL to gauche-package.  It understands http and ftp, and uses either wget or ncftpget to download the tarball, then runs configure and make. tarball がローカルディレクトリにない場合でも、ダウンロードしてくる URL を知っているなら、その URL を直接 gauche-package に与えることができます。gauche-package は http および ftp を理解し、wget か ncftpget のどちらかを使って、その tarball をダウンロードし、configure および make を実行します。

     $ gauche-package install http://www.example.com/download/Package-1.0.tar.gz

Customizing gauche-package
--------------------------

gauche-package のカスタマイズ
----------------------

The gauche-package program reads ~/.gauche-package if it exists.  It must contain an associative list of parameters. It may look like this: gauche-package プログラムは ~/.gauche-package があれば、それを読みます。このファイルにはパラメータの連想リストが含まれていなければなりません。こんな感じです。

     (
      (build-dir . "/home/shiro/tmp")
      (gzip      . "/usr/local/bin/gzip")
      (bzip2     . "/usr/local/bin/bzip2")
      (tar       . "/usr/local/bin/gtar")
     )

The following is a list of recognized parameters. If the program isn't given in the configuration file, gauche-package searches PATH to find one. 以下は、認識されるパラメータのリストです。設定ファイルにプログラムが与えられていなければ、gauche-package は PATH を探します。

build-dir
     A directory where the tarball is extracted.  If URL is given, the downloaded file is also placed in this directory.

bzip2
     Path to the program bzip2.

cat
     Path to the program cat.

make
     Path to the program make.

ncftpget
     Path to the program ncftpget.

rm
     Path to the program rm.

sudo
     Path to the program sudo.

tar
     Path to the program tar.

wget
     Path to the program wget.

build-dir
     tarball が展開されるディレクトリ。もし、URL が与えられれば、ダウンロードされたファイルはこのディレクトリに置かれます。

bzip2
     bzip2 プログラムへのパス

cat
     cat プログラムへのパス

make
     make プログラムへのパス

ncftpget
     ncftpget プログラムへのパス

rm
     rm プログラムへのパス

sudo
     sudo プログラムへのパス

tar
     tar プログラムへのパス

wget
     wget プログラムへのパス