EuLisp

Youtoo is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See the file COPYING in this directory, for a description of the GNU General Public License terms under which you can copy the files.

This version of the EuLisp definition and Youtoo implementation are being developed in an attempt to reconcile the differences with the ultimate aim to create a consistent definition and implementation which is as close to EuLisp-1.0 as is possible to ascertain from the remaining documents related to the standardisation process:

• Youtoo original sources
  This release of Youtoo started life as Youtoo-0.93 developed by Andreas Kind, Julian Padget and others. More details are available from the original README file and the youtoo home page. The b2h and i2doc tools needed to bootstrap youtoo were reverse engineered and provided by T. Kurt Bond.
• EuLisp definition original sources
  The version of the EuLisp definition supplied is this release of Youtoo started life as EuLisp-0.99 from the pack released by Julian Padget: 931202.tar.gz updated following proposals and discussions also released by Julian Padget:
  • Online definition
  • nov93.gz
  • dec93.gz
  • adv-genarith.ps.gz
  • eulisp-ffi.ps.gz
  • eulisp-proposals.ps.gz
  • genarith.ps.gz
  • map.ps.gz
  • stream.ps.gz

The youtoo system is a public domain implementation of the object-oriented dynamic programming language EuLisp. EuLisp is a single-valued dialect of Lisp with an integrated object system, a defined meta-object protocol, modules and a simple light-weight process mechanism (threads).

The youtoo compiler/interpreter compiles EuLisp into C-embedded virtual machine code which can be statically or dynamically linked with the virtual machine, the conservative garbage collector, the EuLisp language library and arbitrary other Lisp and foreign code (C, C++ and Fortran). Resulting stand-alone executables are portable, interoperable and efficient (see The Lisp Performance Page). The language implementation is extended towards a Virtual Multicomputer Architecture. Object serialization and inter-process communication (Sockets, MPI, Harvest Object Cache) support the migration of arbitray data and code.

The system reuses ideas from the Oaklisp system written by Barak Perlmutter and Kevin Lang. The meta-object protocol (Telos) was originally implemented in Common Lisp by Russell Bradford. By default, a garbage collector written by Hans Boehm and Alan Demers is used.

• Unpack version X with
  tar -xzf youtooX.tar.gz
• Run
  ./configure
  and check the settings. Edit the configure file to reflect your system if necessary and re-run
  ./configure.
• Run
  make
  If you want to use shared libraries (which we really recommend Linux, FreeBSD, Solaris and IRIX), run
  make shared
  and add the directory …/youtoo/Lib.${ARCH} to the environment variable $LD_LIBRARY_PATH (see ./makeso.Path).
• You should now be able to run the script
  Bin.${ARCH}/youtoo.sh
  (see next section).

• Run
  Bin.${ARCH}/youtoo.sh -help
  to see the compiler options.
• Run
  Bin.${ARCH}/youtoo.sh fact -l level1
  to compile module fact in (built-in) load directory Misc into a stand-alone executable. With shared libraries the executable should be less the 40K.
• Run
  Bin.${ARCH}/youtoo.sh
  without options to start the EuLisp interpreter. The read-eval-print loop provides extra commands (type help:).

• ~/.eulrc.${ARCH}
  For private customisation, put a copy of .eulrc.${ARCH} in your home directory. For example, remove the optimisation flag of the C compiler.
• EuLisp Module Files
  Have the extension .em.
  • EuLisp Language Level1
    Level1 is provided by the library liblevel1.a. Standard macros are defined in the syntax module macros. Thus, the default module body looks like this: #+BEGIN_SRC lisp (defmodule foo (syntax (macros) import (level1))

    …

    ) ;; end of module #+END_SRC

• Pretty Printing
  The function pprint provides generic pretty printing.
• Main
  There is no main entry function Top-level forms in modules are executed with with respect to the module hierarchy. Global variables *argc* and *argv* are provided.
• Standard Bindings
  See Doc/bindings.txt for a list of standard bindings.
• Module Compilation
  The compiler checks before compiling a module which (directly and indirectly) imported modules really need to be (re)compiled. This feature can be switched off with -no_recompile.
• Standard C foreign-functions
  in Vm/eulisp.h
  • Data conversion from EuLisp to C:
    #+BEGIN_SRC c int eul_int_as_c_int(LispRef x); int eul_bool_as_c_bool(LispRef x); double eul_double_as_c_double(LispRef x); LispRef eul_int_as_dbl(LispRef x); char eul_char_as_c_char(LispRef x); char *eul_string_as_c_string(LispRef x); char *eul_symbol_as_c_string(LispRef x); #+END_SRC
  • Data conversion from C to EuLisp:
    #+BEGIN_SRC c LispRef c_int_as_eul_int(int x); LispRef c_bool_as_eul_bool(bool x) LispRef c_char_as_eul_char(char x); #+END_SRC
  • Creating symbols and keywords:
    #+BEGIN_SRC c eul_intern_symbol(LispRef loc, char *str); eul_intern_keyword(LispRef loc, char *str); #+END_SRC
  • EuLisp data allocation:
    #+BEGIN_SRC c eul_allocate_int(LispRef loc, int x); eul_allocate_double(LispRef loc, double x); eul_allocate_char(LispRef loc, char x); eul_allocate_string(LispRef loc, char *str); eul_allocate_cons(LispRef loc, LispRef x, LispRef y); eul_allocate_vector(LispRef loc,int n, LispRef init); eul_allocate_object(LispRef loc, LispRef class, LispRef n, LispRef init); #+END_SRC
  • EuLisp constants:
    #+BEGIN_SRC c LispRef eul_nil; LispRef eul_t; #+END_SRC
  • EuLisp data access:
    #+BEGIN_SRC c LispRef eul_car(LispRef x); LispRef eul_cdr(LispRef x); LispRef eul_slot_ref(LispRef x, int i); LispRef eul_symbol_name(LispRef x); LispRef eul_keyword_name(LispRef x); LispRef eul_class_of(LispRef x); LispRef eul_size_of(LispRef x); LispRef eul_string_size(LispRef x); #+END_SRC
  • EuLisp data predicates:
    #+BEGIN_SRC c int eul_null(LispRef x); int eul_is_symbol(LispRef x); int eul_is_keyword(LispRef x); int eul_is_int(LispRef x); int eul_is_double(LispRef x); int eul_is_char(LispRef x); int eul_is_string(LispRef x); int eul_is_cons(LispRef x); int eul_is_list(LispRef x); int eul_is_gf(LispRef x); int eul_is_lambda(LispRef x); int eul_is_operator(LispRef x); #+END_SRC
• Using the foreign-function interface
  Uses automatic converters. Here is an example how atoi can be used from Lisp: #+BEGIN_SRC lisp (defextern atoi () ) #+END_SRC If the desired external function foo is in library libbar.a and should be called baz in Lisp the following defining form is necessary: #+BEGIN_SRC lisp (defextern baz (…) … "foo") #+END_SRC To link the library libbar.a, put a copy of .eulrc.${ARCH} in your home directory and add -lbar to the list of $CLIBS; the library path must be given with -L<bar-path> in the list of $CFLAGS.
  • Automatic type conversion
    The following automatic converters are available:

    Lisp	C (C99)
    <int>	int
    <character>	char
    <double>	double
    <string>	char*
    boolean	bool
    ptr	void*
    <int*>	int*
    <double*>	double*
    <string*>	char**

    The ptr converter can be used to pass arbitrary C99 structures to Lisp, so that they can be passed back to C at a later stage. The ptr converter is also useful to pass a Lisp object unconverted to C99.

  • defextern
defextern definitions can not be linked dynamically.
  • DEFINTERN
    Foreign in-calls have to use the DEFINTERN() macro. Examples for in/out-calls to/from Lisp can be found in the directories Examples/Misc, Examples/Fortran, and Examples/C++.
• Macro expansion
  is un-hygienic.
• EuLisp Scripts
  Use #!../youtoo -script/ to write EuLisp scripts (see Examples/Misc/script.em).
• Inter-operation with other languages
  The examples in directory C++ and Fortran show how to interoperate with these languages.
• List operators
  Arithmetic functions +, - and / operate as set union, difference and intersection on lists.
• Examples
  Directory Examples contains modules for explanation and reuse.

• GNU Bignum: Extras/Bignum
  Danius Michaelides wrote a port to the GNU bignum library (gmp).
• MPI: Extras/MPI
  
• Tcl/Tk: Extras/TclTk
  
• Foreign thread libraries: Extras/Fthread
  
• Scheme: Extras/Scheme
  Modules ./Extras/Scheme/scheme0.em and ./Extras/Scheme/scheme.em provide support for writing Scheme programs with youtoo.
• Matching: Extras/Match
  Modulized version of match-slib.scm badly hacked for EuLisp.
• Object serialisation: Extras/OS
  Julian Padget\ includes support for closures and threads.
• OPS5 rule-based system : Extras/OPS5
  An object-oriented version of the OPS5 rule-based system.
• Pipes and forked child processes: Extras/Pipe
  Thanks to Rob Simmons there is support for pipes to forked child processes.

• EuLisp definition
  is provided in both HTML and PDF formats:
  • EuLisp Definition Version 0.991 (HTML)
  • EuLisp Definition Version 0.991 (HTML single page)
  • EuLisp Definition Version 0.991 (PDF)
• EuLisp-1.0 Proposals
  are in the folowing proposal document and discussed in the minutes of the meeting on 19/11/93 and in the preceding and subsequent Email correspondence. The following reports are discussed in the above:
  • eulisp-proposals.ps
  • genarith.ps
  • adv-genarith.ps
  • eulisp-ffi.ps
• Bindings
  The current set of supported bindings in Youtoo are in the file bindings.txt

• Support for 64bit Operation
  The main change to support 64bit pointers is that on such architectures the Instruction is a 16bit integer rather than an 8bit char so that 4 Instructions still fit exactly in a pointer. This allows most of the stack pointer incrementing to remain unchanged. However, a very large number of small changes were also necessary. The C-files are compatible between the 32bit and 64bit versions.
• C99 Compliance
  The code is now C99 compliant and uses C99 data types and constructs so a C99 compiler is required e.g. gcc-4.?.?.
• Rationalisation of the Makefiles
  The Makefiles have been rationalised and simplified by using many features in the GNU version of make, gmake which is now required to build youtoo.
• The start of the EuLisp-1.0 compliance process
  Many small changes to improve consistency between the Youtoo implementation and the EuLisp-0.99 definition and the documents relating to the creation of EuLisp-1.0.