| public Contains ( LSharp.Symbol symbol ) : bool | ||
| symbol | LSharp.Symbol | |
| return | bool | |
/// <summary>
/// Determines whether the environment contains a definition for
/// a variable with the given symbol
/// </summary>
/// <param name="symbol"></param>
/// <returns>True or false</returns>
public bool Contains(Symbol symbol)
{
if (hashtable.ContainsKey(symbol))
{
return(true);
}
if (previousEnvironment != null)
{
return(previousEnvironment.Contains(symbol));
}
return(false);
}
/// <summary>
/// Evaluates an expression in a given lexical environment
/// </summary>
/// <param name="expression"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Eval(Object expression, Environment environment)
{
profiler.TraceCall(expression);
if (expression == null)
return profiler.TraceReturn(null);
// The expression is either an atom or a list
if (Primitives.IsAtom(expression))
{
// Number
if (expression.GetType() == typeof(Double))
return profiler.TraceReturn(expression);
if (expression.GetType() == typeof(int))
return profiler.TraceReturn(expression);
// Character
if (expression.GetType() == typeof(char))
return profiler.TraceReturn(expression);
// String
if (expression.GetType() == typeof(string))
return profiler.TraceReturn(expression);
if (((Symbol)expression) == Symbol.TRUE)
return profiler.TraceReturn(true);
if (((Symbol)expression) == Symbol.FALSE)
return profiler.TraceReturn(false);
if (((Symbol)expression) == Symbol.NULL)
return profiler.TraceReturn(null);
// If the symbol is bound to a value in this lexical environment
if (environment.Contains((Symbol)expression))
// Then it's a variable so return it's value
return profiler.TraceReturn(environment.GetValue((Symbol)expression));
else
{
// Otherwise symbols evaluate to themselves
return profiler.TraceReturn(expression);
}
}
else
{
// The expression must be a list
Cons cons = (Cons)expression;
// Lists are assumed to be of the form (function arguments)
object function = null;
// However, we need to check to see if the function is actually a cons
// that evaluates to a function first, as in:
// (= foo (fn () "bar"))
// (= dispatch (new system.collections.hashtable))
// (set_item dispatch "foo" foo)
// ((item dispatch "foo"))
if (cons.First() is Cons)
{
// if the first arg is a Cons, try to evaluate it to a function
function = Eval(cons.First(), environment);
}
else if (cons.First() is Symbol)
{
// See if there is a binding to a function, clsoure, macro or special form
// in this lexical environment
function = environment.GetValue((Symbol)cons.First());
if (function == null)
function = cons.First();
}
else if (cons.First() == null)
{
string msg = "Expected a function as the first argument in a list but received null";
throw new System.ArgumentNullException(msg);
}
else
{
string msg = "Expected a function as the first argument in a list but received type '";
msg += cons.First().GetType().ToString() + "'";
throw new System.ArgumentException(msg);
}
// If it's a special form
if (function.GetType() == typeof(SpecialForm))
{
return profiler.TraceReturn(((SpecialForm)function)((Cons)cons.Cdr(), environment));
}
// If its a macro application
if (function.GetType() == typeof(Macro))
{
object expansion = ((Macro)function).Expand((Cons)cons.Cdr());
return profiler.TraceReturn(Runtime.Eval(expansion, environment));
}
// It must be a function, closure or method invocation,
// so call apply
Object arguments = EvalList((Cons)cons.Cdr(), environment);
return profiler.TraceReturn(Runtime.Apply(function, arguments, environment));
}
}
public static bool Bound(Symbol symbol, Environment environment)
{
if (environment.Contains(symbol))
return true;
else
return false;
}
public static Expression Compile1(Object s, Environment environment)
{
// Literals are constants
if (Runtime.IsLiteral(s))
return Expression.Constant(s);
// Special Syntax gets expanded and compiled
if (Runtime.IsSsyntax(s))
return Compile1(Runtime.ExpandSSyntax(s),environment);
// Symbols are variable references
if (s is Symbol)
return CompileVarRef((Symbol)s);
// Special Syntax gets expanded and compiled
if (Runtime.IsSsyntax(Runtime.Car(s)))
{
object expansion = Runtime.ExpandSSyntax(((Pair)s).First());
return Compile1(new Pair(expansion, (Pair)s),environment);
}
if (s is Pair)
{
object f = ((Pair)s).First();
// Special Forms
if (f == Symbol.FromName("if"))
return Compiler.CompileIf(((Pair)s).Rest(), environment);
if (f == Symbol.FromName("quote"))
return Compiler.CompileQuote(((Pair)s).Rest(), environment);
if (f == Symbol.FromName("call-clr"))
return Compiler.CompileCall((Pair)((Pair)s).Rest(), environment);
if (f == Symbol.FromName("call-instance"))
return Compiler.CompileInstanceCall((Pair)((Pair)s).Rest(), environment);
if (f == Symbol.FromName("fn"))
return Compiler.CompileFn((Pair)((Pair)s).Rest(), environment);
if (f == Symbol.FromName("macro"))
return Compiler.CompileMac((Pair)((Pair)s).Rest(), environment);
if (f == Symbol.FromName("quasiquote"))
return Compiler.CompileQuasiQuote((Pair)((Pair)s).Rest(), environment);
if ((f is Symbol) && (environment.Contains((Symbol)f)))
{
object value = environment.GetValue((Symbol)f);
// Macros get invoked at compile time, then their results are themeselves compiled
if (value is Macro)
{
object expansion = ((Macro)value).Call(Runtime.AsArray(((Pair)s).Rest()));
return Compile1(expansion,environment);
}
}
// It must be a function call
return CompileFunctionCall(f, ((Pair)s).Rest(),environment);
}
throw new LSharpException(string.Format("Bad object in expression: ", s),environment);
}
public static Expression Compile1(Object s, Environment environment)
{
// Literals are constants
if (Runtime.IsLiteral(s))
{
return(Expression.Constant(s));
}
// Special Syntax gets expanded and compiled
if (Runtime.IsSsyntax(s))
{
return(Compile1(Runtime.ExpandSSyntax(s), environment));
}
// Symbols are variable references
if (s is Symbol)
{
return(CompileVarRef((Symbol)s));
}
// Special Syntax gets expanded and compiled
if (Runtime.IsSsyntax(Runtime.Car(s)))
{
object expansion = Runtime.ExpandSSyntax(((Pair)s).First());
return(Compile1(new Pair(expansion, (Pair)s), environment));
}
if (s is Pair)
{
object f = ((Pair)s).First();
// Special Forms
if (f == Symbol.FromName("if"))
{
return(Compiler.CompileIf(((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("quote"))
{
return(Compiler.CompileQuote(((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("call-clr"))
{
return(Compiler.CompileCall((Pair)((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("call-instance"))
{
return(Compiler.CompileInstanceCall((Pair)((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("fn"))
{
return(Compiler.CompileFn((Pair)((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("macro"))
{
return(Compiler.CompileMac((Pair)((Pair)s).Rest(), environment));
}
if (f == Symbol.FromName("quasiquote"))
{
return(Compiler.CompileQuasiQuote((Pair)((Pair)s).Rest(), environment));
}
if ((f is Symbol) && (environment.Contains((Symbol)f)))
{
object value = environment.GetValue((Symbol)f);
// Macros get invoked at compile time, then their results are themeselves compiled
if (value is Macro)
{
object expansion = ((Macro)value).Call(Runtime.AsArray(((Pair)s).Rest()));
return(Compile1(expansion, environment));
}
}
// It must be a function call
return(CompileFunctionCall(f, ((Pair)s).Rest(), environment));
}
throw new LSharpException(string.Format("Bad object in expression: ", s), environment);
}
/// <summary>
/// Evaluates an expression in a given lexical environment
/// </summary>
/// <param name="form"></param>
/// <param name="environment"></param>
/// <returns></returns>
public static Object Eval(Object expression, Environment environment)
{
profiler.TraceCall(expression);
if (expression == Reader.EOFVALUE)
{
return(profiler.TraceReturn(expression));
}
if (expression == null)
{
return(profiler.TraceReturn(null));
}
// The expression is either an atom or a list
if (Primitives.IsAtom(expression))
{
// Number
if (expression is double)
{
return(profiler.TraceReturn(expression));
}
if (expression is int)
{
return(profiler.TraceReturn(expression));
}
// Character
if (expression is char)
{
return(profiler.TraceReturn(expression));
}
// String
if (expression is string)
{
return(profiler.TraceReturn(expression));
}
Symbol sym = expression as Symbol;
if (sym == Symbol.TRUE)
{
return(profiler.TraceReturn(true));
}
if (sym == Symbol.FALSE)
{
return(profiler.TraceReturn(false));
}
if (sym == Symbol.NULL)
{
return(profiler.TraceReturn(null));
}
// If the symbol is bound to a value in this lexical environment
if (environment.Contains(sym))
{
// Then it's a variable so return it's value
return(profiler.TraceReturn(environment.GetValue(sym)));
}
else
{
// Otherwise symbols evaluate to themselves
return(profiler.TraceReturn(expression));
}
}
else
{
// The expression must be a list
Cons cons = (Cons)expression;
// Lists are assumed to be of the form (function arguments)
// See if there is a binding to a function, clsoure, macro or special form
// in this lexical environment
object function = environment.GetValue((Symbol)cons.First());
// If there is no binding, then use the function name directly - it's probably
// the name of a .NET method
if (function == null)
{
function = cons.First();
}
// If it's a special form
if (function is SpecialForm)
{
return(profiler.TraceReturn(((SpecialForm)function)((Cons)cons.Cdr(), environment)));
}
// If its a macro application
if (function is Macro)
{
object expansion = ((Macro)function).Expand((Cons)cons.Cdr());
return(profiler.TraceReturn(Runtime.Eval(expansion, environment)));
}
// It must be a function, closure or method invocation,
// so call apply
Object arguments = EvalList((Cons)cons.Cdr(), environment);
return(profiler.TraceReturn(Runtime.Apply(function, arguments, environment)));
}
}
private static void ProcessKeyArguments(Cons argumentNameList, Cons argumentList,
Environment localEnvironment)
{
// Make sure that all of the defined key arguments are inserted to the local enviroment with their
// defaults.
while (argumentNameList != null)
{
Symbol argumentName = null;
object argumentValue = null;
// We need to get the name of the argument, it can either be just the name or, it can be
// it's own Cons with the name and an expression for the default value.
if (argumentNameList.Car().GetType() == typeof(Cons))
{
// It is a Cons, so extract the name and the default value. Because the default can be
// any expression, we need to evaluate the value every time the function is called.
argumentName = (Symbol)argumentNameList.Caar();
argumentValue = Runtime.Eval(argumentNameList.Cadar(), localEnvironment);
}
else
{
argumentName = (Symbol)argumentNameList.Car();
}
// Add this variable to the closure's environment, then advance to the next parameter.
localEnvironment.AssignLocal(argumentName, argumentValue);
argumentNameList = (Cons)argumentNameList.Cdr();
}
// Now that the parameters and their defaults have been added to the environment we can now
// process the supplied arguments.
while (argumentList != null)
{
// Because these are keyed parameters, the caller needs to specify the name of each
// parameter.
if (argumentList.Car().GetType() != typeof(Symbol))
{
throw new LSharpException("Key parameters must be specified by name.");
}
// Grab the current parameter and the value associated with it. Then make sure that this
// is a keyword.
Symbol keywordName = (Symbol)argumentList.Car();
object argumentValue = argumentList.Cadr();
if (keywordName.Name[0] != ':')
{
throw new LSharpException(keywordName + " is not a valid keyword.");
}
// Now that we know they supplied a keyword, create a symbol out of it and make sure that
// it exists.
//keywordName = new Symbol(keywordName.Name.Substring(1));
keywordName = Symbol.FromName(keywordName.Name.Substring(1));
if (localEnvironment.Contains(keywordName) == false)
{
throw new LSharpException(keywordName + " is not a recognised keyword.");
}
// Update the parameter with the value that the user specified and then move onto the next
// argument in the list.
localEnvironment.AssignLocal(keywordName, argumentValue);
argumentList = (Cons)argumentList.Cddr();
}
}
private static void ProcessKeyArguments(Cons argumentNameList, Cons argumentList,
Environment localEnvironment)
{
// Make sure that all of the defined key arguments are inserted to the local enviroment with their
// defaults.
while (argumentNameList != null)
{
Symbol argumentName = null;
object argumentValue = null;
// We need to get the name of the argument, it can either be just the name or, it can be
// it's own Cons with the name and an expression for the default value.
if (argumentNameList.Car() is Cons)
{
// It is a Cons, so extract the name and the default value. Because the default can be
// any expression, we need to evaluate the value every time the function is called.
argumentName = (Symbol)argumentNameList.Caar();
argumentValue = Runtime.Eval(argumentNameList.Cadar(), localEnvironment);
}
else
{
argumentName = (Symbol)argumentNameList.Car();
}
// Add this variable to the closure's environment, then advance to the next parameter.
localEnvironment.AssignLocal(argumentName, argumentValue);
argumentNameList = (Cons)argumentNameList.Cdr();
}
// Now that the parameters and their defaults have been added to the environment we can now
// process the supplied arguments.
while (argumentList != null)
{
// Because these are keyed parameters, the caller needs to specify the name of each
// parameter.
if (argumentList.Car().GetType() != typeof(Symbol))
{
throw new LSharpException("Key parameters must be specified by name.");
}
// Grab the current parameter and the value associated with it. Then make sure that this
// is a keyword.
Symbol keywordName = (Symbol)argumentList.Car();
object argumentValue = argumentList.Cadr();
if (keywordName.Name[0] != ':')
{
throw new LSharpException(keywordName + " is not a valid keyword.");
}
// Now that we know they supplied a keyword, create a symbol out of it and make sure that
// it exists.
//keywordName = new Symbol(keywordName.Name.Substring(1));
keywordName = Symbol.FromName(keywordName.Name.Substring(1));
if (localEnvironment.Contains(keywordName) == false)
{
throw new LSharpException(keywordName + " is not a recognised keyword.");
}
// Update the parameter with the value that the user specified and then move onto the next
// argument in the list.
localEnvironment.AssignLocal(keywordName, argumentValue);
argumentList = (Cons)argumentList.Cddr();
}
}