public override void Invoke(SpoolSpace Memory) { Cell x = this._Parameters[0].Evaluate(Memory); if (x.Affinity == CellAffinity.ARRAY) { x.ARRAY.Sort(); } else if (x.Affinity == CellAffinity.TREF) { Table t = this._Host.OpenTable(x.valueTREF); Key k = new Key(); if (this._Parameters.Count >= 2) { Cell y = this._Parameters[1].Evaluate(Memory); if (y.IsNumeric) { k.Add(y.valueINT); } else if (y.IsArray) { foreach (Cell z in y.valueARRAY) { k.Add(z.valueINT); } } else { k = Key.Build(t.Columns.Count); } } Spectre.Tables.TableUtil.Sort(t, k); } }
public override void BeginInvoke(SpoolSpace Memory) { // Do the checks, need an aggregate and we must be part of a loop if (!this._Parameters.ContainsAggregate || !this._Parameters.ContainsNonAggregate) { throw new Exception("Dictionary aggregates must contain at least one aggregate and one non-aggregate"); } //if (this._Parent == null || !this._Parent.IsBreakable) // throw new Exception("Aggregates can only appear in loop statements"); // We don't need to invoke the base method // Build the keys Key k = new Key(), v = new Key(); int idx = 0; foreach (Expression x in this._Parameters) { if (x.IsAggregate) { v.Add(idx); } else { k.Add(idx); } idx++; } // Set up the staging table // this._StorageTree = new DictionaryTable(this._Host, Host.RandomPath(), this._Parameters.Columns, k, Page.DEFAULT_SIZE); }
public override void Invoke(SpoolSpace Memory) { // Get the table source // if (this._Parameters[0].TypeOf() != CellAffinity.TREF) { throw new Exception("Table loops require a tabular expression"); } this.AddSpools(Memory); // Get the table Table t = this._Parameters[0].Select(Memory); // Loop using (RecordReader rr = t.OpenReader()) { while (rr.CanAdvance) { Memory[this._SpoolName].Set(rr.ReadNext()); if (this._Filter.Evaluate(Memory).valueBOOL) { this.InvokeChildren(Memory); } } } this.RemoveSpools(Memory); }
/// <summary> /// Creates a host /// </summary> public Host() { // Check the directory Host.CheckDir(); // Timer this._Timer = Stopwatch.StartNew(); // Communicator this._IO = new CommandLineCommunicator(); // Random number generator this._RNG = new CellRandom(); // Tables this._Cache = new TableStore(this); // Spools this._Store = new SpoolSpace(); this._Store.Add(GLOBAL, new Spool.HeapSpindle(GLOBAL)); // Libraries this._Libraries = new Heap <Library>(); this._Libraries.Allocate("BASE", new BaseLibrary(this)); // Engine this._Engine = new ScriptProcessor(this); // Possibly create a log writer // if (DEBUG_STATE == 1) { this._DebugWriter = new StreamWriter(DebugLogPath); } }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell x = this._Children[0].Evaluate(Memory); return(new Cell(CellSerializer.DiskSize(x))); }
public override void Invoke(SpoolSpace Memory) { Record value = this._Parameters.ToRecord(Memory); value = this.CheckValue(value); this._Writer.Insert(value); }
public override void Invoke(SpoolSpace Memory) { Table Destination = this._Parameters[0].Select(Memory); string Source = this._Parameters[1].Evaluate(Memory).valueCSTRING; char[] Delims = this._Parameters[2].Evaluate(Memory).valueCSTRING.ToCharArray(); char Escape = (this._Parameters.Count >= 4 ? this._Parameters[3].Evaluate(Memory).valueCSTRING.First() : char.MaxValue); int Skips = (this._Parameters.Count == 5 ? this._Parameters[4].Evaluate(Memory).valueINT : 0); using (StreamReader Reader = new StreamReader(Source)) { int i = 0; while (i < Skips && !Reader.EndOfStream) { i++; Reader.ReadLine(); } using (RecordWriter Writer = Destination.OpenWriter()) { while (!Reader.EndOfStream) { Record r = Util.StringUtil.ToRecord(Reader.ReadLine(), Destination.Columns, Delims, Escape); Writer.Insert(r); } } } }
public override void Invoke(SpoolSpace Memory) { this.CheckParameters(2, 4); Table Source = this._Parameters[0].Select(Memory); string Path = this._Parameters[1].Evaluate(Memory); string Delim = this._Parameters.Count >= 3 ? this._Parameters[2].Evaluate(Memory).valueCSTRING : "\t"; string TextQ = this._Parameters.Count == 4 ? this._Parameters[3].Evaluate(Memory).valueCSTRING : ""; using (RecordReader reader = Source.OpenReader()) { using (StreamWriter writer = new StreamWriter(Path)) { string x = Source.Columns.ToNameString(Delim); writer.WriteLine(x); while (reader.CanAdvance) { Record r = reader.ReadNext(); string rec = Util.StringUtil.ToString(r, Delim, TextQ); writer.WriteLine(rec); } } } }
public virtual void EndInvokeChildren(SpoolSpace Memory) { foreach (Statement s in this._Children) { s.EndInvoke(Memory); } }
public void BurnBoundTables(SpoolSpace Memory) { foreach (string t in this._BoundTables) { Memory.Drop(t); } }
public void Execute(string Script) { // Create a token stream and do lexal analysis // AntlrInputStream TextStream = new AntlrInputStream(Script); S_ScriptLexer lex = new S_ScriptLexer(TextStream); // Parse the script // CommonTokenStream RyeTokenStream = new CommonTokenStream(lex); S_ScriptParser par = new S_ScriptParser(RyeTokenStream); // Create an executer object // StatementVisitor processor = new StatementVisitor(this.Host); // Create a spool space // SpoolSpace mem = this._Host.Spools; // Load the call stack and/or parse the errors foreach (S_ScriptParser.StatementContext ctx in par.compileUnit().statement()) { Statement stmt = processor.Render(ctx); stmt.BeginInvoke(mem); stmt.Invoke(mem); stmt.EndInvoke(mem); } }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell x = this._Children[0].Evaluate(Memory); return(CellFunctions.Sign(x)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); double pr = this._Children.Count == 1 ? this._Children[0].Evaluate(Memory).valueDOUBLE : 0.5; return(this._Source.NextBool(pr)); }
public override void BeginInvoke(SpoolSpace Memory) { if (this._Parameters.ContainsAggregate || this._Parameters.Count == 0) { throw new Exception("Generic table inserts cannot contain aggregate functions and must contain at least one expression"); } base.BeginInvoke(Memory); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); string Path = this._Children[0].Evaluate(Memory).valueCSTRING; string Name = this._Children[1].Evaluate(Memory).valueCSTRING; return(TableHeader.DeriveV1Path(Path, Name)); }
public void BindTables(SpoolSpace Memory) { foreach (Expression x in this._Parameters.AllTables) { Memory.Add(x.NameOf(), new Spool.RecordSpindle(x.NameOf(), x.Columns)); this._BoundTables.Add(x.NameOf()); } }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell x = this._Children[0].Evaluate(Memory); Cell y = this._Children[1].Evaluate(Memory); return(CellFunctions.Round(x, y.valueINT)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell x = this._Children[0].Evaluate(Memory); Cell y = this._Children[1].Evaluate(Memory); Cell z = this._Children[2].Evaluate(Memory); return(CellFunctions.ModPow(x, y, z)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell c = this._Children[0].Evaluate(Memory); Cell d = this._Children[1].Evaluate(Memory); CellAffinity a = (CellAffinity)d.BYTE; return(CellConverter.Cast(c, a)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell a = this._Children[0].Evaluate(Memory); Cell b = this._Children[1].Evaluate(Memory); int Start = (this._Children.Count == 2 ? 0 : this._Children[2].Evaluate(Memory).valueINT); return(CellFunctions.Position(a, b, Start)); }
protected void AddSpools(SpoolSpace Memory) { string lname = this._Parameters[0].NameOf(); Memory.Add(lname, new Spool.RecordSpindle(lname, this._Parameters[0].Columns)); string rname = this._Parameters[1].NameOf(); Memory.Add(rname, new Spool.RecordSpindle(rname, this._Parameters[1].Columns)); }
public override void Invoke(SpoolSpace Memory) { Statement x = this._Parent; while (x != null) { x.Raise(RaiseAlert.Exit); x = x._Parent; } }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell Length = this._Children[0].Evaluate(Memory); Cell Default = (this._Children.Count >= 2 ? this._Children[1].Evaluate(Memory) : CellValues.NullBOOL); CellArray x = CellArray.Vector(Length.valueINT, Default); return(new Cell(x)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); CellArray x = this._Children[0].Evaluate(Memory); CellArray y = this._Children[1].Evaluate(Memory); CellArray z = CellArray.Multiply(x, y); return(new Cell(z)); }
public virtual void InvokeChildren(SpoolSpace Memory) { foreach (Statement s in this._Children) { s.Invoke(Memory); if (this.RaiseElement == RaiseAlert.Break || this.RaiseElement == RaiseAlert.Return || this.RaiseElement == RaiseAlert.Exit) { break; } } }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); if (this._Children[0] is Expression.ArrayLiteral) { return(new Cell((this._Children[0] as Expression.ArrayLiteral).Children.Count)); } Cell x = this._Children[0].Evaluate(Memory); return(new Cell(x.Length)); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell x = this._Children[0].Evaluate(Memory); if (x.Affinity != CellAffinity.TREF) { return(CellValues.NullLONG); } return(this._Host.TableStore.RequestTable(x.valueTREF).RecordCount); }
public override Cell Evaluate(SpoolSpace Memory) { this.CheckParameters(); Cell RowCount = this._Children[0].Evaluate(Memory); Cell ColumnCount = this._Children[1].Evaluate(Memory); Cell Default = (this._Children.Count >= 3 ? this._Children[2].Evaluate(Memory) : CellValues.NullBOOL); CellArray x = CellArray.Matrix(RowCount.valueINT, ColumnCount.valueINT, Default); return(new Cell(x)); }
public override void Invoke(SpoolSpace Memory) { // Bind First this.Bind(Memory); // Invoke all this.InvokeChildren(Memory); Memory.Drop(this._Name); this.BurnBoundTables(Memory); }
public override void Invoke(SpoolSpace Memory) { Expression x = this._Parameters[0]; while (x.Evaluate(Memory).valueBOOL) { this.InvokeChildren(Memory); if (this.RaiseElement == RaiseAlert.Break || this.RaiseElement == RaiseAlert.Return || this.RaiseElement == RaiseAlert.Exit) { break; } } }