Easy-ISLisp(EISL) is an interpreter and compiler compatible with the ISLisp standard. EISL was written by Kenichi Sasagawa

See ISLisp YouTube introduction of Easy-ISLisp

Change to the git cloned or downloaded Easy-ISLisp directory.

• Type "sudo make install".
• You can also supply a "PREFIX=$HOME" (or wherever) argument if you want.
• For more advanced hacking on the interpreter itself, you can build a debug-mode executable by supplying a "DEBUG=1" argument to make, but this is unlikely to be needed by someone starting out.

Update Easy-ISlisp

• Type "sudo make clean".
• Type "sudo make install".

You may get an error that the curses.h file cannot be found when compiling EISL & Edlis. In this case, enter the following from the terminal

sudo apt install libncurses-dev

Otherwise, support for curses can be disable with WITHOUT_CURSES=1 in the make command. However, this will limit REPL support and will disable edlis.

After version 1.4 Windows OS is not supported. Please use WSL on Windows. see Visual Studio Code Remote Development Extension Pack

We confirmed operation in the following environments.

• Ubuntu 16.04 GCC 5.4
• Ubuntu 18.04 GCC 7.3
• Raspberry Pi3 Raspbian GCC 6.3
• Raspberry Pi3 Raspbian GCC 8.3.0
• Paspberry Pi400
• openSUSE Leap 42.3 GCC 4.8.5
• Debian GNU/Linux GCC 6.3 GCC 7.3
• Linux Mint GCC ver 5.4
• Linux Mint GCC ver9.3.0
• macOS 11.1 clang 12.0.0
• OpenBSD

If you use Clang on MacOS, provide option to Clang compatible with GCC.

If you want to use library files from anyplace other than the PREFIX argument (default /usr/local), you should set the EASY_ISLISP enviroment variable to point to it.

ISLisp-mode of Emacs is developed by Mr. sasanidas. Watch the video to see how to use it. https://vimeo.com/614514131

Repository URL: https://gitlab.com/sasanidas/islisp-mode

eisl 

In the Linux version,the REPL is editable. If you do not want to use the editable REPL, invoke with the -r option.

eisl -r

If you want to start after reading a file, use the -l command-line option. e.g.

eisl -l foo.lsp 

For other options, see eisl -h:

$ eisl -h
List of options:
-c           -- EISL starts after reading compiler.lsp.
-f           -- EISL starts after reading formatter.lsp.
-h           -- display help.
-l filename  -- EISL starts after reading the file.
-r           -- EISL does not use editable REPL.
-s filename  -- EISL runs the file with script mode.
-v           -- dislplay version number.

You can also write ISLisp scripts, following the usual UNIX convention of pointing to the interpreter with the first line, e.g.

#!/Users/me/bin/eisl -s
(format (standard-output) "Hello world~%")

In the REPL type (quit) or Esc+Q.

In the non-editable REPL type (quit) or CTRL+D.

Mr. Hiroi has published introductory articles about ISLisp. It's written in plain Japanese, so you can easily translate it into your native language with google translator. http://www.nct9.ne.jp/m_hiroi/clisp/islisp.html

When entering a line in the REPL, syntax highlighting, completion, and text editing are available. Key bindings are as follows:

I hope that Lisp will become more popular. I hope many people enjoy it. EISL aims to be user-friendly.

EISL has a compiler. It generates C code that can be compiled using gcc or clang to object code.

Invoke with the -c option, eisl -c or (import "compiler") in the REPL. Then you can

(compile-file "foo.lsp")
(load "foo.o")

For example:

eisl -c
Easy-ISLisp Ver1.6
> (compile-file "tests/tarai.lsp")
type inference
initialize
pass1
pass2
compiling PACK
compiling TARAI
compiling FIB
compiling FIB*
compiling ACK
compiling GFIB
compiling TAK
compiling LISTN
compiling TAKL
compiling CTAK
compiling CTAK-AUX

finalize
invoke GCC
T
> (load "tests/tarai.o")
T
> (time (tarai 12 6 0))
Elapsed Time(second)=0.024106
<undef>
> (time (ack 4 1))
Elapsed Time(second)=3.728262
<undef>
>

By default the edit function invokes the Edlis editor. But note that it respects the UNIX convention of the VISUAL and EDITOR environment variables, so if either of those is defined it will be used instead.

(edit file-name-string) example (edit "foo.lsp")

On paspberry PI, Eisl includes system function of WiringPi.

EISL <==================================> C
(wiringpi-spi-setup ch speed) <===> wiringPiSPISetup (SPI_CH, SPI_SPEED)
(wiringpi-setup-gpio ) <===> wiringPiSetupGpio()
(pin-mode n 'output) <====> pinMode(n, OUTPUT) or 'input -> INPUT 'pwm-output -> PWM-OUTPUT
(digital-write n v) <===> digitalWrite(n, v)
(digital-write-byte v) <===> digitalWriteByte(value)
(digital-read pin) <===> digitalRead(pin)
(delay-seconds howlong) <===> void delay(unsigned int howLong)
(delay-microseconds howlong) <===> void delayMicroseconds(unsigned int howLong)
(pull-up-dn-control pin pud) <===> pullUpDnControl(pin,pud)
(pwm-set-mode 'pwm-mode-ms) <===> pwmSetMode(PWM_MODE_MS); or 'pwm-mode-bal -> PWM_MODE_BAL
(pwm-set-clock n) <===> pwmSetClock(n)
(pwm-set-range n) <===> pwmSetRange(n)
(pwm-write pin value) <===> pwmWrite(pin , value)

;;LED on/off

(defglobal pin 5)
(defglobal flag nil)

(defun test (n)
   (cond ((null flag) (wiringpi-setup-gpio)(setq flag t)))
   (pin-mode pin 'output)
   (for ((i 0 (+ i 1)))
        ((> i n) t)
        (digital-write pin 1)
        (delay-seconds 1)
        (digital-write pin 0)
        (delay-seconds 1)))


;;control servo moter.
;;SG90 Micro servo Digital 9g

(defun setup ()
  (cond ((null flag) (wiringpi-setup-gpio ) (setq flag t)))
  (pin-mode 18 'pwm-output)
  (pwm-set-mode 'pwm-mode-ms)
  (pwm-set-clock 400)
  (pwm-set-range 1024))

(defun test (n)
   (pwm-write 18 n))

• (trace fn1 fn2 ... fn)
• (untrace fn1 fn2 ... fn) or (untrace)
• (backtrace)
• (break)
• (macroexpand-1)