Написание интерпретатора на C #: лучший способ реализовать инструкции? - PullRequest
Новая
       41

Написание интерпретатора на C #: лучший способ реализовать инструкции?

2 голосов
/ 29 марта 2012

Я пишу интерпретатор языка ПЛК с использованием C #.Этот язык ПЛК содержит более 20 типов данных и 25 команд или около того.Как только я начал генерировать код, я уравновешивал два разных способа написания инструкций:

1) Каждый вид инструкций представлен в одном классе, который содержит большой switch для выбора типа данных.Пример: 

public class ADD : Instruction
{
    private string type;

    public ADD(string type)
    {
        this.type = type;
    }

    public bool Exec(Context c)
    {
        switch (type)
        {
            case "INT":
                short valor2 = c.PopINT();
                short valor = c.PopINT();
                short result = (short)(valor + valor2);
                c.PushINT(result);
                break;
            case "DINT":
                int valor4 = c.PopDINT();
                int valor3 = c.PopDINT();
                int result2 = (int)(valor4 + valor3);
                c.PushDINT(result2);
                break;
            case "BOOL":
                // Implement BOOL
                break;
            // Implement other types...
            default:
                break;
        }

        c.IP++;
        return false; ;
    }

}

2) Каждый класс представляет отдельную инструкцию с одним типом данных.Таким образом, избегайте больших switch.Пример: 

public class ADDi : Instruction
{
    public bool Exec(Context c)
    {
        short valor = c.PopINT();
        short valor2 = c.PopINT();
        short result = (short)(valor + valor2);
        c.PushINT(result);
        c.IP++;
        return false;
    }
}

Я использую шаблон команды COMMAND (Exec()) для написания инструкций.Я думаю, что второй вариант лучше, потому что избегает большого переключателя, но этот выбор предполагает написание более 400 инструкций.

Всегда имейте в виду, что в этом случае производительность выполнения важнее, чем производительность при переводе.1015 * Итак, мой точный вопрос заключается в следующем: есть ли другой способ разложить инструкции и типы данных?Я ищу меньшее количество инструкций без ущерба для производительности.

РЕДАКТИРОВАТЬ:

На этом рисунке показана моя иерархия типов:

Type hierarchy

Это реализация класса INT: 

public class INT : ANY_INT
{

    public override string DefaultInitValue()
    {
        return "0";
    }

    public override int GetBytes()
    {
        return 2;
    }

    public override string GetLastType()
    {
        return this.ToString();
    }

    public override string ToString()
    {
        return "INT";
    }

}

Некоторые классы являются более сложными (структуры, массивы, ...).

Операции Push и Pop определяются следующим образом: 

public void PushINT(short value)
{
    //SP -> Stack Pointer
    resMem.WriteINT(SP, value);
    SP += 2;
}

public short PopINT()
{
    SP -= 2;
    short value = resMem.ReadINT(SP);
    return value;
}

И, наконец, операции чтения и записи в память. 

public void WriteINT(int index, short entero)
{
    SetCapacity(index + 2); // Memory grows up dinamically
    memory[index] = (sbyte)((ushort)entero >> 8 & 0x00FF);
    memory[index + 1] = (sbyte)((ushort)entero >> 0 & 0x00FF);
}

public short ReadINT(int index)
{            
    return (short)(((short)(memory[index]) << 8 & 0xFF00) |
       ((short)(memory[index + 1]) & 0x00FF));
}

Надеюсь, эта информация поможет.Спасибо.

Ответы [ 2 ]

7 голосов
/ 29 марта 2012

Если вы можете изменить реализацию Context для поддержки универсальных типов (например, Pop<int> вместо PopINT()), вы можете использовать делегаты, чтобы упростить реализацию.

Дополнительно: 

var addInt = new MathInstruction<int>((a, b) => a + b));
var addDouble = new MathInstruction<double>((a, b) => a + b));
var addDecimal = new MathInstruction<decimal>((a, b) => a + b));

Вычитание 

var subtractInt = new MathInstruction<int>((a, b) => a - b));
var subtractDouble = new MathInstruction<double>((a, b) => a - b));
var subtractDecimal = new MathInstruction<decimal>((a, b) => a - b));

Отдел: 

var divideIntAsDouble = new MathInstruction<int, double>((a, b) => a / b));
var divideDouble = new MathInstruction<double>((a, b) => a / b));
var divideDecimal = new MathInstruction<decimal>((a, b) => a / b));

И преобразование между типами: 

var addIntAndDouble = new MathInstruction<int, double, double>((a, b) => a + b));

Это будет реализовано так: 

class MathInstruction<TA, TB, TResult> : Instruction
{
    private Func<TA, TB, TResult> callback;

    public MathInstruction(Func<TA, TB, TResult> callback) 
    {
        this.callback = callback;
    }

    public bool Exec(Context c)
    {
        var a = c.Pop<TA>();
        var b = c.Pop<TB>();
        var result = callback(a, b);
        c.Push<TResult>(result);
        return false;
    }
}

// Convenience
class MathInstruction<T, TResult> : MathInstruction<T, T, TResult>
class MathInstruction<T> : MathInstruction<T, T, T>

Я представляю, что в вашем контексте просто есть Stack<object> и PopINT, PopBOOL и т. Д., Просто добавьте аргумент и приведите. В этом случае вы, вероятно, можете просто использовать: 

public T Pop<T>()
{
    var o = stack.Pop();
    return Convert.ChangeType(o, typeof(T));
} 

public void Push<T>(T item)
{
    stack.Push(item);
}

Обратите внимание, что это также может обрабатывать ваши логические операторы - например: 

var logicalAnd = new MathInstruction<bool>((a, b) => a && b);
var logicalOr = new MathInstruction<bool>((a, b) => a || b);
2 голосов
/ 29 марта 2012

Не могли бы вы использовать наследование?Я видел бы умную комбинацию наследования, касающуюся типов данных, а затем шаблон стратегии, чтобы делегировать выполнение соответствующим объектам.

Но тогда нам действительно нужно увидеть диаграмму классов, чтобы помочь вам.

Просто не забудьте запрограммировать интерфейс, а не тип, а также, что состав более мощный, чем наследование.Я надеюсь, что это может помочь вам.

...