Chibi-scheme for Windows
========================

Chibi-scheme provides limited support for native desktop Windows. To use
fully-featured Chibi-scheme on Windows, consider using POSIX layer such as
Windows Subsytem for Linux(WSL), Cygwin or MSYS.

Currently, only R7RS Small libraries are available for the platform.

Supported Environments
----------------------

Chibi-scheme can be compiled with following platforms:

* Microsoft Visual Studio 2017
* MinGW32
* MinGW64
* MSYS


Known Issues
------------

Following libraries are not ported yet:

* `(chibi net)`
* `(chibi process)` : `exit` is available through `(scheme process-context)`
* `(chibi stty)`
* `(chibi system)`
* `(chibi time)`

Following library is not completely ported:

* `(chibi filesystem)`

Other issues:

* SRFI-27: Due to C Runtime limitation, the library is not thread-safe
* `make install` is not supported on Windows platforms
* On MSVC, flonum precision is degraded when compared with other compilers
* Cross compilation is not supported


Build with MinGW(Makefile)
--------------------------

The top-level `Makefile` can be used with MinGW.

1. Open MinGW64 or MinGW32 command prompt
2. `make`
3. `make test`

Currently, `make doc` is not supported on these platforms.


Build with MSYS(Makefile)
-------------------------

By default, the Makefile will compile against native Windows API. To use
MSYS's own POSIX emulation layer, specify `PLATFORM=msys`.

1. Open MSYS command prompt
2. `make PLATFORM=msys`
3. `make PLATFORM=msys test`


Build with Visual Studio(CMake)
-------------------------------

Minimal `CMakeLists.txt` is provided as an example to build Chibi-scheme on
Windows platforms. This is only intended to be used with Windows platforms;
currently it does not provide features provided with standard `Makefile` nor
it does not support UNIX/APPLE platforms either.

1. (Make sure CMake was selected with Visual Studio installer)
2. Open this directory with "Open with Visual Studio"
3. Choose "x86-" or "x64-" configuration
4. "CMake" => "Build all"
5. "CMake" => "Tests" => "Run chibi-scheme Tests"

Using the Makefile.libs File To Build and Install Libraries
-----------------------------------------------------------

The Makefile.libs file distributed with the Chibi Scheme sources
can facilitate building and installing Chibi Scheme libraries written
in C or Scheme. To use it, follow these instructions:

1. Copy the Makefile.libs and Makefile.detect files from the Chibi
   Scheme source directory to the library source top-level directory.

2. Place the library source in the subdirectory "lib" of the library
   source top-level directory. For example,

      lib/foo/bar.c
      lib/foo/bar.h
      lib/foo/bar.sld
      lib/foo/bar.scm

3. In the Makefile in the library source top-level directory, define
   the following targets:

      all
      doc
      install
      uninstall
      clean
      dist-clean

   These should depend on the corresponding "-libs" target, but
   can include additional commands. For example:

      all: all-libs
      install: install-libs
              cp -r doc $(PREFIX)/share/chibi/
      uninstall: uninstall-libs
      doc: doc-libs
      clean: clean-libs
      dist-clean: dist-clean-libs

   The all target should be the first target in the Makefile.

   The all-libs target makes the shared libraries in the library.
   The doc-libs target generates HTML files for the library. The
   install-libs and uninstall-libs targets install and uninstall
   the library under the prefix. The clean-libs target removes the
   shared libraries and generated HTML files. The dist-clean-libs
   removes any .c files generated from .stub files and also performs
   a clean-libs.

4. In the Makefile in the library source top-level directory, define
   the following variables:

      COMPILED_LIBS: Any shared libraries that should be built and
      installed. The shared library is build from the corresponding
      .c or .stub file. The $(SO) variable should be used for the
      shared-library suffix; in order for this to work COMPILED_LIBS
      should be defined as a recursively-expanded variable (with
      =) rather than a simply-expanded variable (with :=).

      INCLUDES: Any other files on which the shared libraries depend.

      SCM_LIBS: Any Scheme source files that should be installed.

      HTML_LIBS: Any HTML files that should be generated. The HTML
      files are generated from the corresponding .sld files using
      chibi-doc.

   For example,

      COMPILED_LIBS = lib/foo/bar$(SO)
      INCLUDES = lib/foo/bar.h
      SCM_LIBS = lib/foo/bar.sld lib/foo/bar.scm
      HTML_LIBS = doc/lib/foo/bar.html

5. Add additional flags as necessary to XCPPFLAGS, XCFLAGS, and XLIBS.
   These flags are passed to the compiler and linker when they
   generate the shared library. These should probably be defined at
   minimum as:

      XCPPFLAGS += -I$(PREFIX)/include
      XCFLAGS += -L$(PREFIX)/lib
      XLIBS +=

   These additions will ensure that the compiler and linker can
   find the Chibi Scheme include and library files, even if they
   are installed under a non-standard prefix.

6. Include the common Makefile using:

   include Makefile.libs

A complete example is:

   all: all-libs
   install: install-libs
   uninstall: uninstall-libs
   doc: doc-libs
   clean: clean-libs
   dist-clean: dist-clean-libs

   COMPILED_LIBS = lib/foo/bar$(SO)
   INCLUDES = lib/foo/bar.h
   SCM_LIBS = lib/foo/bar.sld lib/foo/bar.scm
   HTML_LIBS = doc/lib/foo/bar.html

   XCPPFLAGS += -I$(PREFIX)/include
   XCFLAGS += -L$(PREFIX)/lib
   XLIBS += -lpthread

   include Makefile.libs

# ![Chibi-Scheme](https://goo.gl/ZDtn4q)

**Minimal Scheme Implementation for use as an Extension Language**

http://synthcode.com/wiki/chibi-scheme

Chibi-Scheme is a very small library intended for use as an extension
and scripting language in C programs.  In addition to support for
lightweight VM-based threads, each VM itself runs in an isolated heap
allowing multiple VMs to run simultaneously in different OS threads.

There are no external dependencies so is relatively easy to drop into
any project.

Despite the small size, Chibi-Scheme attempts to do The Right Thing.
The default settings include:

* a full numeric tower, with rational and complex numbers
* full and seamless Unicode support
* low-level and high-level hygienic macros
* an extensible module system

Specifically, the default repl language contains all bindings from
[R7RS small](https://small.r7rs.org/), available explicitly as the
`(scheme small)` library.  The language is built in layers, however -
see the manual for instructions on compiling with fewer features or
requesting a smaller language on startup.

Chibi-Scheme is known to work on **32** and **64-bit** Linux, FreeBSD,
NetBSD, OpenBSD and OS X, Plan 9, Windows, iOS, Android,
ARM and [Emscripten](https://kripken.github.io/emscripten-site).  Basic
support for native Windows desktop also exists. See README-win32.md
for details and build instructions.

To build on most platforms just run `make && make test`.  This has a
few conditionals assuming GNU make.  If using another make, there are
a few parameters in Makefile.detect you need to set by hand.

This will provide a shared library *libchibi-scheme*, as well as a
sample *chibi-scheme* command-line repl.  You can then run

    sudo make install

to install the binaries and libraries.  You can optionally specify a
**PREFIX** for the installation directory:

    make PREFIX=/path/to/install/
    sudo make PREFIX=/path/to/install/ install

By default files are installed in **/usr/local**.

If you want to try out chibi-scheme without installing, be sure to set
`LD_LIBRARY_PATH` so it can find the shared libraries.

To make the emscripten build run `make js`.

For more detailed documentation, run `make doc` and see the generated
*doc/chibi.html*.