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 | |
sisc.io.custom | |
sisc.modules | |
sisc.modules.hashtable | |
sisc.modules.io | |
sisc.modules.record | |
sisc.modules.s2j | |
sisc.nativefun | |
sisc.reader | |
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 |
---|---|
Value |
Syntax.singletonValue() |
Modifier and Type | Method and Description |
---|---|
static int |
Compiler.getExpType(SymbolicEnvironment env,
Value s) |
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 |
Values |
Modifier and Type | Field and Description |
---|---|
Value[] |
Closure.env |
Value |
SchemeThread.rv |
Value |
Box.val |
Value[] |
SchemeVector.vals |
Value[] |
Values.values |
Modifier and Type | Method and Description |
---|---|
Value |
Pair.car() |
Value |
Pair.cdr() |
Value |
Closure.express() |
abstract Value |
Expression.express()
A debugging function, express returns a Scheme value that describes
this expression.
|
Value |
Value.express() |
Value |
Expression.getAnnotation(Symbol key) |
Value |
ExpressionValue.getAnnotation(Symbol key) |
Value |
Expression.getAnnotation(Symbol key,
Value def) |
Value |
SchemeThread.getResult(Interpreter r) |
Value |
Expression.getValue(Interpreter r)
If an expression implements the Immediate interface, it must
override getValue, which returns as a Value, the immediate value
of this expression.
|
Value |
Immediate.getValue(Interpreter r) |
Value |
Value.getValue(Interpreter r)
Called to obtain the value of this Value.
|
Value |
Expression.setAnnotation(Symbol key,
Value val) |
Value |
ExpressionValue.setAnnotation(Symbol key,
Value v) |
Value |
Expression.setAnnotation(Symbol key,
Value val,
Value def) |
Value |
EOFObject.singletonValue() |
Value |
EmptyList.singletonValue() |
Value |
MemoizedSymbol.singletonValue() |
Value |
Nothing.singletonValue() |
Value |
SchemeBoolean.singletonValue() |
Value |
SchemeVoid.singletonValue() |
Value |
Singleton.singletonValue() |
Value |
Quantity.singletonValue() |
Modifier and Type | Method and Description |
---|---|
static void |
Procedure.error(Interpreter r,
Value where,
NestedPrimRuntimeException parent) |
void |
ImmutableVector.fill(Value v) |
void |
SchemeVector.fill(Value v) |
Value |
Expression.getAnnotation(Symbol key,
Value def) |
void |
ImmutableVector.set(int idx,
Value v) |
void |
SchemeVector.set(int idx,
Value v) |
void |
Box.set(Value v) |
Value |
Expression.setAnnotation(Symbol key,
Value val) |
Value |
ExpressionValue.setAnnotation(Symbol key,
Value v) |
Value |
Expression.setAnnotation(Symbol key,
Value val,
Value def) |
void |
ImmutablePair.setCar(Value v) |
void |
Pair.setCar(Value v) |
void |
ImmutablePair.setCdr(Value v) |
void |
Pair.setCdr(Value v) |
boolean |
Box.valueEqual(Value v) |
boolean |
EmptyList.valueEqual(Value o) |
boolean |
ExpressionValue.valueEqual(Value v) |
boolean |
Pair.valueEqual(Value v) |
boolean |
SchemeString.valueEqual(Value v) |
boolean |
SchemeVector.valueEqual(Value v) |
boolean |
Symbol.valueEqual(Value v) |
boolean |
Value.valueEqual(Value v)
Compares this value to another for semantic equality.
|
boolean |
Quantity.valueEqual(Value v) |
Constructor and Description |
---|
Box(Value val) |
Closure(boolean arity,
int fcount,
Expression body,
Value[] env,
int[] boxes) |
ImmutablePair(Value car,
Value cdr) |
ImmutablePair(Value car,
Value cdr,
boolean isImmutable) |
ImmutableVector(int count,
Value initializer) |
ImmutableVector(Value[] v) |
Pair(Value car,
Value cdr) |
SchemeVector(int count,
Value initializer) |
SchemeVector(Value[] v) |
Values(Value[] v) |
Modifier and Type | Class and Description |
---|---|
class |
ConfigParameter |
class |
DelegatingSymEnv |
class |
LexicalEnvironment |
class |
MemorySymEnv |
class |
NativeParameter |
class |
Parameter |
class |
SchemeParameter |
Modifier and Type | Field and Description |
---|---|
protected Value |
SchemeParameter.def |
Value[] |
MemorySymEnv.env |
Value |
DynamicEnvironment.in |
Value |
DynamicEnvironment.out |
Value[] |
LexicalEnvironment.vals |
Value |
DynamicEnvironment.wind |
Modifier and Type | Method and Description |
---|---|
Value |
DelegatingSymEnv.asValue() |
Value |
MemorySymEnv.asValue() |
Value |
SymbolicEnvironment.asValue() |
static Value[] |
LexicalUtils.fixLexicals(Interpreter r,
int lcount,
int[] locs,
int[] lexs) |
Value |
DynamicEnvironment.getCaseSensitive() |
Value |
DynamicEnvironment.getCurrentInPort() |
Value |
DynamicEnvironment.getCurrentOutPort() |
Value |
DynamicEnvironment.getEmitAnnotations() |
Value |
DynamicEnvironment.getEmitDebuggingSymbols() |
Value |
DynamicEnvironment.getHedgedInlining() |
Value |
DynamicEnvironment.getInputPort() |
Value |
DynamicEnvironment.getInternalDebugging() |
Value |
DynamicEnvironment.getMaxStackTraceDepth() |
Value |
DynamicEnvironment.getOutputPort() |
Value |
DynamicEnvironment.getPermissiveParsing() |
Value |
DynamicEnvironment.getPrintShared() |
Value |
DynamicEnvironment.getSourceAnnotations() |
Value |
DynamicEnvironment.getStrictR5RSCompliance() |
Value |
DynamicEnvironment.getSynopsisLength() |
Value |
ConfigParameter.getValue(Interpreter r) |
Value |
NativeParameter.getValue(Interpreter r) |
abstract Value |
Parameter.getValue(Interpreter r) |
Value |
SchemeParameter.getValue(Interpreter r) |
Value |
DynamicEnvironment.getVectorLengthPrefixing() |
Value |
DelegatingSymEnv.lookup(int pi) |
Value |
MemorySymEnv.lookup(int pi) |
Value |
SymbolicEnvironment.lookup(int pi) |
Value |
LexicalEnvironment.lookup(int depth,
int pos) |
Value |
DelegatingSymEnv.lookup(Symbol s) |
Value |
MemorySymEnv.lookup(Symbol s) |
Value |
SymbolicEnvironment.lookup(Symbol s) |
Modifier and Type | Method and Description |
---|---|
int |
DelegatingSymEnv.define(Symbol s,
Value v) |
int |
MemorySymEnv.define(Symbol s,
Value v) |
int |
SymbolicEnvironment.define(Symbol s,
Value v) |
void |
LexicalEnvironment.set(int depth,
int pos,
Value v) |
void |
DelegatingSymEnv.set(int envLoc,
Value v) |
void |
MemorySymEnv.set(int envLoc,
Value v) |
void |
SymbolicEnvironment.set(int envLoc,
Value v) |
void |
DynamicEnvironment.setCaseSensitive(Value v) |
void |
DynamicEnvironment.setCharacterSet(Value v) |
void |
DynamicEnvironment.setEmitAnnotations(Value v) |
void |
DynamicEnvironment.setEmitDebuggingSymbols(Value v) |
void |
DynamicEnvironment.setHedgedInlining(Value v) |
void |
DynamicEnvironment.setInputPort(Value v) |
void |
DynamicEnvironment.setInternalDebugging(Value v) |
void |
DynamicEnvironment.setMaxStackTraceDepth(Value v) |
void |
DynamicEnvironment.setOutputPort(Value v) |
void |
DynamicEnvironment.setPermissiveParsing(Value v) |
void |
DynamicEnvironment.setPrintShared(Value v) |
void |
DynamicEnvironment.setSourceAnnotations(Value v) |
void |
DynamicEnvironment.setStrictR5RSCompliance(Value v) |
void |
DynamicEnvironment.setSynopsisLength(Value v) |
void |
NativeParameter.setValue(Interpreter r,
Value v) |
abstract void |
Parameter.setValue(Interpreter r,
Value v) |
void |
SchemeParameter.setValue(Interpreter r,
Value v) |
void |
DynamicEnvironment.setVectorLengthPrefixing(Value v) |
protected int |
MemorySymEnv.store(Symbol s,
Value v) |
Constructor and Description |
---|
ConfigParameter(java.lang.String paramName,
Value def) |
LexicalEnvironment(Value[] vals,
LexicalEnvironment parent) |
SchemeParameter(Value def) |
Modifier and Type | Class and Description |
---|---|
class |
AnnotatedExpr |
Modifier and Type | Field and Description |
---|---|
Value |
AnnotatedExpr.annotation |
Value |
AnnotatedExpr.stripped |
Modifier and Type | Method and Description |
---|---|
Value |
AnnotatedExpr.express() |
Value |
AppEval.express() |
Value |
AppExp.express() |
Value |
ApplyValuesContEval.express() |
Value |
DefineEval.express() |
Value |
EvalExp.express() |
Value |
FillRibExp.express() |
Value |
FreeReferenceExp.express() |
Value |
FreeSetEval.express() |
Value |
IfEval.express() |
Value |
LambdaExp.express() |
Value |
LetrecEval.express() |
Value |
LetrecExp.express() |
Value |
LexicalReferenceExp.express() |
Value |
LocalReferenceExp.express() |
Value |
SetboxEval.express() |
Value |
UnboxExp.express() |
Value |
AnnotatedExpr.getValue(Interpreter r) |
Value |
FreeReferenceExp.getValue(Interpreter r) |
Value |
LambdaExp.getValue(Interpreter r) |
Value |
LexicalReferenceExp.getValue(Interpreter r) |
Value |
LocalReferenceExp.getValue(Interpreter r) |
Value |
UnboxExp.getValue(Interpreter r) |
Modifier and Type | Method and Description |
---|---|
void |
FreeSetEval.setValue(Interpreter r,
Value v) |
Constructor and Description |
---|
AnnotatedExpr(Expression expr,
Value annotation) |
Modifier and Type | Method and Description |
---|---|
Value |
FixedAppExp_0.doGetValue(FixableProcedure proc,
Interpreter r) |
Value |
FixedAppExp_1.doGetValue(FixableProcedure proc,
Interpreter r) |
Value |
FixedAppExp_2.doGetValue(FixableProcedure proc,
Interpreter r) |
Value |
FixedAppExp_3.doGetValue(FixableProcedure proc,
Interpreter r) |
Value |
FixedAppExp_0.express() |
Value |
FixedAppExp_1.express() |
Value |
FixedAppExp_2.express() |
Value |
FixedAppExp_3.express() |
Value |
FixedAppExp_0.getValue(Interpreter r) |
Modifier and Type | Class and Description |
---|---|
class |
ApplyParentFrame |
class |
CallFrame |
Modifier and Type | Field and Description |
---|---|
Value |
Interpreter.acc |
protected Value[] |
Interpreter.dv1 |
protected Value[] |
Interpreter.dv2 |
protected Value[] |
Interpreter.dv3 |
protected Value[] |
Interpreter.dv4 |
Value[] |
CallFrame.env |
Value[] |
Interpreter.env |
Value[][] |
Interpreter.IAI |
Value[] |
CallFrame.lcl |
Value[] |
Interpreter.lcl |
Value[] |
CallFrame.vlr |
Value[] |
Interpreter.vlr |
Modifier and Type | Method and Description |
---|---|
Value[] |
Interpreter.createValues(int size) |
Value |
Interpreter.eval(Procedure p,
Value[] args)
Applies the given procedure to the given values
|
Value |
Interpreter.eval(java.lang.String expr)
Parses and evaluates s-expression(s)
|
Value |
Interpreter.eval(Value v)
Evaluates a Scheme value as code.
|
Value |
Interpreter.eval(Value v,
SymbolicEnvironment env)
Evaluates a Scheme value as code.
|
Value |
Interpreter.evalInput(java.io.PushbackReader port)
Parses and evaluates s-expression(s) from an input port
|
Value |
ApplyParentFrame.express() |
Value |
CallFrame.express() |
Value |
Interpreter.ThrowSchemeException.express() |
Value |
Interpreter.interpret(Expression e) |
Value |
StackTracer.toValue() |
Value[] |
Interpreter.vlrToArgs()
Returns a Value[] prepared as a value rib
for a procedure with a fixed argument count.
|
Value[] |
Interpreter.vlrToRestArgs(int fcount)
Returns a Value[] prepared as a value rib for a
for procedure expecting rest args in the last
rib position.
|
Modifier and Type | Method and Description |
---|---|
Expression |
Interpreter.compile(Value v) |
Expression |
Interpreter.compile(Value v,
SymbolicEnvironment env) |
void |
Interpreter.define(Symbol s,
Value v,
Symbol context)
Defines a new binding in a named environment.
|
Value |
Interpreter.eval(Procedure p,
Value[] args)
Applies the given procedure to the given values
|
Value |
Interpreter.eval(Value v)
Evaluates a Scheme value as code.
|
Value |
Interpreter.eval(Value v,
SymbolicEnvironment env)
Evaluates a Scheme value as code.
|
void |
CallFrame.init(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
void |
CallFrame.init(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
void |
CallFrame.init(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
void |
Interpreter.newVLR(Value[] vlr) |
void |
Interpreter.returnValues(Value[] v) |
void |
Interpreter.setupTailCall(Expression e,
Value vlr0) |
void |
Interpreter.setupTailCall(Expression e,
Value[] newvlr) |
void |
Interpreter.setVLR(int pos,
Value v) |
static boolean |
CallFrame.visitValueArray(ExpressionVisitor v,
Value[] va) |
Constructor and Description |
---|
CallFrame(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
CallFrame(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
CallFrame(Expression n,
Value[] v,
boolean vk,
Value[] l,
Value[] e,
SymbolicEnvironment t,
CallFrame f,
CallFrame p,
StackTracer tr) |
Modifier and Type | Method and Description |
---|---|
Value |
DeserializerStream.readSer() |
Value |
SerialInputStream.readSer() |
Modifier and Type | Method and Description |
---|---|
ValueWriter |
PortValueWriter.append(Value v) |
ValueWriter |
SharedValueWriter.append(Value v) |
ValueWriter |
ValueWriter.append(Value v) |
void |
PortValueWriter.display(Value v) |
void |
ValueWriter.display(Value v) |
protected void |
PortValueWriter.displayOrWrite(Value v,
boolean display) |
protected void |
SharedValueWriter.displayOrWrite(Value v,
boolean display) |
boolean |
PortValueWriter.isInlinable(Value v) |
boolean |
SharedValueWriter.isInlinable(Value v) |
boolean |
ValueWriter.isInlinable(Value v) |
void |
PortValueWriter.write(Value v) |
void |
ValueWriter.write(Value v) |
void |
SerialOutputStream.writeSer(Value v) |
void |
SerializerStream.writeSer(Value v) |
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 | Field and Description |
---|---|
protected Value |
CustomBinaryInputPort.portLocal |
protected Value |
CustomBinaryOutputPort.portLocal |
protected Value |
CustomCharacterInputPort.portLocal |
protected Value |
CustomCharacterOutputPort.portLocal |
Modifier and Type | Method and Description |
---|---|
static Value |
IOUtils.bridge(Procedure proc,
Value v) |
static Value |
IOUtils.bridge(Procedure proc,
Value[] args) |
Value |
CustomPortProxy.getHost() |
Value |
SchemeInputStream.getHost() |
Value |
SchemeOutputStream.getHost() |
Value |
SchemeReader.getHost() |
Value |
SchemeWriter.getHost() |
Value |
CustomBinaryInputPort.getPortLocal() |
Value |
CustomBinaryOutputPort.getPortLocal() |
Value |
CustomCharacterInputPort.getPortLocal() |
Value |
CustomCharacterOutputPort.getPortLocal() |
Value |
CustomPort.getPortLocal() |
Modifier and Type | Method and Description |
---|---|
static Value |
IOUtils.bridge(Procedure proc,
Value v) |
static Value |
IOUtils.bridge(Procedure proc,
Value[] args) |
void |
CustomPortProxy.setHost(Value host) |
void |
SchemeInputStream.setHost(Value host) |
void |
SchemeOutputStream.setHost(Value host) |
void |
SchemeReader.setHost(Value host) |
void |
SchemeWriter.setHost(Value host) |
void |
CustomBinaryInputPort.setPortLocal(Value local) |
void |
CustomBinaryOutputPort.setPortLocal(Value local) |
void |
CustomCharacterInputPort.setPortLocal(Value local) |
void |
CustomCharacterOutputPort.setPortLocal(Value local) |
void |
CustomPort.setPortLocal(Value v) |
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 | Method and Description |
---|---|
Value |
Threads.Mutex.acquire() |
Value |
OptionalPrimitives.Simple.apply() |
Value |
Primitives.Simple.apply() |
Value |
Threads.Simple.apply() |
Value |
Threads.Complex.apply() |
Value |
Threads.Complex.apply(Interpreter f,
Value v1) |
Value |
Annotations.Simple.apply(Value v1) |
Value |
Logical.apply(Value v1) |
Value |
OptionalPrimitives.Simple.apply(Value v1) |
Value |
OptionalPrimitives.Complex.apply(Value v1) |
Value |
Primitives.Simple.apply(Value v1) |
Value |
Threads.Simple.apply(Value v1) |
Value |
Types.apply(Value v1) |
Value |
Annotations.Complex.apply(Value[] vlr) |
Value |
Logical.apply(Value[] v) |
Value |
OptionalPrimitives.Simple.apply(Value[] vlr) |
Value |
Primitives.Simple.apply(Value[] v) |
Value |
Annotations.Simple.apply(Value v1,
Value v2) |
Value |
Annotations.Complex.apply(Value v1,
Value v2) |
Value |
Logical.apply(Value v1,
Value v2) |
Value |
OptionalPrimitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Threads.Simple.apply(Value v1,
Value v2) |
Value |
Threads.Complex.apply(Value v1,
Value v2) |
Value |
Types.apply(Value v1,
Value v2) |
Value |
Annotations.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Annotations.Complex.apply(Value v1,
Value v2,
Value v3) |
Value |
Logical.apply(Value v1,
Value v2,
Value v3) |
Value |
OptionalPrimitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Threads.Complex.apply(Value v1,
Value v2,
Value v3) |
static Value |
OptionalPrimitives.cadr(Value p) |
static Value |
OptionalPrimitives.cddr(Value p) |
Value |
Annotations.Index.construct(java.lang.Object context,
int id) |
Value |
Debugging.Index.construct(java.lang.Object context,
int id) |
Value |
Logical.Index.construct(java.lang.Object context,
int id) |
Value |
OptionalPrimitives.Index.construct(java.lang.Object context,
int id) |
Value |
Primitives.Index.construct(java.lang.Object context,
int id) |
Value |
Threads.Index.construct(java.lang.Object context,
int id) |
Value |
Types.Index.construct(java.lang.Object context,
int id) |
Value |
Debugging.doApply(Interpreter f) |
Value |
Primitives.Complex.doApply(Interpreter r) |
Value |
Primitives.Complex.doApply(Interpreter r,
Value[] vlr) |
Value |
R5RS.getBindingValue(Interpreter r,
Symbol name) |
Value |
Threads.Mutex.lock(long timeout) |
Value |
Threads.Mutex.unlock(Threads.CondVar condvar,
long timeout) |
Modifier and Type | Method and Description |
---|---|
Value |
Threads.Complex.apply(Interpreter f,
Value v1) |
Value |
Annotations.Simple.apply(Value v1) |
Value |
Logical.apply(Value v1) |
Value |
OptionalPrimitives.Simple.apply(Value v1) |
Value |
OptionalPrimitives.Complex.apply(Value v1) |
Value |
Primitives.Simple.apply(Value v1) |
Value |
Threads.Simple.apply(Value v1) |
Value |
Types.apply(Value v1) |
Value |
Annotations.Complex.apply(Value[] vlr) |
Value |
Logical.apply(Value[] v) |
Value |
OptionalPrimitives.Simple.apply(Value[] vlr) |
Value |
Primitives.Simple.apply(Value[] v) |
Value |
Annotations.Simple.apply(Value v1,
Value v2) |
Value |
Annotations.Complex.apply(Value v1,
Value v2) |
Value |
Logical.apply(Value v1,
Value v2) |
Value |
OptionalPrimitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Threads.Simple.apply(Value v1,
Value v2) |
Value |
Threads.Complex.apply(Value v1,
Value v2) |
Value |
Types.apply(Value v1,
Value v2) |
Value |
Annotations.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Annotations.Complex.apply(Value v1,
Value v2,
Value v3) |
Value |
Logical.apply(Value v1,
Value v2,
Value v3) |
Value |
OptionalPrimitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Threads.Complex.apply(Value v1,
Value v2,
Value v3) |
static Value |
OptionalPrimitives.cadr(Value p) |
static Value |
OptionalPrimitives.cddr(Value p) |
static Threads.CondVar |
Threads.condvar(Value o) |
Value |
Primitives.Complex.doApply(Interpreter r,
Value[] vlr) |
static boolean |
OptionalPrimitives.jnumQuery(Value v,
int mask) |
static Threads.Mutex |
Threads.mutex(Value o) |
static SchemeBoolean |
Primitives.numQuery(Value v,
int mask) |
static Threads.Mutex |
Threads.Mutex.of(Value v) |
static SchemeThread |
Threads.sthread(Value o) |
static Types.SchemeType |
Types.stype(Value o) |
Modifier and Type | Class and Description |
---|---|
class |
Hashtable |
class |
HashtableBase |
class |
Primitives |
class |
SynchronizedHashtable |
class |
WeakHashtable |
Modifier and Type | Method and Description |
---|---|
Value |
Primitives.Simple.apply(Value v1) |
Value |
Primitives.Complex.apply(Value v1) |
Value |
Primitives.Simple.apply(Value[] v) |
Value |
Primitives.Complex.apply(Value[] v) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2) |
Value |
Primitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Complex.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Index.construct(java.lang.Object context,
int id) |
Value |
Hashtable.get(Value k) |
abstract Value |
HashtableBase.get(Value k) |
Value |
SynchronizedHashtable.get(Value k) |
Value |
HashtableKey.getValue() |
Value |
Hashtable.put(Value k,
Value v) |
abstract Value |
HashtableBase.put(Value k,
Value v) |
Value |
SynchronizedHashtable.put(Value k,
Value v) |
Value |
Hashtable.remove(Value k) |
abstract Value |
HashtableBase.remove(Value k) |
Value |
SynchronizedHashtable.remove(Value k) |
Modifier and Type | Method and Description |
---|---|
Value |
Primitives.Simple.apply(Value v1) |
Value |
Primitives.Complex.apply(Value v1) |
Value |
Primitives.Simple.apply(Value[] v) |
Value |
Primitives.Complex.apply(Value[] v) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2) |
Value |
Primitives.Simple.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Complex.apply(Value v1,
Value v2,
Value v3) |
boolean |
Hashtable.callEquals(Value v1,
Value v2) |
int |
Hashtable.callHashCode(Value v) |
Value |
Hashtable.get(Value k) |
abstract Value |
HashtableBase.get(Value k) |
Value |
SynchronizedHashtable.get(Value k) |
protected HashtableKey |
Hashtable.makeKey(Value k) |
protected HashtableKey |
WeakHashtable.makeKey(Value k) |
Value |
Hashtable.put(Value k,
Value v) |
abstract Value |
HashtableBase.put(Value k,
Value v) |
Value |
SynchronizedHashtable.put(Value k,
Value v) |
Value |
Hashtable.remove(Value k) |
abstract Value |
HashtableBase.remove(Value k) |
Value |
SynchronizedHashtable.remove(Value k) |
static HashtableBase |
Primitives.shash(Value o) |
boolean |
Hashtable.valueEqual(Value v) |
abstract boolean |
HashtableBase.valueEqual(Value v) |
boolean |
SynchronizedHashtable.valueEqual(Value v) |
boolean |
WeakHashtable.valueEqual(Value v) |
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 | Method and Description |
---|---|
Value |
StringIO.apply() |
Value |
CustomIO.apply(Value v1) |
Value |
FileManipulation.Simple.apply(Value v1) |
Value |
FileManipulation.Complex.apply(Value v1) |
Value |
StringIO.apply(Value v1) |
Value |
CustomIO.apply(Value v1,
Value v2) |
Value |
FileManipulation.Complex.apply(Value v1,
Value v2) |
Value |
BinaryIO.Index.construct(java.lang.Object context,
int id) |
Value |
BufferIO.Index.construct(java.lang.Object context,
int id) |
Value |
CustomIO.Index.construct(java.lang.Object context,
int id) |
Value |
FileManipulation.Index.construct(java.lang.Object context,
int id) |
Value |
IO.Index.construct(java.lang.Object context,
int id) |
Value |
Networking.Index.construct(java.lang.Object context,
int id) |
Value |
SerialIO.Index.construct(java.lang.Object context,
int id) |
Value |
StringIO.Index.construct(java.lang.Object context,
int id) |
Value |
IO.displayOrWrite(Interpreter r,
SchemeCharacterOutputPort port,
Value v,
boolean display) |
Value |
BinaryIO.doApply(Interpreter f) |
Value |
BufferIO.doApply(Interpreter f) |
Value |
IO.doApply(Interpreter f) |
Value |
Networking.doApply(Interpreter f) |
Value |
SerialIO.doApply(Interpreter f) |
static Value |
IO.read(Interpreter r,
SchemeCharacterInputPort i) |
static Value |
IO.readCode(Interpreter r,
SchemeCharacterInputPort i) |
static Value |
SerialIO.readSer(Interpreter r,
SerialInputStream p) |
static Value |
SerialIO.writeSer(Interpreter r,
SerialOutputStream p,
Value v) |
Modifier and Type | Method and Description |
---|---|
Value |
CustomIO.apply(Value v1) |
Value |
FileManipulation.Simple.apply(Value v1) |
Value |
FileManipulation.Complex.apply(Value v1) |
Value |
StringIO.apply(Value v1) |
Value |
CustomIO.apply(Value v1,
Value v2) |
Value |
FileManipulation.Complex.apply(Value v1,
Value v2) |
static CustomPort |
CustomIO.customport(Value o) |
Value |
IO.displayOrWrite(Interpreter r,
SchemeCharacterOutputPort port,
Value v,
boolean display) |
static java.io.File |
FileManipulation.fileHandle(Value o) |
static Networking.SchemeMulticastUDPSocket |
Networking.mcastsock(Value o) |
static Networking.SchemeServerSocket |
Networking.serversock(Value o) |
static SerialInputStream |
SerialIO.sinport(Value o) |
static Networking.SchemeSocket |
Networking.sock(Value o) |
static SerialOutputStream |
SerialIO.soutport(Value o) |
static Value |
SerialIO.writeSer(Interpreter r,
SerialOutputStream p,
Value v) |
Modifier and Type | Class and Description |
---|---|
class |
Record |
Modifier and Type | Method and Description |
---|---|
Value |
Primitives.Simple.apply(Value v1) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2,
Value v3) |
Value |
Primitives.Index.construct(java.lang.Object context,
int id) |
Value |
Record.getSlot(int idx) |
Value |
Record.getType() |
Modifier and Type | Method and Description |
---|---|
Value |
Primitives.Simple.apply(Value v1) |
Value |
Primitives.Simple.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2) |
Value |
Primitives.Complex.apply(Value v1,
Value v2,
Value v3) |
static Record |
Primitives.record(Value o) |
void |
Record.setSlot(int idx,
Value v) |
void |
Record.setType(Value v) |
boolean |
Record.valueEqual(Value v) |
Constructor and Description |
---|
Record(Value type,
int sz) |
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 | Method and Description |
---|---|
Value |
Reflection.Simple.apply() |
Value |
Conversion.apply(Value v1) |
Value |
Reflection.Simple.apply(Value v1) |
Value |
Conversion.apply(Value v1,
Value v2) |
Value |
Reflection.Simple.apply(Value v1,
Value v2) |
Value |
Reflection.Complex.apply(Value v1,
Value v2,
Value v3) |
Value |
Conversion.Index.construct(java.lang.Object context,
int id) |
Value |
Operation.Index.construct(java.lang.Object context,
int id) |
Value |
Reflection.Index.construct(java.lang.Object context,
int id) |
Value |
Operation.doApply(Interpreter f) |
static Value |
Util.objArrayToVec(java.lang.Object[] objs) |
Modifier and Type | Method and Description |
---|---|
Value |
Conversion.apply(Value v1) |
Value |
Reflection.Simple.apply(Value v1) |
Value |
Conversion.apply(Value v1,
Value v2) |
Value |
Reflection.Simple.apply(Value v1,
Value v2) |
Value |
Reflection.Complex.apply(Value v1,
Value v2,
Value v3) |
static java.lang.Class |
Util.jclass(Value o) |
static java.lang.reflect.Constructor |
Util.jconstr(Value o) |
static java.lang.reflect.Field |
Util.jfield(Value o) |
static java.lang.reflect.Method |
Util.jmethod(Value o) |
static java.lang.Object |
Util.jobj(Value o) |
static int |
Util.jtype(Value o) |
static JavaObject |
Util.sjobj(Value o) |
boolean |
JavaNull.valueEqual(Value v) |
boolean |
JavaObject.valueEqual(Value v) |
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 | Method and Description |
---|---|
Value |
CommonIndexedProcedure.apply() |
Value |
FixableProcedure.apply()
A fixable procedure must subclass one of the following methods
|
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value[] v) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1,
Value v2) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1,
Value v2,
Value v3) |
Value |
CommonIndexedProcedure.apply(Value v1) |
Value |
FixableProcedure.apply(Value v1) |
Value |
CommonIndexedProcedure.apply(Value[] vlr) |
Value |
FixableProcedure.apply(Value[] v) |
Value |
CommonIndexedProcedure.apply(Value v1,
Value v2) |
Value |
FixableProcedure.apply(Value v1,
Value v2) |
Value |
CommonIndexedProcedure.apply(Value v1,
Value v2,
Value v3) |
Value |
FixableProcedure.apply(Value v1,
Value v2,
Value v3) |
Value |
CommonIndexedProcedure.applyZero(Interpreter r)
A common indexed procedure must subclass one of the following methods
|
abstract Value |
IndexedLibraryAdapter.construct(java.lang.Object context,
int id) |
Value |
NativeModuleTemplate.Index.construct(java.lang.Object context,
int id) |
Value |
CommonIndexedProcedure.doApply(Interpreter r) |
Value |
FixableProcedure.doApply(Interpreter r) |
abstract Value |
NativeProcedure.doApply(Interpreter r)
A NativeProcedure instance must implement this method, which
performs the actual processing specific to that procedure, and
returns a Value.
|
Value |
IndexedLibraryAdapter.getBindingValue(Interpreter r,
Symbol name) |
abstract Value |
NativeLibrary.getBindingValue(Interpreter r,
Symbol name) |
Modifier and Type | Method and Description |
---|---|
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value[] v) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1,
Value v2) |
Value |
CommonIndexedProcedure.apply(Interpreter r,
Value v1,
Value v2,
Value v3) |
Value |
CommonIndexedProcedure.apply(Value v1) |
Value |
FixableProcedure.apply(Value v1) |
Value |
CommonIndexedProcedure.apply(Value[] vlr) |
Value |
FixableProcedure.apply(Value[] v) |
Value |
CommonIndexedProcedure.apply(Value v1,
Value v2) |
Value |
FixableProcedure.apply(Value v1,
Value v2) |
Value |
CommonIndexedProcedure.apply(Value v1,
Value v2,
Value v3) |
Value |
FixableProcedure.apply(Value v1,
Value v2,
Value v3) |
Modifier and Type | Method and Description |
---|---|
Value |
Parser.nextExpression(java.io.PushbackReader is) |
protected Value |
Parser.nextExpression(java.io.PushbackReader is,
java.util.HashMap state,
int flags,
Pair anns) |
Value |
Parser.nextExpression(java.io.PushbackReader is,
int radix,
int flags) |
Value |
Parser.nextExpression(java.io.PushbackReader is,
int radix,
int flags,
Pair anns)
Reads an s-expression from the given input port.
|
Value |
Parser.nextExpression(java.io.PushbackReader is,
int flags,
Pair anns) |
Value |
Parser.readList(java.io.PushbackReader is,
java.util.HashMap state,
java.lang.Integer def,
int flags,
Pair anns) |
Modifier and Type | Class and Description |
---|---|
class |
LibraryAE
An SymEnv backed by a random-access library.
|
Modifier and Type | Method and Description |
---|---|
Value[] |
Deserializer.readValueArray() |
Value[] |
DeserializerImpl.readValueArray() |
Modifier and Type | Method and Description |
---|---|
int |
LibraryAE.store(Symbol s,
Value v)
Catch all occurences of sets and note them for when we serialize
|
Modifier and Type | Field and Description |
---|---|
static Value[] |
Util.ZV |
Modifier and Type | Method and Description |
---|---|
static Value |
Util.assq(Value v,
Pair p) |
static Value |
InternedValue.deserResolve(Symbol name,
java.lang.Class clazz) |
Value |
FreeReference.express() |
Value |
FreeReference.getValue() |
Value |
InternedValue.getValue() |
static Value |
Util.javaWrap(java.lang.Object o) |
static Value |
Util.memq(Value v,
Pair p) |
static Value[] |
Util.pairToValues(Pair p) |
static Value |
Util.read(java.lang.String expr) |
Modifier and Type | Method and Description |
---|---|
static AnnotatedExpr |
Util.annotated(Value o) |
static Value |
Util.assq(Value v,
Pair p) |
static SchemeBinaryInputPort |
Util.bininport(Value o) |
static java.io.InputStream |
Util.bininstream(Value o) |
static SchemeBinaryOutputPort |
Util.binoutport(Value o) |
static java.io.OutputStream |
Util.binoutstream(Value o) |
static Box |
Util.box(Value o) |
static char |
Util.character(Value c) |
static SchemeCharacterInputPort |
Util.charinport(Value o) |
static java.io.Reader |
Util.charinreader(Value o) |
static SchemeCharacterOutputPort |
Util.charoutport(Value o) |
static java.io.Writer |
Util.charoutwriter(Value o) |
static SchemeCharacter |
Util.chr(Value o) |
static CallFrame |
Util.cont(Value o) |
void |
FreeReference.define(Value v) |
static SymbolicEnvironment |
Util.env(Value o) |
static void |
Util.error(Interpreter r,
Value errormessage) |
static void |
Util.error(Interpreter r,
Value where,
java.lang.String errormessage) |
static void |
Util.error(Interpreter r,
Value where,
java.lang.String errormessage,
java.lang.Exception e) |
static void |
Util.error(Interpreter r,
Value where,
java.lang.String errormessage,
Pair moreData) |
static Expression |
Util.expr(Value o) |
static ImmutablePair |
Util.immutablePair(Value o) |
static ImmutableVector |
Util.immutableVector(Value o) |
static InputPort |
Util.inport(Value o) |
static InternedValue |
InternedValue.intern(Symbol name,
Value value) |
static Pair |
Util.list(Value o1) |
static Pair |
Util.list(Value o1,
Value o2) |
static Pair |
Util.list(Value o1,
Value o2,
Value o3) |
static Pair |
Util.list(Value o1,
Value o2,
Value o3,
Value o4) |
static Pair |
Util.list(Value o1,
Value o2,
Value o3,
Value o4,
Value o5) |
static InternedValue |
InternedValue.lookupByValue(Value value) |
static Value |
Util.memq(Value v,
Pair p) |
static NativeLibrary |
Util.nlib(Value o) |
static Quantity |
Util.num(Value o) |
static OutputPort |
Util.outport(Value o) |
static Pair |
Util.pair(Value o) |
static Procedure |
Util.proc(Value o) |
void |
FreeReference.setValue(Value v) |
static SchemeString |
Util.str(Value o) |
static java.lang.String |
Util.string(Value o) |
static Symbol |
Util.symbol(Value o) |
static java.lang.String |
Util.symval(Value o) |
static Pair |
Util.truePair(Value o) |
static boolean |
Util.truth(Value v) |
static void |
Util.typeError(java.lang.String type,
Value o) |
static void |
Util.typeError(Symbol bundleName,
java.lang.String type,
Value o) |
static void |
Util.updateName(Value v,
Symbol s) |
static java.net.URL |
Util.url(Value v) |
static java.net.URL |
Util.url(Value current,
Value v) |
static Pair |
Util.valArrayToList(Value[] r) |
static Pair |
Util.valArrayToList(Value[] r,
int offset,
int len) |
static SchemeVector |
Util.valArrayToVec(Value[] r) |
static SchemeVector |
Util.vec(Value o) |