예제 #1
0
        private static Value ApplyIfDefined(OsmiumEngine engine, Symbol sym, Value value)
        {
            if (engine.System.SPreRead.HasOwnValue())
            {
                value = engine.Evaluate(engine.Expr(sym, value));
            }

            return(value);
        }
예제 #2
0
        public void TestSymbolParse()
        {
            void Helper(string goal, string input)
            {
                Assert.AreEqual(_engine.Sym(goal), _engine.Evaluate(input));
            }

            Helper("Global`a", "a");
            Helper("Global`a", "Global`a");
            Helper("Global`x`y", "`x`y");
        }
        public static (Value, bool)? And(OsmiumEngine engine, ExpressionValue expr)
        {
            var pts = new List <Value>();

            bool noChange = true;

            foreach (var part in expr.Parts)
            {
                var epart = engine.Evaluate(part);
                if (epart is Symbol sv)
                {
                    if (sv == engine.System.False)
                    {
                        return(epart, false);
                    }

                    if (sv == engine.System.True)
                    {
                        continue;
                    }
                }

                noChange = noChange && epart.Equals(part);

                pts.Add(epart);
            }

            if (pts.Count == 0)
            {
                return(engine.System.True, false);
            }

            if (pts.Count == 1)
            {
                return(pts[0], false);
            }

            return(engine.Expr(engine.System.And,
                               pts.ToArray()
                               ), false);
        }
예제 #4
0
        static void Main(string[] args)
        {
            var prompt = true;

            if (prompt)
            {
                Console.WriteLine("Osmium Kernel");
            }

            var engine = new OsmiumEngine();

            while (true)
            {
                if (!engine.System.SLine.HasOwnValue())
                {
                    // $Line = 1
                    engine.Set(engine.System.SLine, engine.One);
                }

                if (prompt)
                {
                    Console.WriteLine();
                    Console.Write("In[{0}]:= ", engine.System.SLine.GetValue());
                }

                var input = Console.ReadLine();

                input = (ApplyIfDefined(engine, engine.System.SPreRead, engine.Str(input)) as StringValue)?.Value ?? "";

                var parsed = engine.Parse(input);

                if (parsed == null)
                {
                    continue;
                }

                AddDownValue(engine, engine.System.InString, engine.Str(input), engine.System.SLine);
                AddDownValue(engine, engine.System.In, parsed, engine.System.SLine);

                var output = engine.Evaluate(engine.System.SPre.HasOwnValue() ? engine.Expr(engine.System.SPre, parsed) : parsed);

                output = ApplyIfDefined(engine, engine.System.SPost, output);

                AddDownValue(engine, engine.System.Out, output);

                engine.SetDelayed(
                    engine.Expr(engine.System.MessageList, engine.System.SLine),
                    engine.System.SMessageList.HasOwnValue() ? engine.System.SMessageList.GetValue() : engine.List()
                    );

                if (!output.Equals(engine.Null))
                {
                    output = ApplyIfDefined(engine, engine.System.SPrePrint, output);

                    if (prompt)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Out[{0}]= {1}", engine.System.SLine.GetValue(), output);
                    }
                    else
                    {
                        Console.WriteLine(output);
                    }
                }

                engine.Evaluate(engine.Expr(engine.System.Increment, engine.System.SLine));
            }
        }
예제 #5
0
 Value ValOf(string sym) => _e.Evaluate(_e.Sym(sym));