
README

1 Overview of the LINGUIST system

1.1 What is LINGUIST?

     LINGUIST is an interactive Japanese language analysis system on
CESP(*1) which is available under Unix(*2).  The LINGUIST
computational tool was designed to assist the development of grammar
rules written in DCG.  LINGUIST can be used to develop grammar rules
written in DCG and to modify them for use in many sort of application
systems.  Grammar rules can be used and modified in existing grammar
for Japanese provided from ICOT's 6th Research Laboratory.

     LINGUIST is interactive; you can instantly see the results of
analysis on the grammar rules or dictionaries on which you made
changes.  LINGUIST offers many features to make analysis experiments
easy and comprehensive.  These features include the following:

    * Minimum key entries. LINGUIST is designed to allow most
      operations to be performed with a mouse.
    * Multiple windows. Provides high visibility flow of executions to
      be viewed by locating all necessary functions in one window.
    * Powerful utilities. A visual debugger traces grammar rules.
    * Supplied linguistic knowledge source. Basic grammars that
      contain grammar rules for Japanese sentence analysis and
      dictionaries.

     LINGUIST was originally designed for use on PSI machines.  Now
the software is available on Sun workstations under Unix using CESP.
This document is aimed of the needs of Sun workstation users.

     *1 : CESP is a object-oriented language with Prolog facility.
     *2 : Unix is a trademark of Bell Laboratory.

1.2 How To Access LINGUIST

     You gain can access to LINGUIST by the following procedure.

    1. Invoke CESP by typing ``run-CESP'' at the EMACS level, after
       the CTRL-X command.  The command is displayed in the command
       window of EMACS, which is located at the bottom of the EMACS
       screen display.
       For example:

            ``M-x run-CESP''

    2. CESP interpreter is invoked. The CESP system will display the
       prompt as follows:

            ``CESP>''

    3. Start the librarian by entering ``librarian'' at CESP prompt.

            ``CESP> librarian''

    4. In response to the ``librarian'' command, CESP changes the
       prompt as follows:

            ``LIB>''

    5. Read in the LINGUIST program using the predicate ``catalogue'',
       followed by the file names inside brackets:

            ``LIB> catalogue(`~/linguist/*.esp')

    6. After cataloging, type the command ``debugger'' to start the
       debugger.  CESP responds by displaying the system prompt.

            ``LIB> debugger''
            ``DEB>''

    7. To invoke LINGUIST, use the predicate :go(#linguist):

            ``DEB> :go(#linguist).

1.2.1 System Initialization

        When the predicate :go(#linguist) is issued in a debugger
session, a LINGUIST window with a transparent frame will appear.  You
may notice that the response time for the frame to appear the first
time is different for later.  The first time takes a few minutes,
whereas latter often its take a few seconds.  This is because the
system must initially load the entire LINGUIST template files prior to
appearance.

        Once this has been done, the LINGUIST frame window is shown
immediately after the menu selection.

        LINGUIST initializes the system.  While the system is
initializing, the switch windows, which correspond to the processes
and are discussed later, will alternate with each another.  System
initialization is complete when all switch windows have alternated.
Figure 1.1 identifies the LINGUIST window display.


    +---- The interactive process window
    V
+---------------------------------------------------------------+
|                                                               |
|                          LINGUIST                             |
|                                                               |
|   Logic-Based Integrated Natural Language Processing System   |
|                                                               |
|                                                               |
|                      Version 1.1                              |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
|                                                               |
+-----------------------------+-----------+----------+----------+
|Systems Reports              | Generator | Accessor | Debugger |
|  +---------------------+    |           |          |          |
|  |                     |    +-----------+----------+----------+
|  +---------------------+    |   Help    |         EXIT        |
+-----------------------------+-----------+---------------------+
     ^                                 ^
     + The message output window       + The switch window


                    Figure 1.1 Window Components

1.3 How To Terminate LINGUIST

        This section describes how to terminate LINGUIST.  You may
leave LINGUIST during any process stage.  The termination procedure is
as follows:

    1. Select ``EXIT'' from the LINGUIST switch window.
    2. If you select ``EXIT'' and click a mouse button, LINGUIST
       displays the following notice in the confirmation window.

            ``EXIT  LINGUIST?''

    3. Select ``Yes'' from the confirmation window.  If you respond
       with ``No'', the confirmation window disappears immediately.
       This allows you to continue to operate the LINGUIST system.

     The LINGUIST system window is now deactivated and terminated.  If
you want to terminate the CESP session, do the following:

    1. Type ``exit'' at the debugger level to return to the command
       level.  In response to the ``exit'' command, the CESP will
       change the system prompt:

            ``DEB> exit''
            ``CESP>''

    2. Enter ``exit'' at the system prompt.

            ``CESP> exit''

    3. This allows you to exit CESP and return to EMACS.

     CESP will be terminated and the *scratch* buffer window will
appear.

1.4 Window Components

     The basic window components of the LINGUIST system are as
follows: the interactive process window, the message window and the
switch window, as illustrated in Figure 1.1.

     The main window, which is assigned to the current process,
displays the opening messages at the beginning of the LINGUIST
session.  System messages, which may include include error messages,
appear on the message output window.  LINGUIST provides three kinds of
processes developing grammar rules.  Each process is assigned to a
separate window.  These windows, however, share the same location.
You can access the process window you wish to work with through the
switch menu on the switch window.  The switch window always displays
the process name currently worked on.

1.4.1 Processes

     LINGUIST has the following interactive process windows.

    [1] ``Generator''   performs environmental definitions.
    [2] ``Accessor''    performs text analysis experiments.
    [3] ``Debugger''    debugs grammar rules and dictionaries.

     Each of windows is assinged to a process.  The functions of the
processes are discussed in the next section.

1.4.2 System Messages

     Each interactive process window provides several messages during
execution.  There are two types: LINGUIST system messages and CESP
error messages.  The former informs you of the process states, for
instance, ``Translation started' and ``Translation ended''.  The
latter informs you of operational errors.

% End of File
