Package | Description |
---|---|
sisc |
SISC: The Second Interpreter of Scheme Code
|
sisc.compiler | |
sisc.data | |
sisc.env | |
sisc.exprs | |
sisc.exprs.fp | |
sisc.interpreter | |
sisc.io.custom | |
sisc.modules | |
sisc.modules.hashtable | |
sisc.modules.io | |
sisc.modules.record | |
sisc.modules.s2j | |
sisc.nativefun | |
sisc.ser | |
sisc.util |
Modifier and Type | Class and Description |
---|---|
static class |
REPL.SchemeSocketThread |
Modifier and Type | Class and Description |
---|---|
class |
Syntax |
Modifier and Type | Method and Description |
---|---|
static Expression |
Compiler.application(Interpreter r,
Expression rator,
Expression[] rands,
int context,
Pair annotation,
SymbolicEnvironment env) |
protected Expression |
Compiler.compile(Interpreter r,
Expression v,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
int context,
SymbolicEnvironment env,
Pair an) |
Expression |
Compiler.compile(Interpreter r,
Expression v,
SymbolicEnvironment env) |
Expression |
Compiler.compileApp(Interpreter r,
Pair expr,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
int context,
SymbolicEnvironment env,
Pair an) |
Expression |
Compiler.compileLetrec(Interpreter r,
Symbol[] formals,
Symbol[] lexicals,
Expression[] rands,
Expression body,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
SymbolicEnvironment env,
int context) |
static Expression |
Compiler.makeFillRib(Interpreter r,
Expression lastRand,
Expression rand,
int pos,
Expression nxp,
boolean immediate) |
Modifier and Type | Method and Description |
---|---|
static Expression |
Compiler.application(Interpreter r,
Expression rator,
Expression[] rands,
int context,
Pair annotation,
SymbolicEnvironment env) |
static Expression |
Compiler.application(Interpreter r,
Expression rator,
Expression[] rands,
int context,
Pair annotation,
SymbolicEnvironment env) |
protected Expression |
Compiler.compile(Interpreter r,
Expression v,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
int context,
SymbolicEnvironment env,
Pair an) |
Expression |
Compiler.compile(Interpreter r,
Expression v,
SymbolicEnvironment env) |
Expression |
Compiler.compileLetrec(Interpreter r,
Symbol[] formals,
Symbol[] lexicals,
Expression[] rands,
Expression body,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
SymbolicEnvironment env,
int context) |
Expression |
Compiler.compileLetrec(Interpreter r,
Symbol[] formals,
Symbol[] lexicals,
Expression[] rands,
Expression body,
Pair sets,
sisc.compiler.Compiler.ReferenceFactory rf,
SymbolicEnvironment env,
int context) |
static Expression |
Compiler.makeFillRib(Interpreter r,
Expression lastRand,
Expression rand,
int pos,
Expression nxp,
boolean immediate) |
Modifier and Type | Class and Description |
---|---|
class |
Box |
class |
Closure |
class |
EmptyList |
class |
EOFObject |
class |
ExpressionValue |
class |
ImmutablePair |
class |
ImmutableString |
class |
ImmutableVector |
class |
MemoizedSymbol |
class |
Nothing
A value, unlike "void", which is not equal to anything
|
class |
Pair |
class |
Procedure
The Procedure class is the base class for any Scheme Procedure.
|
class |
Quantity |
class |
SchemeBinaryInputPort
A Scheme binary input port.
|
class |
SchemeBinaryOutputPort
A Scheme binary output port.
|
class |
SchemeBoolean |
class |
SchemeCharacter |
class |
SchemeCharacterInputPort
A Scheme character output port.
|
class |
SchemeCharacterOutputPort
A Scheme character output port.
|
class |
SchemeString |
class |
SchemeThread |
class |
SchemeVector |
class |
SchemeVoid |
class |
Symbol |
class |
Value
Value is the base class for anything treated as a first-class value
within Scheme.
|
class |
Values |
Modifier and Type | Field and Description |
---|---|
Expression |
Closure.body |
Expression |
ExpressionValue.e |
Constructor and Description |
---|
Closure(boolean arity,
int fcount,
Expression body,
Value[] env,
int[] boxes) |
ExpressionValue(Expression e) |
Modifier and Type | Class and Description |
---|---|
class |
ConfigParameter |
class |
DelegatingSymEnv |
class |
LexicalEnvironment |
class |
MemorySymEnv |
class |
NativeParameter |
class |
Parameter |
class |
SchemeParameter |
Modifier and Type | Class and Description |
---|---|
class |
AnnotatedExpr |
class |
AppEval |
class |
AppExp |
class |
ApplyValuesContEval |
class |
DefineEval |
class |
EvalExp |
class |
FillRibExp |
class |
FreeReferenceExp |
class |
FreeSetEval |
class |
IfEval |
class |
LambdaExp |
class |
LetrecEval |
class |
LetrecExp |
class |
LexicalReferenceExp |
class |
LocalReferenceExp |
class |
SetboxEval |
class |
UnboxExp |
Modifier and Type | Field and Description |
---|---|
Expression |
IfEval.altern |
Expression |
LetrecEval.body |
Expression |
LambdaExp.body |
Expression |
IfEval.conseq |
Expression |
FillRibExp.exp |
Expression |
AppExp.exp |
Expression |
AnnotatedExpr.expr |
Expression |
FillRibExp.nxp |
Expression |
AppExp.nxp |
Expression |
EvalExp.post |
Expression |
EvalExp.pre |
Expression[] |
AppExp.rands |
Modifier and Type | Method and Description |
---|---|
void |
FillRibExp.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
AnnotatedExpr.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
LetrecEval.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
EvalExp.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
IfEval.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
AppExp.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
Constructor and Description |
---|
AnnotatedExpr(Expression expr,
Value annotation) |
AppExp(Expression exp,
Expression[] rands,
Expression nxp,
boolean allImmediate) |
AppExp(Expression exp,
Expression[] rands,
Expression nxp,
boolean allImmediate) |
EvalExp(Expression pre,
Expression post,
boolean preImmediate) |
FillRibExp(Expression exp,
int pos,
Expression nxp,
boolean lari) |
IfEval(Expression conseq,
Expression altern) |
LambdaExp(int s,
Expression body,
boolean arity,
int[] localids,
int[] lexids,
int[] boxes) |
LetrecEval(Expression body) |
LetrecExp(Expression exp,
Expression[] rands,
Expression nxp,
int[] localIndices,
int[] lexicalIndices,
boolean allImmediate) |
LetrecExp(Expression exp,
Expression[] rands,
Expression nxp,
int[] localIndices,
int[] lexicalIndices,
boolean allImmediate) |
Modifier and Type | Class and Description |
---|---|
class |
FixedAppExp_0 |
class |
FixedAppExp_1 |
class |
FixedAppExp_2 |
class |
FixedAppExp_3 |
Modifier and Type | Method and Description |
---|---|
Expression[] |
FixedAppExp_1.getOperands() |
Expression[] |
FixedAppExp_0.getOperands() |
Expression[] |
FixedAppExp_2.getOperands() |
Expression[] |
FixedAppExp_3.getOperands() |
Modifier and Type | Method and Description |
---|---|
void |
FixedAppExp_1.alter(Interpreter r,
int uexpPosition,
Expression replaceWith) |
void |
OptimisticHost.alter(Interpreter r,
int uexpPosition,
Expression replaceWith)
Instructs the host to replace the uExp referenced at the
given (Expression dependent) position, with the given
Expression.
|
static void |
Utils.assertNonOptimistic(Expression exp) |
static void |
Utils.linkOptimistic(OptimisticHost host,
Expression exp,
int uexpPos) |
void |
FixedAppExp_0.revert(Interpreter r,
Expression[] rands) |
void |
FixedAppExp_0.revert(Interpreter r,
Expression[] rands,
int flags) |
Modifier and Type | Class and Description |
---|---|
class |
ApplyParentFrame |
class |
CallFrame |
static class |
Interpreter.ThrowSchemeException |
Modifier and Type | Field and Description |
---|---|
Expression |
Interpreter.nxp |
Expression |
CallFrame.nxp |
Modifier and Type | Method and Description |
---|---|
Expression |
Interpreter.compile(Value v) |
Expression |
Interpreter.compile(Value v,
SymbolicEnvironment env) |
Expression |
AppContext.getExpression(Symbol name) |
Expression |
Interpreter.lookup(Symbol s,
Symbol context)
Retrieves the value of a binding in a named environment
|
Expression |
AppContext.resolveBinding(LibraryBinding lb) |
Modifier and Type | Method and Description |
---|---|
void |
StackTracer.add(Expression expr) |
void |
CallFrame.init(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
Value |
Interpreter.interpret(Expression e) |
LibraryBinding |
AppContext.lookupBinding(Expression e) |
void |
Interpreter.next(Expression nextExpr) |
void |
Interpreter.push(Expression n) |
void |
Interpreter.pushExpr(Expression e) |
void |
Interpreter.setFailureContinuation(Expression e) |
void |
Interpreter.setupTailCall(Expression e,
Value vlr0) |
void |
Interpreter.setupTailCall(Expression e,
Value[] newvlr) |
void |
Interpreter.trace(Expression e) |
Constructor and Description |
---|
CallFrame(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
Modifier and Type | Class and Description |
---|---|
class |
CustomBinaryInputPort
A Scheme binary port whose implementation is provided by a Scheme defined stream
|
class |
CustomBinaryOutputPort |
class |
CustomCharacterInputPort |
class |
CustomCharacterOutputPort |
Modifier and Type | Class and Description |
---|---|
static class |
Annotations.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
Annotations.Index
The Index
|
static class |
Annotations.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
class |
Debugging |
static class |
Debugging.Index |
class |
Logical |
static class |
Logical.Index |
static class |
OptionalPrimitives.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
OptionalPrimitives.Index
The Index
|
static class |
OptionalPrimitives.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
static class |
Primitives.Complex
The Complex procedures either have a side effect, or require the
interpreter to execute
|
static class |
Primitives.Index |
static class |
Primitives.Simple
The Simple procedures are purely functional procedures which do not need
to access interpreter registers to execute
|
class |
R5RS |
static class |
Threads.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
Threads.CondVar |
static class |
Threads.Index |
static class |
Threads.Mutex |
static class |
Threads.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
class |
Types |
static class |
Types.Index |
static class |
Types.SchemeType |
Modifier and Type | Class and Description |
---|---|
class |
Hashtable |
class |
HashtableBase |
class |
Primitives |
class |
SynchronizedHashtable |
class |
WeakHashtable |
Modifier and Type | Class and Description |
---|---|
class |
BinaryIO |
static class |
BinaryIO.Index |
class |
Buffer |
class |
BufferIO |
static class |
BufferIO.Index |
class |
CustomIO |
static class |
CustomIO.Index |
static class |
FileManipulation.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
FileManipulation.Index
The Index
|
static class |
FileManipulation.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
class |
IO |
static class |
IO.Index |
class |
Networking |
static class |
Networking.Index |
static class |
Networking.SchemeMulticastUDPSocket |
static class |
Networking.SchemeServerSocket |
static class |
Networking.SchemeSocket |
static class |
Networking.SchemeTCPSocket |
static class |
Networking.SchemeUDPSocket |
class |
SerialIO |
static class |
SerialIO.Index |
class |
StringIO |
static class |
StringIO.Index |
Modifier and Type | Class and Description |
---|---|
class |
Record |
Modifier and Type | Class and Description |
---|---|
class |
Conversion |
static class |
Conversion.Index |
class |
JavaNull |
class |
JavaObject |
class |
JavaPrimitive |
class |
Operation |
static class |
Operation.Index |
class |
Reflection |
static class |
Reflection.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
Reflection.Index
The Index
|
static class |
Reflection.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
class |
Util |
Modifier and Type | Class and Description |
---|---|
class |
CommonIndexedProcedure
CommonIndexedProcedure is a helper class intended to unify the interfaces
of fixable and non-fixable procedures, so that development of native
libraries is more consistent and flexible.
|
class |
FixableProcedure
A fixable procedure is a Scheme procedure similar to a NativeProcedure,
but which does not need access to the Interpreter to be implemented,
causes no side-effects, and requires three or fewer arguments.
|
class |
IndexedFixableProcedure
An indexed procedure contains the implementation of many
native procedures, indexed by an integer.
|
class |
IndexedLibraryAdapter |
class |
IndexedProcedure
An indexed procedure contains the implementation of many
native procedures, indexed by an integer.
|
class |
NativeLibrary
A Native Library is a collection of bindings that can be imported
into any environment in SISC.
|
static class |
NativeModuleTemplate.Complex
The Complex procedures either have a side effect, or
require the interpreter to execute
|
static class |
NativeModuleTemplate.Index
The Index
|
static class |
NativeModuleTemplate.Simple
The Simple procedures are purely functional procedures
which do not need to access interpreter registers to execute
|
class |
NativeProcedure
A native procedure is a Scheme procedure whose behavior when
applied is implemented in Java code.
|
Modifier and Type | Class and Description |
---|---|
class |
LibraryAE
An SymEnv backed by a random-access library.
|
Modifier and Type | Method and Description |
---|---|
Expression |
SLL2Deserializer.deser() |
protected abstract Expression |
SLL2Deserializer.fetchShared(int oid) |
protected Expression |
BlockDeserializer.fetchShared(int oid) |
protected Expression |
StreamDeserializer.fetchShared(int oid) |
Expression |
Library.getExpression(int oid) |
Expression |
LibraryManager.getExpression(Symbol name) |
Expression |
Library.getExpression(Symbol name) |
Expression |
Library.getLocalExpression(Symbol name) |
Expression |
JavaDeserializer.readExpression() |
Expression |
SLL2Deserializer.readExpression() |
Expression |
Deserializer.readExpression() |
protected Expression |
SLL2Deserializer.readExpression(boolean flush,
int definingOid) |
Expression[] |
DeserializerImpl.readExpressionArray() |
Expression[] |
Deserializer.readExpressionArray() |
Expression |
JavaDeserializer.readInitializedExpression() |
Expression |
SLL2Deserializer.readInitializedExpression() |
Expression |
Deserializer.readInitializedExpression() |
Expression |
LibraryManager.resolveBinding(LibraryBinding lb)
Returns an expression from an external library
|
Expression |
DeserializerImpl.resolveLibraryBinding(LibraryBinding lb) |
protected abstract Expression |
SLL2Deserializer.skipReadObject(boolean flush,
int definingOid) |
protected Expression |
BlockDeserializer.skipReadObject(boolean flush,
int definingOid) |
protected Expression |
StreamDeserializer.skipReadObject(boolean flush,
int definingOid) |
Modifier and Type | Method and Description |
---|---|
int |
LibraryBuilder.add(Expression val)
Add a shared data structure
|
int |
LibraryBuilder.add(Symbol name,
Expression val)
Add an entry point.
|
int |
LibraryBuilder.get(Expression val) |
LibraryBinding |
LibraryManager.lookupBinding(Expression e)
Returns the reference to a binding in the active libraries, or null
if the provided expression isn't an entry point in any library.
|
LibraryBinding |
SerializerImpl.lookupLibraryBinding(Expression e) |
protected abstract void |
SLL2Deserializer.recordReadObject(int definingOid,
Expression e) |
protected void |
BlockDeserializer.recordReadObject(int definingOid,
Expression e) |
protected void |
StreamDeserializer.recordReadObject(int definingOid,
Expression e) |
int |
Library.reverseLookup(Expression e)
Given an expression, return the entry point id of the expression if any, -1 otherwise.
|
void |
SLL2Serializer.serialize(Expression e) |
void |
SLL2Serializer.writeExpression(Expression e) |
void |
Serializer.writeExpression(Expression e) |
void |
JavaSerializer.writeExpression(Expression e) |
protected abstract void |
SLL2Serializer.writeExpression(Expression e,
boolean flush)
Required call which actually writes out the bytes of an expression
|
protected void |
BlockSerializer.writeExpression(Expression e,
boolean flush) |
protected void |
StreamSerializer.writeExpression(Expression e,
boolean flush) |
protected boolean |
SLL2Serializer.writeExpression(Expression e,
int pos,
int offset,
boolean flush) |
void |
SerializerImpl.writeExpressionArray(Expression[] v) |
void |
Serializer.writeExpressionArray(Expression[] vlr) |
void |
SLL2Serializer.writeInitializedExpression(Expression e) |
void |
Serializer.writeInitializedExpression(Expression e) |
void |
JavaSerializer.writeInitializedExpression(Expression e) |
protected void |
SLL2Serializer.writeNewEntryPointMarker(int posi,
Expression e) |
Constructor and Description |
---|
BlockSerializer(AppContext ctx,
java.io.OutputStream out,
java.util.Vector classes,
Expression[] entryPoints) |
Modifier and Type | Method and Description |
---|---|
static Expression |
Util.annotatedAppEval(java.lang.Class clazz,
java.lang.String fn) |
static Expression |
Util.expr(Value o) |
static Expression[] |
Util.pairToExpressions(Pair p) |