Ejemplo n.º 1
0
        public static ILispNode Neq(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
            #region DateTime

            try
            {
                var merger = new AtomMerger(new LispMissing());
                var walker = new DateTimeWalker("!=");

                var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);

                return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);
            }
            catch {}

            #endregion

            try
            {
                var merger = new AtomMerger(new LispMissing());
                var walker = new NumberWalker("!=");

                var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);

                return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);
            }
            catch {}

            try
            {
                var merger = new AtomMerger(new LispMissing());
                var walker = new BooleanWalker("!=");

                var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);

                return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);
            }
            catch {}

            try
            {
                var merger = new AtomMerger(new LispMissing());
                var walker = new StringWalker("!=");

                var result = functor.WalkAsBoolean(arguments, callStack, 2, merger, walker);

                return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);
            }
            catch {}

            throw new Exception("!= requires all arguments to be dates, numbers, booleans or strings");
        }
Ejemplo n.º 2
0
        public static ILispNode Apply(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                if (arguments.Count < 1)
                {
                    throw new Exception("MAP requires at least 1 argument");
                }

                var applyFunctor = arguments[0].Eval(callStack, args);

                return(Functor.Apply(applyFunctor, new LispList(null, arguments.Skip(1)), callStack, args));
            }
            catch
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("apply threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(apply {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 3
0
        public static ILispNode Print(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var strResult = arguments.Aggregate(
                String.Empty,
                (r, x) => r + (((r == String.Empty)
                                    ? ""
                                    : " ") + x.Eval(callStack, true).ToString()));

            Console.WriteLine(strResult);

            return(new LispAtom(strResult));

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("print threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(print {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 4
0
        public static ILispNode Prod(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                var merger = new AtomMerger(new LispMissing(), (r, x) => (double)r * (double)x);

                var result = functor.MergeAsNumber(arguments, callStack, 2, merger);

                return((merger.MissingSymbols.Count() > 0)
                        ? merger.MissingSymbols
                        : result);
            }
            catch
            {
                throw new Exception("PROD requires all arguments to be numbers");
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("prod threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(prod {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 5
0
        public static ILispNode Prog(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var values = arguments.Select(x => x.Eval(callStack, true)).ToList();

            var missingSymbols = values.Aggregate(new LispMissing(), (r, x) => r.Merge(x));

            return((missingSymbols.Count() > 0)
                       ? missingSymbols
                       : values.Last());

#if TRACE_FLOW
        }
        catch (Exception ex)
        {
            Console.WriteLine("prog threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(prog {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 6
0
        public static ILispNode Negate(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                var merger = new AtomMerger(new LispMissing(), (r, x) => - 1 * (double)x);

                var result = functor.MergeAsNumber(arguments, callStack, 1, merger);

                return((merger.MissingSymbols.Count() > 0)
                        ? merger.MissingSymbols
                        : result);
            }
            catch (Exception ex)
            {
                throw new LispException(null, "NEGATE throws exception!", ex);
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("negate threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(negate {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 7
0
        public static ILispNode Not(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                var merger = new AtomMerger(new LispMissing(), (r, x) => !(bool)x);

                var result = functor.MergeAsBoolean(arguments, callStack, 1, merger);

                return((merger.MissingSymbols.Count() > 0)
                        ? merger.MissingSymbols
                        : result);
            }
            catch
            {
                throw new Exception("NOT requires its single argument to be Boolean");
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("not threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(not {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 8
0
        public static ILispNode AddNumber(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var merger = new AtomMerger(new LispMissing(), (r, x) => (double)r + (double)x);

            var result = functor.MergeAsNumber(arguments, callStack, 2, merger);

            return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("add_number throws: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(add_number {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 9
0
        public static ILispNode SubDate(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var merger = new AtomMerger(new LispMissing(), (r, x) => (DateTime)r - (TimeSpan)x);

            var result = functor.MergeAsDateTime(arguments, callStack, 2, merger);

            return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("sub_date throws: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(sub_date {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 10
0
        public static ILispNode Concat(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var merger = new AtomMerger(new LispMissing(), (r, x) => (((string)r).Unquote() + ((string)x).Unquote()).Quote());

            var result = functor.MergeAsString(arguments, callStack, 2, merger);

            return((merger.MissingSymbols.Count() > 0)
                    ? merger.MissingSymbols
                    : result);

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("concat throws: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(concat {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 11
0
        public static ILispNode ApplyDynamicFunction(Lambda lambda, LispList arguments, CallStack callStack, params object [] args)
        {
            try
            {
                callStack.PushFrame();

                var functionBodyStatements = lambda.Body;
                var fOptional = false;

                for (var iParam = 0; iParam < lambda.FormalParameters.Count; iParam++)
                {
                    var param = lambda.FormalParameters[iParam];
                    Debug.Assert(param is LispAtom, "Formal Parameter should be an Atom");

                    var paramName = (param as LispAtom).ValueAsString;
                    Debug.Assert(paramName != String.Empty, "Formal Parameter name cannot be a null string");

                    fOptional |= paramName.EndsWith("?");
                    paramName  = paramName.TrimEnd('?');

                    ILispNode paramValue = null;
                    try
                    {
                        paramValue = arguments[iParam].Eval(callStack, true);
                        if (paramValue is LispMissing)
                        {
                            throw new Exception("Value to be bound cannot be evaluated");
                        }
                    }
                    catch
                    {
                        if (!fOptional)
                        {
                            throw new Exception(String.Format("Cannot find value to bind to {0}", paramName));
                        }
                        paramValue = new LispNil();
                    }
                    finally
                    {
                        Debug.Assert(paramValue != null, paramName + " is bound to null");

                        var invocationParamName = String.Format("{0}_{1}", paramName, callStack.NumberOfFrames);
                        callStack[invocationParamName] = paramValue;

                        functionBodyStatements = functionBodyStatements.Select(x => ReplaceParamName(x, paramName, invocationParamName)).ToList();
                    }
                }

                ILispNode result = new LispNil();
                foreach (var statement in functionBodyStatements)
                {
                    result = statement.Eval(callStack);
                }
                return(result);
            }
            finally
            {
                callStack.PopFrame();
            }
        }
Ejemplo n.º 12
0
        public static ILispNode MergeAsBoolean(this ILispNode root, IList <ILispNode> arguments, CallStack callStack, int arity, IMerger merger)
        {
            if (arguments.Count < arity)
            {
                throw new Exception("Not enough arguments");
            }

            var fFirst = true;
            var fUnary = (arity == 1);

            return(new LispAtom(
                       arguments.Aggregate(
                           false,
                           (result, xArg) =>
            {
                var xEval = xArg.Eval(callStack);

                // nil is treated as false
                if (xEval is LispNil)
                {
                    xEval = new LispAtom(false);
                }

                if ((xEval is LispMissing) && (merger.MergeMissing != null))
                {
                    return (bool)merger.MergeMissing(result, xEval as LispMissing);
                }

                if ((xEval is LispList) && (merger.MergeList != null))
                {
                    return (bool)merger.MergeList(result, xEval as LispList);
                }

                Debug.Assert(xEval is LispAtom, "Argument does not evaluate to an Atom!");

                try
                {
                    if (!(xEval as LispAtom).IsBoolean)
                    {
                        throw new Exception();
                    }

                    // if fUnary, it means the function has only the first argument, which must be merged
                    // otherwise, we can prime the pump with the value of the first argument
                    if (fFirst && !fUnary)
                    {
                        result = (xEval as LispAtom).ValueAsBoolean;
                        fFirst = false;

                        return result;
                    }
                    return (bool)merger.MergeAtom(result, (xEval as LispAtom).ValueAsBoolean);
                }
                catch
                {
                    throw new Exception("Argument does not evaluate to a Boolean");
                }
            })));
        }
Ejemplo n.º 13
0
        public static ILispNode Cond(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            var missing = new LispMissing();
            if (arguments.Count < 1)
            {
                throw new Exception("COND requires at least 1 argument");
            }

            for (var i = 0; i <= arguments.Count; i++)
            {
                var _case = arguments[i];
                if (_case is LispMissing)
                {
                    missing.Merge(_case);
                    continue;
                }

                if (!(_case is LispList) && ((_case as LispList).Count != 2))
                {
                    throw new Exception("Each COND case requires exactly 2 arguments");
                }

                var test = (_case as LispList)[0].Eval(callStack, true);
                if (test is LispMissing)
                {
                    missing.Merge(test);
                    continue;
                }

                if ((test is LispNil) || (!(test as LispAtom).ValueAsBoolean))
                {
                    continue;
                }

                return((_case as LispList)[1].Eval(callStack, true));
            }

            return(new LispNil());

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("cond threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(cond {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 14
0
        public static ILispNode WalkAsBoolean(this ILispNode root, IList <ILispNode> arguments, CallStack callStack, int arity, IMerger merger, IWalker walker)
        {
            ILispNode xPrev = null;

            return(new LispAtom(
                       arguments.Aggregate(
                           true,
                           (result, xArg) =>
            {
                var xEval = xArg.Eval(callStack);

                if ((xEval is LispNil) && (merger.MergeNil != null))
                {
                    return (bool)merger.MergeNil(result, xEval as LispNil);
                }

                if ((xEval is LispMissing) && (merger.MergeMissing != null))
                {
                    return (bool)merger.MergeMissing(result, xEval as LispMissing);
                }

                if ((xEval is LispList) && (merger.MergeList != null))
                {
                    return (bool)merger.MergeList(result, xEval as LispList);
                }

                try
                {
                    Debug.Assert(xEval is LispAtom, "Argument does not evaluate to an Atom!");

                    if (walker.ItemTest(xEval))
                    {
                        if (xPrev == null)
                        {
                            walker.First(xEval);
                            return true;
                        }
                        else
                        {
                            return (bool)walker.Sequence(result, xPrev, xEval);
                        }
                    }

                    throw new Exception("ItemTest failed without throwing an exception!");
                }
                catch (Exception ex)
                {
                    throw new Exception("Argument is invalid", ex);
                }
                finally
                {
                    xPrev = xEval;
                }
            })));
        }
Ejemplo n.º 15
0
        public static ILispNode Defun(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                if (arguments.Count < 3)
                {
                    throw new Exception("DEFUN requires at least 3 arguments");
                }

                var functionName = arguments[0].Eval(callStack, false);
                if (!(functionName is LispAtom))
                {
                    throw new Exception("A defun must have a first argument which evaluates to an Atom");
                }

                var name = (functionName as LispAtom).ValueAsString;
                if (name == String.Empty)
                {
                    throw new Exception("A defun must have a non-null string for a name as its first argument");
                }

                if (!(arguments[1] is LispList))
                {
                    throw new Exception("A defun must have a LIST of formal parameters as its second argument");
                }

                var formalParams = (arguments[1] as LispList);

                callStack[name] = new Defun(name, formalParams, arguments.Skip(2).ToList());
                return(new LispAtom(null, name, Token.ValidName));
            }
            catch
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("defun threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(defun {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 16
0
        public static ILispNode WeekOfYear(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
            DateTime result;

            if (DateTime.TryParse((arguments[0].Eval(callStack, true) as LispAtom).ValueAsDateTime.ToString(), out result))
            {
                return(new LispAtom(CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(result, CalendarWeekRule.FirstFourDayWeek, System.DayOfWeek.Sunday)));
            }
            else
            {
                return(new LispNil());
            }
        }
Ejemplo n.º 17
0
        public static ILispNode DayOfYear(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
            DateTime result;

            if (DateTime.TryParse((arguments[0].Eval(callStack, true) as LispAtom).ValueAsDateTime.ToString(), out result))
            {
                return(new LispAtom(result.DayOfYear));
            }
            else
            {
                return(new LispNil());
            }
        }
Ejemplo n.º 18
0
        public static ILispNode Iff(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count < 2)
            {
                throw new Exception("IF requires at least 2 arguments");
            }

            if (arguments.Count > 3)
            {
                throw new Exception("IF requires at most 3 arguments");
            }

            var test = arguments[0].Eval(callStack, true);
            if (test is LispMissing)
            {
                return(test);
            }

            if (test is LispList)
            {
                throw new Exception("IF requires a test which evaluates to an Atom");
            }

            var fTrue = (test as LispAtom).ValueAsBoolean;

            return(fTrue
                       ? arguments[1].Eval(callStack, true)
                       : ((arguments.Count == 3)
                              ? arguments[2].Eval(callStack, true)
                              : (new LispNil())));

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("iif threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(iif {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 19
0
 public LispMissing Merge(ILispNode source)
 {
     try
     {
         if (source is LispMissing)
         {
             (source as LispMissing).ToList().ForEach(x => _missingSymbols.Add(x));
         }
         return(this);
     }
     catch
     {
         return(new LispMissing());
     }
 }
Ejemplo n.º 20
0
        public static ILispNode Lambda(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                if (arguments.Count < 2)
                {
                    throw new Exception("LAMBDA requires at least 2 arguments");
                }

                if (!(arguments[0] is LispList))
                {
                    throw new Exception("A lambda must have a LIST of formal parameters as its first argument");
                }

                var result = new LispList
                {
                    (arguments[0] as LispList)
                };

                foreach (var argument in arguments.Skip(1))
                {
                    result.Add(argument);
                }

                return(result);
            }
            catch
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("lambda threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(lambda {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 21
0
        public static ILispNode Today(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
            try
            {
                var formatParam = (arguments.Count > 0)
                    ? arguments[0].Eval(callStack, true)
                    : null;
                var strFormat = (((formatParam == null) || (formatParam is LispNil))
                    ? String.Empty
                    : (formatParam as LispAtom).ValueAsString);

                return(new LispAtom(DateTime.Today.ToString(strFormat)));
            }
            catch
            {
                return(new LispNil());
            }
        }
Ejemplo n.º 22
0
        public static ILispNode List(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count < 1)
            {
                return(new LispNil());
            }

            var missing = new LispMissing();
            var result  = new LispList();

            foreach (var xEval in arguments.Select(x => x.Eval(callStack, true)))
            {
                if (xEval is LispMissing)
                {
                    missing.Merge(xEval);
                }
                else
                {
                    result.Add(xEval);
                }
            }

            return((missing.Count() > 0)
                       ? missing
                       : result as ILispNode);

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("list threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(list {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 23
0
        public static ILispNode Bool(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                var xEval = arguments[0].Eval(callStack, true);
                if (xEval is LispMissing)
                {
                    return(xEval);
                }

                if (xEval is LispAtom)
                {
                    bool result;
                    if (bool.TryParse((xEval as LispAtom).ValueAsNumber.ToString(), out result))
                    {
                        return(new LispAtom(result));
                    }
                }

                throw new Exception();
            }
            catch
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("bool threw Exception" + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(bool {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 24
0
        public static ILispNode Cdr(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count != 1)
            {
                throw new Exception("CDR requires exactly 1 argument");
            }
            try
            {
                var arg = arguments[0].Eval(callStack, true);
                if (arg is LispMissing)
                {
                    return(arg);
                }

                if ((arg is LispNil) || (arg is LispAtom))
                {
                    return(new LispNil());
                }

                return((arg as LispList).Cdr);
            }
            catch (Exception)
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("cdr threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(cdr {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 25
0
        public static ILispNode NilP(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count != 1)
            {
                throw new Exception("NIL-P requires exactly one argument");
            }

            var result = arguments[0].Eval(callStack, true);

            if (result is LispNil)
            {
                return(new LispAtom(true));
            }
            if ((result is LispAtom) && !(result as LispAtom).ValueAsBoolean)
            {
                return(new LispAtom(true));
            }
            if ((result is LispList) && ((result as LispList).Count == 0))
            {
                return(new LispAtom(true));
            }

            return(new LispAtom(false));

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("nil_p threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(nil_p {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 26
0
        public static ILispNode Date(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
            DateTime result;

            if (DateTime.TryParse((arguments[0].Eval(callStack, true) as LispAtom).ValueAsDateTime.ToString(), out result))
            {
                var formatParam = (arguments.Count > 1)
                    ? arguments[1].Eval(callStack, true)
                    : null;
                var strFormat = ((formatParam is LispNil)
                    ? String.Empty
                    : (formatParam as LispAtom).ValueAsString);

                return(new LispAtom(result.ToString(strFormat)));
            }
            else
            {
                return(new LispNil());
            }
        }
Ejemplo n.º 27
0
        public static ILispNode SetQ(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count != 2)
            {
                throw new Exception("SETQ requires exactly 2 arguments");
            }

            var variableName = arguments[0].Eval(callStack, false);
            if (!(variableName is LispAtom))
            {
                throw new Exception("A setq must have a first argument which evaluates to an Atom");
            }

            var name = (variableName as LispAtom).ValueAsString;
            if (name == String.Empty)
            {
                throw new Exception("A setq must have a non-null string for a name as its first argument");
            }

            callStack[name] = arguments[1].Eval(callStack, true);

            return(callStack[name] as ILispNode);

#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("setq threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(setq {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 28
0
        public static ILispNode Atom(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            if (arguments.Count != 1)
            {
                throw new Exception("ATOM requires exactly one argument");
            }

            var result = arguments[0].Eval(callStack, true);

            if (result is LispNil)
            {
                return(result);
            }
            if (result is LispMissing)
            {
                return(result);
            }
            if (result is LispAtom)
            {
                return(result);
            }

            throw new Exception("ATOM requires arguments that evaluate to Atom");
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("atom threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(atom {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 29
0
        public static ILispNode False(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object [] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            return(new LispAtom(false));

#if TRACE_FLOW
        }
        catch (Exception ex)
        {
            Console.WriteLine("false threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(false {0}) done", arguments.ToLispArgString());
        }
#endif
        }
Ejemplo n.º 30
0
        public static ILispNode Map(ILispNode functor, IList <ILispNode> arguments, CallStack callStack, params object[] args)
        {
#if TRACE_FLOW
            try
            {
#endif
            try
            {
                if (arguments.Count < 1)
                {
                    throw new Exception("MAP requires at least 1 argument");
                }

                var result = new LispList();

                var mapFunctor = arguments[0].Eval(callStack, args);

                // run through the arguments list one at a time and map them to the result with the lambda
                arguments.Skip(1).ToList().ForEach(x => result.Add(Functor.Apply(mapFunctor, new LispList().Add(x), callStack, args)));

                return(result);
            }
            catch
            {
                return(new LispNil());
            }
#if TRACE_FLOW
        }

        catch (Exception ex)
        {
            Console.WriteLine("map threw Exception: " + ex.Message);
            throw;
        }
        finally
        {
            Console.WriteLine("(map {0}) done", arguments.ToLispArgString());
        }
#endif
        }