Uses of Class
sisc.data.Expression

Packages that use Expression

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

Uses of Expression in sisc

Subclasses of Expression in sisc

static class

REPL.SchemeSocketThread

Uses of Expression in sisc.compiler

Subclasses of Expression in sisc.compiler

class

Syntax

Methods in sisc.compiler that return Expression

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)

Methods in sisc.compiler with parameters of type Expression

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)

Uses of Expression in sisc.data

Subclasses of Expression in sisc.data

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

Fields in sisc.data declared as Expression

Expression	Closure.body
Expression	ExpressionValue.e

Constructors in sisc.data with parameters of type Expression

Closure(boolean arity, int fcount, Expression body, Value[] env, int[] boxes)

ExpressionValue(Expression e)

Uses of Expression in sisc.env

Subclasses of Expression in sisc.env

class	ConfigParameter
class	DelegatingSymEnv
class	LexicalEnvironment
class	MemorySymEnv
class	NativeParameter
class	Parameter
class	SchemeParameter

Uses of Expression in sisc.exprs

Subclasses of Expression in sisc.exprs

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

Fields in sisc.exprs declared as Expression

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

Methods in sisc.exprs with parameters of type Expression

void	LetrecEval.alter(Interpreter r, int uexpPosition, Expression replaceWith)
void	IfEval.alter(Interpreter r, int uexpPosition, Expression replaceWith)
void	FillRibExp.alter(Interpreter r, int uexpPosition, Expression replaceWith)
void	EvalExp.alter(Interpreter r, int uexpPosition, Expression replaceWith)
void	AppExp.alter(Interpreter r, int uexpPosition, Expression replaceWith)
void	AnnotatedExpr.alter(Interpreter r, int uexpPosition, Expression replaceWith)

Constructors in sisc.exprs with parameters of type Expression

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)

Uses of Expression in sisc.exprs.fp

Subclasses of Expression in sisc.exprs.fp

class	FixedAppExp_0
class	FixedAppExp_1
class	FixedAppExp_2
class	FixedAppExp_3

Methods in sisc.exprs.fp that return Expression

Expression[]	FixedAppExp_3.getOperands()
Expression[]	FixedAppExp_2.getOperands()
Expression[]	FixedAppExp_1.getOperands()
Expression[]	FixedAppExp_0.getOperands()

Methods in sisc.exprs.fp with parameters of type Expression

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.
void	FixedAppExp_1.alter(Interpreter r, int uexpPosition, Expression replaceWith)
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)

Uses of Expression in sisc.interpreter

Subclasses of Expression in sisc.interpreter

class	ApplyParentFrame
class	CallFrame
static class	Interpreter.ThrowSchemeException

Fields in sisc.interpreter declared as Expression

Expression	Interpreter.nxp
Expression	CallFrame.nxp

Methods in sisc.interpreter that return Expression

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)

Methods in sisc.interpreter with parameters of type Expression

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)

Constructors in sisc.interpreter with parameters of type Expression

CallFrame(Expression n, Value[] v, boolean vk, Value[] l, Value[] e, SymbolicEnvironment t, CallFrame f, CallFrame p, StackTracer tr)

Uses of Expression in sisc.io.custom

Subclasses of Expression in sisc.io.custom

class	CustomBinaryInputPort A Scheme binary port whose implementation is provided by a Scheme defined stream
class	CustomBinaryOutputPort
class	CustomCharacterInputPort
class	CustomCharacterOutputPort

Uses of Expression in sisc.modules

Subclasses of Expression in sisc.modules

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

Uses of Expression in sisc.modules.hashtable

Subclasses of Expression in sisc.modules.hashtable

class	Hashtable
class	HashtableBase
class	Primitives
class	SynchronizedHashtable
class	WeakHashtable

Uses of Expression in sisc.modules.io

Subclasses of Expression in sisc.modules.io

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

Uses of Expression in sisc.modules.record

Subclasses of Expression in sisc.modules.record

class

Record

Uses of Expression in sisc.modules.s2j

Subclasses of Expression in sisc.modules.s2j

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

Uses of Expression in sisc.nativefun

Subclasses of Expression in sisc.nativefun

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.

Uses of Expression in sisc.ser

Subclasses of Expression in sisc.ser

class

LibraryAE An SymEnv backed by a random-access library.

Methods in sisc.ser that return Expression

Expression	SLL2Deserializer.deser()
protected Expression	StreamDeserializer.fetchShared(int oid)
protected abstract Expression	SLL2Deserializer.fetchShared(int oid)
protected Expression	BlockDeserializer.fetchShared(int oid)
Expression	Library.getExpression(int oid)
Expression	LibraryManager.getExpression(Symbol name)
Expression	Library.getExpression(Symbol name)
Expression	Library.getLocalExpression(Symbol name)
Expression	SLL2Deserializer.readExpression()
Expression	JavaDeserializer.readExpression()
Expression	Deserializer.readExpression()
protected Expression	SLL2Deserializer.readExpression(boolean flush, int definingOid)
Expression[]	DeserializerImpl.readExpressionArray()
Expression[]	Deserializer.readExpressionArray()
Expression	SLL2Deserializer.readInitializedExpression()
Expression	JavaDeserializer.readInitializedExpression()
Expression	Deserializer.readInitializedExpression()
Expression	LibraryManager.resolveBinding(LibraryBinding lb) Returns an expression from an external library
Expression	DeserializerImpl.resolveLibraryBinding(LibraryBinding lb)
protected Expression	StreamDeserializer.skipReadObject(boolean flush, int definingOid)
protected abstract Expression	SLL2Deserializer.skipReadObject(boolean flush, int definingOid)
protected Expression	BlockDeserializer.skipReadObject(boolean flush, int definingOid)

Methods in sisc.ser with parameters of type Expression

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 void	StreamDeserializer.recordReadObject(int definingOid, Expression e)
protected abstract void	SLL2Deserializer.recordReadObject(int definingOid, Expression e)
protected void	BlockDeserializer.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	Serializer.writeExpression(Expression e)
void	SLL2Serializer.writeExpression(Expression e)
void	JavaSerializer.writeExpression(Expression e)
protected void	StreamSerializer.writeExpression(Expression e, boolean flush)
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 boolean	SLL2Serializer.writeExpression(Expression e, int pos, int offset, boolean flush)
void	SerializerImpl.writeExpressionArray(Expression[] v)
void	Serializer.writeExpressionArray(Expression[] vlr)
void	Serializer.writeInitializedExpression(Expression e)
void	SLL2Serializer.writeInitializedExpression(Expression e)
void	JavaSerializer.writeInitializedExpression(Expression e)
protected void	SLL2Serializer.writeNewEntryPointMarker(int posi, Expression e)

Constructors in sisc.ser with parameters of type Expression

BlockSerializer(AppContext ctx, java.io.OutputStream out, java.util.Vector classes, Expression[] entryPoints)

Uses of Expression in sisc.util

Methods in sisc.util that return Expression

static Expression	Util.annotatedAppEval(java.lang.Class clazz, java.lang.String fn)
static Expression	Util.expr(Value o)
static Expression[]	Util.pairToExpressions(Pair p)