C# Symbols.SymbolTable类代码示例

 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(">>> ");
 }

 internal VectorExpression(
     SymbolTable symbols,
     YacqList elements
 )
     : base(symbols, elements)
 {
 }

 internal LambdaListExpression(
     SymbolTable symbols,
     YacqList elements
 )
     : base(symbols, elements)
 {
 }

 internal IdentifierExpression(
     SymbolTable symbols,
     String name
 )
     : base(symbols)
 {
     this.Name = name;
 }

 internal TypeCandidateExpression(
     SymbolTable symbols,
     IList<Type> candidates
 )
     : base(symbols)
 {
     this.Candidates = new ReadOnlyCollection<Type>(candidates ?? Type.EmptyTypes);
 }

 internal SerializedExpression(
     SymbolTable symbols,
     Node node
 )
     : base(symbols)
 {
     this.Node = node;
 }

 public static Expression Clear(DispatchExpression e, SymbolTable s, Type t)
 {
     return YacqExpression.Dispatch(
         s,
         DispatchTypes.Method,
         s.Resolve("*textbox*"),
         "Clear"
     );
 }

 internal NumberExpression(
     SymbolTable symbols,
     String text
 )
     : base(symbols)
 {
     this.SourceText = text;
     this.Value = this.Parse();
 }

 internal AmbiguousParameterExpression(
     SymbolTable symbols,
     Type type,
     String name
 )
     : base(symbols)
 {
     this._type = type;
     this.Name = name;
 }

 internal QuotedExpression(
     SymbolTable symbols,
     QuoteType quoteType,
     Expression expression
 )
     : base(symbols)
 {
     this.QuoteType = quoteType;
     this.Expression = expression ?? Empty();
     this.SetPosition(this.Expression);
 }

 internal ContextfulExpression(
     SymbolTable symbols,
     Expression expression,
     ContextType contextType
 )
     : base(symbols)
 {
     this.Expression = expression;
     this.ContextType = contextType;
     this.SetPosition(expression);
 }

 internal MacroExpression(SymbolTable symbols, Expression body, IList<AmbiguousParameterExpression> parameters)
     : base(symbols)
 {
     if (parameters.Any(p => p.Type(symbols) != null && !typeof(Expression).IsAppropriate(p.Type)))
     {
         throw new ArgumentException("All parameters of macro must be Expression", "parameters");
     }
     this.Parameters = new ReadOnlyCollection<AmbiguousParameterExpression>(parameters ?? Arrays.Empty<AmbiguousParameterExpression>());
     this.Body = body ?? Empty();
     this.SetPosition(this.Parameters.EndWith(this.Body));
 }

 internal TextExpression(
     SymbolTable symbols,
     Char quoteChar,
     String sourceText
 )
     : base(symbols)
 {
     this._codes = new List<String>();
     this.QuoteChar = quoteChar;
     this.SourceText = sourceText ?? "";
     this.Value = this.Parse();
 }

 /// <summary>
 /// Reduces this node to a simpler expression with additional symbol tables.
 /// </summary>
 /// <param name="symbols">The additional symbol table for reducing.</param>
 /// <param name="expectedType">The type which is expected as the type of reduced expression.</param>
 /// <returns>The reduced expression.</returns>
 protected override Expression ReduceImpl(SymbolTable symbols, Type expectedType)
 {
     if (symbols.ResolveMatch(DispatchTypes.Member, this.Name) != null
         || symbols.Missing != DispatchExpression.DefaultMissing
     )
     {
         return Variable(symbols, this.Name)
             .ReduceOnce(symbols, expectedType)
             .Let(e => (e as MacroExpression).Null(m => m.Evaluate(symbols)) ?? e);
     }
     else
     {
         throw new ParseException("Identifier evaluation failed: " + this, this);
     }
 }

 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"
         )
     );
 }