http://people.csail.mit.edu/jaffer/Schlep/scm2cs.html
	Scm2cs
	Current Version Released Terms 1.37 Dec 25 2014 Free

Table of Contents

• Installation
• Usage
• Source Language
  • Scope of the Scheme Subset
  • Defmacro
• Delcarations
• Target Language
• Schlep API

Installation

• Obtain SCM Scheme Implementation.
• Obtain SLIB Scheme Library.
• Obtain schleprt.scm (stubs for running Schlepable code in SCM).
• Obtain SchlepRT.cs and include it (or a file with its contents) in the arguments to scm2cs (Runtime support).
• Obtain scm2cs.scm and install in a PATH directory as "scm2cs".

Usage

Usage: scm2cs [-i] file1.scm ... file2.cs ...
Usage: scm2cs [-i] file1.scm ... file2.cs ... dir/
  Translates Scheme files FILE1.scm, ... and catenates C# files
  DIR/FILE2.cs, ... to one C# file DIR/*CLASS-NAME*.cs, where
  *CLASS-NAME* is declared in "scm2cs.typ" or a declare-names form
  in a Scheme file, defaulting to "".  .SCM and .CS files can be
  mixed in any order on the command line.

Options:
 -i             ignore classname generation.

http://people.csail.mit.edu/jaffer/Schlep/scm2cs

Source Language

Scm2cs is a Scheme to C# translator for a subset of Scheme. Using Scheme files as source, scm2cs produces texinfo documentation and formatted C# code preserving comments; and type, function, and variable names as much as possible. The output from scm2cs is human-readable and can form the base for further development in C#; abandoning the original Scheme source.

Scope of the Scheme Subset

The Scheme subset supported by scm2cs is listed at
http://people.csail.mit.edu/jaffer/Schlep/#Schlep Subset.

Scheme integers and real numbers, booleans, chars, and strings are translated to the equivalent C# types. SLIB byte vectors map to the type byte[] in C# code. Vectors of user defined (C#) types are supported.

The user incorporates custom C# data types by coding their definitions and accessors in a C# source file. For the purposes of running in Scheme, put analogous definitions in a file which is not translated by scm2cs.

Characters in variable names are translated as follows:

`%'	=>	`_Percent'
`@'	=>	`_At'
`->'	=>	`To'
`='	=>	`Equal'
`>'	=>	`More'
`<'	=>	`Less'
`?'	=>	`_P'
`:'	=>	`_'
`-'	=>	`'

Scm2cs does not include support for a Scheme runtime. Generated C# programs should not assume general Scheme values unless linked with a library providing these features.

Scheme identifier names are used to determine the C# types of the corresponding variables and methods.

Defmacro

Defmacros transforming Scheme code to Scheme code may be defined in Scheme source files. If there are defmacros used in more than one Scheme source file, they can be removed to a separate file, and that file imported by a call to defmacro:load in each file (before a defmacro is invoked).

Function: defmacro:load filename

Imports defmacros from filename.

Variable: *schlep-defmacros*

Is an alist associating defmacro names with their transformers. It is fluid-let during each file translatation, so that scm2cs macro definitions do not take effect in the Scheme top level.

Delcarations

Variable: declarations

The C# types to which variables are translated are controlled by declarations. A declaration is a list (glob type). glob is a match string; type an expression. Globs are matched to variable names with trailing digits removed. Declarations made later override those made earlier.

Declarations can be made by a call to declare-names. If no declarations have been made before schlep is called, schlep will read a list of declarations from a file named `scm2cs.typ' if it exists in the same directory as the Scheme file being translated.

If the type is a symbol or string, variables which match the glob string will be declared as types of that name. If the type is a list, then it will be interpreted as follows.

(ptr type)

produces * type.

(array type)

produces type[].

Types can be nested. Procedure names ending with `!' are typed to return void. Procedure names ending with `?' are translated to names with a trailing `_P'.

Function: declare-names globs

globs must be a list of lists (declarations). Glob declarations may have local scope. Glob declarations at top level persist from one file to the next.

The Scheme files in the table at
http://people.csail.mit.edu/jaffer/CNS/benchmarks.html#PRNG
have examples of the use of declare-names.

Target Language

Function: pragma.cs string ...

In Scheme source, pragma.cs has no effect, but the strings are written to filename.cs during translation.

Variable: number-lines?

Define number-lines? to #t for C# code to be prefixed with commmented line numbers. The default value is #f.

Schlep API

The following procedures are called to translate a file. They should not be called from the file being translated.

Function: schlep filename ...

Translates scheme files to C#. Each argument must be a string. If the suffix is:

`scm'

Produces files Filename.cs and Filename.txi (Filename is capitalized).

If filename.txi is empty after translation, then it is deleted.

Procedure: declarations-report! cumulative? port

Prints an association-list (suitable passing to declare-name!) along with the counts of references to each name pattern type declared.