Backup of How to Use (No. 3)

[ Front page | List of pages | Search | Recent changes | Backup | Help ]

• List of Backups
• View the diff.
• View the diff current.
• View the source.
• Go to How to Use.
  • 1 (2006-01-08 (Sun) 07:52:55)
  • 2 (2006-01-19 (Thu) 13:59:56)
  • 3 (2006-03-24 (Fri) 14:50:48)
  • 4 (2006-06-13 (Tue) 15:59:26)
  • 5 (2006-11-30 (Thu) 17:16:12)
  • 6 (2006-12-01 (Fri) 16:29:26)
  • 7 (2006-12-18 (Mon) 16:59:22)
  • 8 (2009-12-07 (Mon) 06:53:40)
  • 9 (2009-12-07 (Mon) 10:38:20)
  • 10 (2010-02-11 (Thu) 15:45:09)
  • 11 (2010-02-11 (Thu) 15:45:09)
  • 12 (2010-05-28 (Fri) 14:05:18)
  • 13 (2011-06-12 (Sun) 03:44:34)
  • 14 (2012-05-10 (Thu) 06:30:26)
  • 15 (2014-06-01 (Sun) 14:38:04)
  • 16 (2017-03-02 (Thu) 03:32:49)
  • 17 (2017-03-02 (Thu) 05:03:59)
  • 18 (2019-04-29 (Mon) 07:59:42)
  • 19 (2019-05-26 (Sun) 13:19:39)
  • 20 (2019-05-27 (Mon) 01:33:56)

---

Documentation

System Overview

The LMNtal system first compiles LMNtal source files into intermediate code. It then translates the intermediate code into Java programs, which is in turn compiled into Java bytecode and packaged into a .jar (Java archive) file.

The LMNtal system can also execute the intermediate code interpretively (rather than translating them into Java) by giving the --interpret option.

When invoked without a source filename, the LMNtal system enters the read-eval-print loop (REPL) mode in which expressions are executed interpretively.

The system comes with a library API. In addition, you can define your own libraries to be used with your programs. See How to create libraries (below) for details about libraries.

LMNtal programs transtaled into Java bytecode run an order of magnitude faster than the interpreted intermediate code.

How to Use

(Note to Cygwin users: The command names (lmnc, lmnr, lmntal) shown below work on UNIX/Linux and Windows. On Cygwin, please use lmnc_cyg, lmnr_cyg, and lmntal_cyg instead.)

Using shellscripts (Windows 2000/XP, Cygwin and UNIX/Linux)

On Windows 2000/XP, Cygwin and UNIX/Linux, shellscripts in the bin directory facilitate compilation and execution.

Preparing libraries

(Note: Skip this step unless you have your own library.)

Prepare compiled libraries (how to make lirary .jar files will be explained below) and put them in the lib directory.

Compilation

$lmnc foo.lmn

Compiler options can be specified either before or after the filename.

$ lmnc -O2 foo.lmn
$ lmnc foo.lmn -d

Execution

$ lmnr foo.jar

Runtime options must be specified after the .jar filename.

(ok) $ lmnr foo.jar -g
(no) $ lmnr -t foo.jar

Interactive execution (Read-Eval-Print loop)

$ lmntal

• (Since lmntal is just an alias of lmnc, lmnc will work as well.)

The system enters the interactive when a filename is not specified in the command line. Enter an LMNtal expression (that can spread over multiple lines) and hit the return key twice to execute it. you can also tell the system to start execution with one newline by giving the --immediate option.

The following list shows some interactive-mode commands:

:q                - quit
:h                - see help
:trace | :notrace - set trace mode
:verbose [0-9]    - set verbosity level
:shuffle [0-3]    - set shuffle level

Here is an example of an interactive mode session:

% lmntal [PRESS ENTER]
        LMNtal version 0.70.20060105

Type :h to see help.
Type :q to quit.
Enter an empty line to run the input.

# A=f(f(f(f(f(A))))), c,c, ( c, X=f(Y) :- X=g(Y) ) [PRESS ENTER]
[PRESS ENTER]
f(g(g(f(f(_4)))),_4), @601
# A=f(f(f(f(f(A))))), c,c, ( c, X=f(Y) :- X=g(Y) ) [PRESS ENTER]
[PRESS ENTER]
g(f(f(f(g(_24)))),_24), @604
# :q [PRESS ENTER]
%

Doing manually (Windows 9x etc.)

Compilation

1. When standard or user-defined libraries are used, add their .jar files into the classpath.
2. Compile the source file:

   $ java runtime.FrontEnd foo.lmn

3. foo.jar will be created.

Execution

1. Add foo.jar into the classpath.
2. When standard or user-defined libraries are used, add their .jar files into the classpath.
3. Invoke the Main class (in foo.jar) as:

   java Main

Command-line options

There are many options for compilation and execution. Popular options include:

-t            - trace mode
-v[0-9]       - set verbosity level ( -v = -v5 )
-s[0-3]       - set shuffle level ( -s = -s3 )
-g            - graphical mode (experimental)

To see the list of all available options, do:

 lmntal --help

A Verbosity Level expresses how verbosely an LMNtal process is displayed.

  0: silence
  2: default
  3: print `proxy atoms' and contents of rulesets
  4: expand operators
  5: expand atoms
  6: expand rulesets

A shuffle Level expresses how randomly the execution goes on.

  0: (default) use an atom stack for each membrane
     (atoms are selected in a LIFO manner)
  1: atoms are selected in a system-defined order
     (which is not random or LIFO)
  2: select atoms and membranes randomly from a membrane
  3: select atoms, membranes and rules randomly from a membrane

The graphical Mode (experimental) visualizes program execution. A graphical window will be displayed that visualizes the evolution of hierarchical graph structure. Computation proceeds step by step by pressing the space bar or clicking on the 'Go ahead' button. Atoms can be dragged to arbitrary positions so that the graph may look better. To terminate the execution, close the window manually.

How to create libraries

A library is a program that is prepared (compiled) separately and added to the classpath. A library can be used also with a program running under the --interpret option.

By using shellscripts in the bin directory, you can invoke LMNtal after adding all .jar files located in the lib directory to the classpath.

You can also use the source code of the library by giving the --use-source-library option, in which case the .lmn files in the lib/src directory will be read and compiled on demand.

To create your own program library, compile the program with the --library option:

lmnc --library libhoge.lmn
java runtime.FrontEnd --library libhoge.lmn  (Windows 9x)

Then, move the .jar file to the $LMNTAL_HOME/lib directory.

Classes built by the translator

• General rules
  • One Java class will be created for each ruleset (= a set of rules located in the same 'place' of the membrane structure in the source program).
  • The class name will be Ruleset(rule_set_ID)'.
  • When the compiled program contains a module definition, a class Module_(module_name)' will be created in the translated package.
    • The class has a static method getRulesets() that returns a list of rulesets contained in that module.

• For non-libraries:
  • The ruleset classes belong to the package translated.
  • The class Main will be generated in the default package.

• For libraries:
  • The ruleset classes belong to the package translated.module_(library_name).

System rulesets

• A system ruleset is a set of global rules, namely rules applicable to every place in the membrane structure. For instance, built-in arithmetics (that evaluates x=1+2*3 to x=7, for example) is implemented as system rulesets.

• A programmer can define his/her own system ruleset by defining the system_ruleset module.

Bugs

• A large LMNtal program may create a Java class definition that is too large to be compiled by your Java compiler.

• The aggregate construct found in technical papers have not yet been implemented.

• Shuffle levels 0-2 can be specified as a runtime option, while shuffle level 3 must be specified also at compile time.

   

Modified by uedalab LMNtal group

PukiWiki 1.5.1 © 2001-2016 PukiWiki Development Team
Powered by PHP 7.4.3-4ubuntu2.20

HTML convert time to 0.015 sec.