public override Expression Deserialize() { return(YacqExpression.Macro( this.Body.Deserialize(), this.Parameters.SelectAll(p => p.Deserialize <AmbiguousParameterExpression>()) )); }
public ReplWindow() { this.Width = 450; this.Height = 350; this.Title = "YACQ Console"; this.Content = this.textBox; this.textBox.AcceptsReturn = true; this.textBox.BorderThickness = new Thickness(0); this.textBox.FontFamily = new FontFamily("Consolas"); this.textBox.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled; this.textBox.VerticalScrollBarVisibility = ScrollBarVisibility.Visible; this.textBox.TextWrapping = TextWrapping.Wrap; this.textBox.Text = string.Format("YACQ {0} on Krile {1}\r\n", YacqServices.Version, typeof(App).Assembly.GetName().Version); this.textBox.Select(this.textBox.Text.Length, 0); this.textBox.PreviewKeyDown += this.textBox_PreviewKeyDown; this.symbolTable = new SymbolTable(YacqFilter.FilterSymbols, typeof(Symbols)) { { "*textbox*", YacqExpression.Constant(textBox) }, }; var rcPath = Path.Combine( Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "yacq_lib\\rc.yacq" ); if (File.Exists(rcPath)) { YacqServices.ParseAll(this.symbolTable, File.ReadAllText(rcPath)) .ForEach(e => YacqExpression.Lambda(e).Compile().DynamicInvoke()); this.textBox.AppendText("rc.yacq was loaded.\r\n"); } this.textBox.AppendText(">>> "); }
public override DynamicMetaObject FallbackSetIndex(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion) { try { return(new DynamicMetaObject( YacqExpression.Function(this._symbols, "=", YacqExpression.Function(this._symbols, ".", target.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType), YacqExpression.Vector(this._symbols, indexes.SelectAll(o => o.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType)) ) ), value.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType) ).Reduce(this._symbols).TryConvert(typeof(Object)), target.Restrictions )); } catch (Exception ex) { return(errorSuggestion ?? new DynamicMetaObject( Expression.Throw(Expression.Constant(ex), typeof(Object)), BindingRestrictions.Empty )); } }
public override Expression Deserialize() { return(YacqExpression.Text( this.QuoteChar, this.SourceText )); }
public override Expression Deserialize() { return(YacqExpression.AmbiguousParameter( this.Type.Null(t => t.Deserialize()), this.Name )); }
public override Expression Deserialize() { return(YacqExpression.Contextful( this.Expression.Deserialize(), this.ContextType )); }
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) { try { return(new DynamicMetaObject( (Static.GetTargetType(target.Value) .Null(t => YacqExpression.TypeCandidate(this._symbols, t)) ?? target.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType) ) .Method(this._symbols, this.Name, args.SelectAll(o => o.Expression.Reduce(this._symbols).TryConvert(o.RuntimeType)) ) .Reduce(this._symbols) .If(e => e.Type == typeof(void), e => Expression.Block(e, Expression.Default(typeof(Object))) ) .If(e => e.Type.IsValueType, e => e.TryConvert(typeof(Object)) ), target.Restrictions )); } catch (Exception ex) { return(errorSuggestion ?? new DynamicMetaObject( Expression.Throw(Expression.Constant(ex), typeof(Object)), BindingRestrictions.Empty )); } }
public override Expression Deserialize() { return(YacqExpression.AmbiguousLambda( this.ReturnType.Null(t => t.Deserialize()), this.Bodies.Select(n => n.Deserialize()), this.Parameters.SelectAll(p => p.Deserialize <AmbiguousParameterExpression>()) )); }
public static Expression Clear(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.Dispatch( s, DispatchTypes.Method, s.Resolve("*textbox*"), "Clear" )); }
/// <summary> /// Defines a new auto-implemented property to the type. /// </summary> /// <param name="name">The name of the property. <paramref name="name"/> cannot contain embedded nulls.</param> /// <param name="type">The type of the property.</param> /// <param name="methodAttributes">A bitwise combination of the accessor method attributes.</param> /// <param name="initializer">The expression which is not reduced to be <see cref="LambdaExpression"/> for the initializer of the backing field, with a parameter for "this" instance, returns <paramref name="type"/> value.</param> /// <returns>The defined property.</returns> public PropertyBuilder DefineProperty( String name, Type type, MethodAttributes methodAttributes, Expression initializer ) { return(this.DefineProperty(name, type, methodAttributes, initializer, YacqExpression.List(), YacqExpression.List())); }
public static Expression DumpObject(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.TypeCandidate(typeof(JsonConvert)) .Method(s, "SerializeObject", e.Left, Expression.Constant(Formatting.None), SerializerSettings )); }
public override Expression Deserialize() { return(YacqExpression.Dispatch( this.DispatchType, this.Left.Null(n => Deserialize()), this.Name, this.TypeArguments.SelectAll(t => t.Deserialize()), this.Arguments.SelectAll(n => n.Deserialize()) )); }
public static Expression Write(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.Dispatch( s, DispatchTypes.Method, s.Resolve("*textbox*"), "AppendText", YacqExpression.Dispatch( s, DispatchTypes.Method, e.Left, "ToString" ) )); }
internal static SymbolTable CreatePathSymbols(SymbolTable symbols, IEnumerable <String> fragments) { return(((SymbolTableExpression)EnumerableEx.Generate( Tuple.Create(fragments, symbols.ResolveModule()), _ => _.Item1.Any(), _ => Tuple.Create(_.Item1.Skip(1), _.Item1.First() .Let(f => _.Item2.ExistsKey(f) && _.Item2.Resolve(f) is SymbolTableExpression ? ((SymbolTableExpression)_.Item2.Resolve(f)).Symbols : new SymbolTable().Apply( s => s.MarkAsModule(), s => _.Item2[f] = YacqExpression.SymbolTable(s) ) )), _ => _.Item2 ).Last().Resolve(fragments.Last())).Symbols); }
public void Run() { this.Output = ""; Observable.Start(() => { try { this.WriteOutput("Started."); var expr = YacqServices.Parse( new SymbolTable() { { DispatchTypes.Method, typeof(Object), "print", (e, s, t) => YacqExpression.Dispatch( s, DispatchTypes.Method, Expression.Constant(this), "Print", e.Left ) }, }, this.Body ); this.WriteOutput("Parsed.\nGenerated Expression:\n" + expr); var func = Expression.Lambda(expr).Compile(); this.WriteOutput("Compiled."); var ret = func.DynamicInvoke(); this.WriteOutput("Finished.\nReturned Type: " + (ret != null ? ret.GetType().Name : "null")); if (ret != null) { this.Output += "Returned Value:\n" + (ret is IEnumerable && !(ret is String) ? String.Join(", ", ((IEnumerable)ret).OfType <Object>().Select(e => e.ToString())) : ret ); } } catch (Exception ex) { this.WriteOutput(ex.ToString()); } }).Subscribe(_ => { }); }
public static Expression Missing(DispatchExpression e, SymbolTable s, Type t) { Type type; if (e.DispatchType == DispatchTypes.Method && !s.ExistsKey(DispatchTypes.Method, e.Name) && (type = FilterRegistrant.GetFilter(e.Name).FirstOrDefault()) != null ) { return(YacqExpression.Dispatch( s, DispatchTypes.Constructor, YacqExpression.TypeCandidate(type), null, e.Arguments ) .Method(s, "Filter", YacqExpression.Identifier(s, "it"))); } return(DispatchExpression.DefaultMissing(e, s, t)); }
public override DynamicMetaObject FallbackUnaryOperation(DynamicMetaObject target, DynamicMetaObject errorSuggestion) { try { return(new DynamicMetaObject( YacqExpression.Function(this._symbols, GetSymbolName(this.Operation), target.Expression.Reduce(_symbols).TryConvert(target.RuntimeType) ).Reduce(this._symbols).TryConvert(typeof(Object)), target.Restrictions )); } catch (Exception ex) { return(errorSuggestion ?? new DynamicMetaObject( Expression.Throw(Expression.Constant(ex), typeof(Object)), BindingRestrictions.Empty )); } }
public static Expression WriteLine(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.Dispatch( s, DispatchTypes.Method, YacqExpression.Dispatch( s, DispatchTypes.Method, "+", YacqExpression.Dispatch( s, DispatchTypes.Method, e.Left, "ToString" ), Expression.Constant("\n") ), "printn" )); }
public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion) { try { return(new DynamicMetaObject( YacqExpression.List(this._symbols, args.SelectAll(o => o.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType)) .StartWith(target.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType)) ).Reduce(this._symbols).TryConvert(typeof(Object)), target.Restrictions )); } catch (Exception ex) { return(errorSuggestion ?? new DynamicMetaObject( Expression.Throw(Expression.Constant(ex), typeof(Object)), BindingRestrictions.Empty )); } }
public static Expression Tab(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.TypeCandidate(typeof(Setting)) .Member(s, "Instance") .Member(s, "StateProperty") .Member(s, "TabInformations") .Method(s, "SelectMany", YacqExpression.Function(s, "\\", YacqExpression.Vector(s, YacqExpression.Identifier(s, "e")), YacqExpression.Identifier(s, "e") ) ) .Method(s, "First", YacqExpression.LambdaList(s, YacqExpression.Identifier(s, "=="), YacqExpression.Identifier(s, "$0").Member(s, "Name"), e.Arguments[0] ) ) .Member(s, "TweetSources") .Method(s, "Single")); }
/// <summary> /// Creates a <see cref="Type"/> object for the type. After defining members on the type, this method is called in order to load its Type object. /// </summary> /// <param name="symbols">The additional symbol table for reducing.</param> /// <returns>The new Type object for this type.</returns> public Type Create(SymbolTable symbols = null) { if (this.IsCreated) { return(this._type.CreateType()); } if (this.GetConstructors().IsEmpty()) { this.DefineConstructor(null); } if (this._cctor != null) { this._cctor.Null(c => c.GetILGenerator().Emit(OpCodes.Ret)); } return(this._type.CreateType() .Apply( t => this._initializers.ForEach(_ => new SymbolTable(symbols) { { "this", YacqExpression.TypeCandidate(t) }, } .Let(s => _.Item2.Reduce(s, _.Item3.ReplaceGenericArguments( new Dictionary <Type, Type>() { { this._type, t }, } )) .Apply(e => (e != null ? (LambdaExpression)e : Expression.Lambda(_.Item2.Reduce(s)) ).CompileToMethod(_.Item1)) ) ), t => this._prologue.GetILGenerator().Emit(OpCodes.Ret), t => this._implType.CreateType(), t => this.IsCreated = true )); }
public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion) { try { return(new DynamicMetaObject( YacqExpression.Function(this._symbols, "=", (Static.GetTargetType(target.Value) .Null(t => YacqExpression.TypeCandidate(this._symbols, t)) ?? target.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType) ).Member(this._symbols, this.Name), value.Expression.Reduce(this._symbols).TryConvert(target.RuntimeType) ).Reduce(this._symbols).TryConvert(typeof(Object)), target.Restrictions )); } catch (Exception ex) { return(errorSuggestion ?? new DynamicMetaObject( Expression.Throw(Expression.Constant(ex), typeof(Object)), BindingRestrictions.Empty )); } }
public override Expression Deserialize() { return(YacqExpression.Identifier( this.Name )); }
public override Expression Deserialize() { return(YacqExpression.TypeCandidate( this.Candidates.Select(t => t.Deserialize()) )); }
internal StandardGrammar() { this._isReadOnly = false; var newline = Combinator.Choice( Chars.Sequence("\r\n"), Chars.OneOf('\r', '\n', '\x85', '\u2028', '\u2029') .Select(EnumerableEx.Return) ).Select(_ => Environment.NewLine); var punctuation = Chars.OneOf('"', '\'', '(', ')', ',', '.', ':', ';', '[', ']', '`', '{', '}'); Parser <Char, YacqExpression> expressionRef = null; var expression = new Lazy <Parser <Char, YacqExpression> >( () => stream => expressionRef(stream) ); this.Add("yacq", "expression", g => expression.Value); // Comments { this.Add("comment", "eol", g => Prims.Pipe( ';'.Satisfy(), newline.Not().Right(Chars.Any()).Many(), newline.Ignore().Or(Chars.Eof()), (p, r, s) => (YacqExpression)YacqExpression.Ignore() )); Parser <Char, YacqExpression> blockCommentRef = null; Parser <Char, YacqExpression> blockCommentRestRef = null; var blockComment = new Lazy <Parser <Char, YacqExpression> >( () => stream => blockCommentRef(stream) ); var blockCommentRest = new Lazy <Parser <Char, YacqExpression> >( () => stream => blockCommentRestRef(stream) ); var blockCommentPrefix = Chars.Sequence("#|"); var blockCommentSuffix = Chars.Sequence("|#"); blockCommentRef = blockCommentPrefix .Right(blockCommentRest.Value.Many()) .Left(blockCommentSuffix) .Select(_ => (YacqExpression)YacqExpression.Ignore()); blockCommentRestRef = blockCommentPrefix.Not() .Right(blockCommentSuffix.Not()) .Right(Chars.Any()) .Select(_ => (YacqExpression)YacqExpression.Ignore()) .Or(blockComment.Value); this.Add("comment", "block", g => blockComment.Value); this.Add("comment", "expression", g => Prims.Pipe( Chars.Sequence("#;"), g["yacq", "expression"], (p, r) => (YacqExpression)YacqExpression.Ignore() )); this.Add("yacq", "comment", g => Combinator.Choice(g["comment"])); } this.Add("yacq", "ignore", g => Combinator.Choice( this.Get["yacq", "comment"].Ignore(), Chars.Space().Ignore(), newline.Ignore() ).Many().Select(_ => (YacqExpression)YacqExpression.Ignore())); // Texts this.Add("term", "text", g => SetPosition( Chars.OneOf('\'', '\"', '`') .SelectMany(q => q.Satisfy() .Not() .Right('\\'.Satisfy() .Right(q.Satisfy()) .Or(Chars.Any()) ) .Many() .Left(q.Satisfy()) .Select(cs => cs.StartWith(q).EndWith(q)) ) .Select(cs => (YacqExpression)YacqExpression.Text(new String(cs.ToArray()))) )); // Numbers { var numberPrefix = Chars.OneOf('+', '-'); var numberSuffix = Combinator.Choice( Chars.Sequence("ul"), Chars.Sequence("UL"), Chars.OneOf('D', 'F', 'L', 'M', 'U', 'd', 'f', 'l', 'm', 'u') .Select(EnumerableEx.Return) ); var digit = '_'.Satisfy().Many().Right(Chars.Digit()); var hexPrefix = Chars.Sequence("0x"); var hex = '_'.Satisfy().Many().Right(Chars.Hex()); var octPrefix = Chars.Sequence("0o"); var oct = '_'.Satisfy().Many().Right(Chars.Oct()); var binPrefix = Chars.Sequence("0b"); var bin = '_'.Satisfy().Many().Right(Chars.OneOf('0', '1')); var fraction = Prims.Pipe( '.'.Satisfy(), digit.Many(1), (d, ds) => ds.StartWith(d) ); var exponent = Prims.Pipe( Chars.OneOf('E', 'e'), Chars.OneOf('+', '-').Maybe(), digit.Many(1), (e, s, ds) => ds .If(_ => s.Exists(), _ => _.StartWith(s.Perform())) .StartWith(e) ); this.Add("term", "number", g => Combinator.Choice( SetPosition(Prims.Pipe( binPrefix, bin.Many(1), numberSuffix.Maybe(), (p, n, s) => (YacqExpression)YacqExpression.Number( new String(p.Concat(n).If( _ => s.Exists(), cs => cs.Concat(s.Perform()) ).ToArray()) ) )), SetPosition(Prims.Pipe( octPrefix, oct.Many(1), numberSuffix.Maybe(), (p, n, s) => (YacqExpression)YacqExpression.Number( new String(p.Concat(n).If( _ => s.Exists(), cs => cs.Concat(s.Perform()) ).ToArray()) ) )), SetPosition(Prims.Pipe( hexPrefix, hex.Many(1), numberSuffix.Maybe(), (p, n, s) => (YacqExpression)YacqExpression.Number( new String(p.Concat(n).If( _ => s.Exists(), cs => cs.Concat(s.Perform()) ).ToArray()) ) )), SetPosition( numberPrefix.Maybe().SelectMany(p => digit.Many(1).SelectMany(i => fraction.Maybe().SelectMany(f => exponent.Maybe().SelectMany(e => numberSuffix.Maybe().Select(s => (YacqExpression)YacqExpression.Number(new String(EnumerableEx.Concat( i.If(_ => p.Exists(), _ => _.StartWith(p.Perform())), f.Otherwise(Enumerable.Empty <Char>), e.Otherwise(Enumerable.Empty <Char>), s.Otherwise(Enumerable.Empty <Char>) ).ToArray())) ) ) ) ) ) ) )); } // Lists this.Add("term", "list", g => SetPosition( g["yacq", "expression"] .Between(g["yacq", "ignore"], g["yacq", "ignore"]) .Many() .Between('('.Satisfy(), ')'.Satisfy()) .Select(es => (YacqExpression)YacqExpression.List(es)) )); // Vectors this.Add("term", "vector", g => SetPosition( g["yacq", "expression"] .Between(g["yacq", "ignore"], g["yacq", "ignore"]) .Many() .Between('['.Satisfy(), ']'.Satisfy()) .Select(es => (YacqExpression)YacqExpression.Vector(es)) )); // Lambda Lists this.Add("term", "lambdaList", g => SetPosition( g["yacq", "expression"] .Between(g["yacq", "ignore"], g["yacq", "ignore"]) .Many() .Between('{'.Satisfy(), '}'.Satisfy()) .Select(es => (YacqExpression)YacqExpression.LambdaList(es)) )); // Quotes this.Add("term", "quote", g => SetPosition( Prims.Pipe( Chars.Sequence("#'"), g["yacq", "expression"], (p, e) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier("quote"), e) ) )); // Quasiquotes this.Add("term", "quasiquote", g => SetPosition( Prims.Pipe( Chars.Sequence("#`"), g["yacq", "expression"], (p, e) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier("quasiquote"), e) ) )); // Unquote-Splicings this.Add("term", "unquoteSplicing", g => SetPosition( Prims.Pipe( Chars.Sequence("#,@"), g["yacq", "expression"], (p, e) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier("unquote-splicing"), e) ) )); // Unquotes this.Add("term", "unquote", g => SetPosition( Prims.Pipe( Chars.Sequence("#,"), g["yacq", "expression"], (p, e) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier("unquote"), e) ) )); // Identifiers this.Add("term", "identifier", g => Combinator.Choice( SetPosition('.'.Satisfy() .Many(1) .Select(cs => (YacqExpression)YacqExpression.Identifier(new String(cs.ToArray()))) ), SetPosition(':'.Satisfy() .Many(1) .Select(cs => (YacqExpression)YacqExpression.Identifier(new String(cs.ToArray()))) ), SetPosition(Chars.Digit() .Not() .Right(Chars.Space() .Or(punctuation) .Not() .Right(Chars.Any()) .Many(1) ) .Select(cs => (YacqExpression)YacqExpression.Identifier(new String(cs.ToArray()))) ) )); // Terms this.Add("yacq", "term", g => Combinator.Choice(g["term"]) .Between(g["yacq", "ignore"], g["yacq", "ignore"]) ); // Infix Dots this.Add("infix", "dot", g => Prims.Pipe( g["yacq", "term"], '.'.Satisfy() .Right(g["yacq", "term"]) .Many(), (h, t) => t.Aggregate(h, (l, r) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier("."), l, r) ) )); // Infix Colons this.Add("infix", "colon", g => Prims.Pipe( g["infix", "dot"], ':'.Satisfy() .Right(g["infix", "dot"]) .Many(), (h, t) => t.Aggregate(h, (l, r) => (YacqExpression)YacqExpression.List(YacqExpression.Identifier(":"), l, r) ) )); expressionRef = this.Get["infix"].Last(); this.Set.Default = g => g["yacq", "expression"]; this._isReadOnly = true; }
public static Expression RangeFromTo(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.TypeCandidate(typeof(LongRange)) .Method(s, "FromBetweenValues", e.Left, e.Arguments[0])); }
public static Expression RangeExact(DispatchExpression e, SymbolTable s, Type t) { return(YacqExpression.TypeCandidate(typeof(LongRange)) .Method(s, "FromPivotValue", e.Arguments[0])); }
public override Expression Deserialize() { return(YacqExpression.Quote( this.Expression.Deserialize() )); }
public override Expression Deserialize() { return(YacqExpression.LambdaList( this.Elements.Null(_ => _.Select(n => n.Deserialize())) )); }
public override Expression Deserialize() { return(YacqExpression.Ignore()); }