c# - 在 C# 中使用运算符构建自定义表达式树

Question

这个问题是关于使用 C#(或任何其他语言)中的运算符在 .NET 中构建自定义表达式树。我提供了问题以及一些背景信息。

---

对于我的 managed 2-phase 64-bit assembler我需要对表达式的支持。例如，一个人可能想要组装:

mystring: DB 'hello, world'
          TIMES 64-$+mystring DB ' '

表达式 64-$+mystring 不能是一个字符串，而是一个实际有效的表达式，具有语法和类型检查以及 VS 中的 IntelliSense 的优点，类似于:

64 - Reference.CurrentOffset + new Reference("mystring");

此表达式在构造时不会求值。相反，它稍后在我的汇编程序的上下文中进行评估(当它确定符号偏移等时)。 .NET 框架(自 .NET 3.5 起)提供了对表达式树的支持，在我看来，它非常适合这种稍后或在其他地方求值的表达式。

但我不知道如何确保可以使用C# 语法(使用+、<<、% 等)构建表达式树。我想防止这样的事情:

var expression = AssemblerExpression.Subtract(64,
    AssemblerExpression.Add(AssemblerExpression.CurrentOffset(),
        AssemblerExpression.Reference("mystring")))

你会怎么做？

---

注意:我需要一个表达式树来将表达式转换为可接受的自定义字符串表示形式，同时能够在定义时以外的时间点对其求值。

---

我的示例的解释:64-$+mystring。 $ 是当前偏移量，因此它是一个事先未知的特定数字(但在评估时已知)。 mystring 是一个符号，在评估时可能知道也可能不知道(例如，当它尚未定义时)。从符号 S 中减去常量 C 与 S + -C 相同。减去两个符号 S0 和 S1 (S1 - S0) 得到两个符号值之间的整数差。

但是，这个问题实际上不是关于如何评估汇编程序表达式，而是关于如何评估其中包含自定义类的任何表达式(例如符号和 $ 在示例中)以及如何仍然确保它可以使用一些访问者进行 pretty-print (从而保留树)。由于 .NET 框架有其表达式树和访问者，如果可能的话，最好使用它们。

Answer 1

我不知道您的具体目标是什么，但以下是一些我认为可行的粗略方法。

注意我

1. 仅演示索引引用表达式(因此暂时忽略通过寄存器的间接寻址；您可以添加一个类似于 SymbolicReference 类的 RegisterInderectReference)。这也适用于您建议的 $ (当前偏移量)功能。它可能肯定是一个寄存器(？)
2. 也没有明确显示一元/二元 operator- 的作用。然而，机制在很大程度上是相同的。我没有添加它，因为我无法计算出您问题中示例表达式的语义
   _{(我认为减去已知字符串的地址是没有用，例如)}
3. 该方法没有设置(语义)限制:您可以抵消任何 ReferenceBase 派生的 IReference。实际上，您可能只想允许一级索引，直接在 SymbolicReference 上定义 operator+ 会更合适。

4. 为了演示目的牺牲了编码风格(一般来说，您不希望重复 Compile() 您的表达式树，并直接使用 .Compile()( ) 看起来丑陋且令人困惑。由 OP 以更易读的方式集成它

5. 显式转换运算符的演示真是跑题了。我有点忘乎所以了(？)

6. 可以观察代码 running live on IdeOne.com

.

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Linq;


namespace Assembler
{
    internal class State
    {
        public readonly IDictionary<string, ulong> SymbolTable = new Dictionary<string, ulong>();

        public void Clear() 
        {
            SymbolTable.Clear();
        }
    }

    internal interface IReference
    {
        ulong EvalAddress(State s); // evaluate reference to address
    }

    internal abstract class ReferenceBase : IReference
    {
        public static IndexedReference operator+(long directOffset, ReferenceBase baseRef) { return new IndexedReference(baseRef, directOffset); }
        public static IndexedReference operator+(ReferenceBase baseRef, long directOffset) { return new IndexedReference(baseRef, directOffset); }

        public abstract ulong EvalAddress(State s);
    }

    internal class SymbolicReference : ReferenceBase
    {
        public static explicit operator SymbolicReference(string symbol)    { return new SymbolicReference(symbol); }
        public SymbolicReference(string symbol) { _symbol = symbol; }

        private readonly string _symbol;

        public override ulong EvalAddress(State s) 
        {
            return s.SymbolTable[_symbol];
        }

        public override string ToString() { return string.Format("Sym({0})", _symbol); }
    }

    internal class IndexedReference : ReferenceBase
    {
        public IndexedReference(IReference baseRef, long directOffset) 
        {
            _baseRef = baseRef;
            _directOffset = directOffset;
        }

        private readonly IReference _baseRef;
        private readonly long _directOffset;

        public override ulong EvalAddress(State s) 
        {
            return (_directOffset<0)
                ? _baseRef.EvalAddress(s) - (ulong) Math.Abs(_directOffset)
                : _baseRef.EvalAddress(s) + (ulong) Math.Abs(_directOffset);
        }

        public override string ToString() { return string.Format("{0} + {1}", _directOffset, _baseRef); }
    }
}

namespace Program
{
    using Assembler;

    public static class Program
    {
        public static void Main(string[] args)
        {
            var myBaseRef1 = new SymbolicReference("mystring1");

            Expression<Func<IReference>> anyRefExpr = () => 64 + myBaseRef1;
            Console.WriteLine(anyRefExpr);

            var myBaseRef2 = (SymbolicReference) "mystring2"; // uses explicit conversion operator

            Expression<Func<IndexedReference>> indexedRefExpr = () => 64 + myBaseRef2;
            Console.WriteLine(indexedRefExpr);

            Console.WriteLine(Console.Out.NewLine + "=== show compiletime types of returned values:");
            Console.WriteLine("myBaseRef1     -> {0}", myBaseRef1);
            Console.WriteLine("myBaseRef2     -> {0}", myBaseRef2);
            Console.WriteLine("anyRefExpr     -> {0}", anyRefExpr.Compile().Method.ReturnType);
            Console.WriteLine("indexedRefExpr -> {0}", indexedRefExpr.Compile().Method.ReturnType);

            Console.WriteLine(Console.Out.NewLine + "=== show runtime types of returned values:");
            Console.WriteLine("myBaseRef1     -> {0}", myBaseRef1);
            Console.WriteLine("myBaseRef2     -> {0}", myBaseRef2);
            Console.WriteLine("anyRefExpr     -> {0}", anyRefExpr.Compile()());     // compile() returns Func<...>
            Console.WriteLine("indexedRefExpr -> {0}", indexedRefExpr.Compile()());

            Console.WriteLine(Console.Out.NewLine + "=== observe how you could add an evaluation model using some kind of symbol table:");
            var compilerState = new State();
            compilerState.SymbolTable.Add("mystring1", 0xdeadbeef); // raw addresses
            compilerState.SymbolTable.Add("mystring2", 0xfeedface);

            Console.WriteLine("myBaseRef1 evaluates to     0x{0:x8}", myBaseRef1.EvalAddress(compilerState));
            Console.WriteLine("myBaseRef2 evaluates to     0x{0:x8}", myBaseRef2.EvalAddress(compilerState));
            Console.WriteLine("anyRefExpr displays as      {0:x8}",   anyRefExpr.Compile()());
            Console.WriteLine("indexedRefExpr displays as  {0:x8}",   indexedRefExpr.Compile()());
            Console.WriteLine("anyRefExpr evaluates to     0x{0:x8}", anyRefExpr.Compile()().EvalAddress(compilerState));
            Console.WriteLine("indexedRefExpr evaluates to 0x{0:x8}", indexedRefExpr.Compile()().EvalAddress(compilerState));
        }
    }
}