242 lines
8.6 KiB
C#
242 lines
8.6 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.Serialization;
|
|
|
|
namespace Cryville.Common.Pdt {
|
|
/// <summary>
|
|
/// Base of evaluator for PDT expressions.
|
|
/// </summary>
|
|
public abstract class PdtEvaluatorBase {
|
|
private struct StackFrame {
|
|
public int Offset;
|
|
public int Length;
|
|
public int Type;
|
|
}
|
|
int _framecount = 0;
|
|
int _goffset = 0;
|
|
readonly StackFrame[] _stack = new StackFrame[256];
|
|
readonly byte[] _mem = new byte[0x100000];
|
|
bool _revokepttconst;
|
|
LinkedListNode<PdtInstruction> _rip;
|
|
/// <summary>
|
|
/// Evaluates an expression and passes the result to a target operator.
|
|
/// </summary>
|
|
/// <param name="target">The target operator.</param>
|
|
/// <param name="exp">The expression to evaluate.</param>
|
|
public void Evaluate(PdtOperator target, PdtExpression exp) {
|
|
_framecount = 0;
|
|
_goffset = 0;
|
|
_revokepttconst = false;
|
|
for (_rip = exp.Instructions.First; _rip != null; _rip = _rip.Next)
|
|
_rip.Value.Execute(this);
|
|
Operate(target, _framecount, true);
|
|
if (exp.IsPotentialConstant) {
|
|
exp.IsConstant = exp.IsPotentialConstant = !_revokepttconst;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Patches an expression with a lefthand variable and a compound operator.
|
|
/// </summary>
|
|
/// <param name="target">The name of the lefthand variable.</param>
|
|
/// <param name="op">The name of the compound operator.</param>
|
|
/// <param name="exp">The expression.</param>
|
|
public void PatchCompound(int target, int op, PdtExpression exp) {
|
|
exp.Instructions.AddFirst(new PdtInstruction.PushVariable(target));
|
|
exp.Instructions.AddLast(new PdtInstruction.Operate(op, 2));
|
|
}
|
|
/// <summary>
|
|
/// Optimizes an expression by merging its instructions.
|
|
/// </summary>
|
|
/// <param name="exp">The expression to optimize.</param>
|
|
public void Optimize(PdtExpression exp) {
|
|
_framecount = 0;
|
|
_goffset = 0;
|
|
List<PdtInstruction.Collapse> ct;
|
|
var cols = new Dictionary<LinkedListNode<PdtInstruction>, List<PdtInstruction.Collapse>>();
|
|
var il = exp.Instructions;
|
|
for (_rip = il.First; _rip != null; _rip = _rip == null ? il.First : _rip.Next) {
|
|
var i = _rip.Value;
|
|
if (i is PdtInstruction.Operate) {
|
|
int fc0 = _framecount;
|
|
int fc1 = ((PdtInstruction.Operate)i).Signature.ParamCount;
|
|
try { i.Execute(this); } catch (Exception) { }
|
|
if (fc0 - _framecount == fc1) {
|
|
unsafe {
|
|
fixed (StackFrame* frame = &_stack[_framecount++]) {
|
|
frame->Type = PdtInternalType.Error;
|
|
frame->Offset = -1;
|
|
frame->Length = 0;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
var frame = _stack[_framecount - 1];
|
|
_rip = il.AddAfter(_rip, new PdtInstruction.PushConstant(frame.Type, _mem, frame.Offset, frame.Length));
|
|
for (var j = 0; j <= fc1; j++) il.Remove(_rip.Previous);
|
|
}
|
|
}
|
|
else if (i is PdtInstruction.Collapse) {
|
|
var t = (PdtInstruction.Collapse)i;
|
|
try {
|
|
var pins = _rip;
|
|
i.Execute(this);
|
|
if (_rip == pins) {
|
|
_rip = _rip.Next;
|
|
il.Remove(_rip.Previous);
|
|
il.Remove(_rip.Previous);
|
|
_rip = _rip.Previous;
|
|
}
|
|
else {
|
|
_rip = pins.Previous;
|
|
while (_rip.Next != t.Target) il.Remove(_rip.Next);
|
|
il.Remove(_rip.Next);
|
|
if (cols.TryGetValue(t.Target, out ct)) {
|
|
foreach (var u in ct) u.Target = _rip;
|
|
cols.Remove(t.Target);
|
|
cols.Add(_rip, ct);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception) {
|
|
if (cols.TryGetValue(t.Target, out ct)) ct.Add(t);
|
|
else cols.Add(t.Target, new List<PdtInstruction.Collapse> { t });
|
|
}
|
|
}
|
|
else if (i is PdtInstruction.PushVariable) {
|
|
i.Execute(this);
|
|
var frame = _stack[_framecount - 1];
|
|
if (frame.Type != PdtInternalType.Undefined && frame.Type != PdtInternalType.Error) {
|
|
_rip = il.AddAfter(_rip, new PdtInstruction.PushConstant(frame.Type, _mem, frame.Offset, frame.Length));
|
|
il.Remove(_rip.Previous);
|
|
}
|
|
}
|
|
else i.Execute(this);
|
|
if (_rip != null && cols.TryGetValue(_rip, out ct)) {
|
|
unsafe {
|
|
fixed (StackFrame* frame = &_stack[_framecount - 1]) {
|
|
frame->Type = PdtInternalType.Error;
|
|
frame->Offset = -1;
|
|
frame->Length = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exp.IsConstant = true;
|
|
exp.IsPotentialConstant = true;
|
|
for (var ins = il.First; ins != null; ins = ins.Next) {
|
|
if (!(ins.Value is PdtInstruction.PushConstant)) {
|
|
exp.IsConstant = false;
|
|
}
|
|
else if (!(ins.Value is PdtInstruction.PushVariable)) {
|
|
exp.IsPotentialConstant = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Revokes the potential constant mark of the current expression.
|
|
/// </summary>
|
|
protected void RevokePotentialConstant() {
|
|
_revokepttconst = true;
|
|
}
|
|
internal unsafe void PushConstant(int type, byte[] value) {
|
|
fixed (StackFrame* frame = &_stack[_framecount++]) {
|
|
frame->Type = type;
|
|
frame->Offset = _goffset;
|
|
frame->Length = value.Length;
|
|
Array.Copy(value, 0, _mem, _goffset, value.Length);
|
|
_goffset += value.Length;
|
|
}
|
|
}
|
|
internal unsafe void PushVariable(int name, bool forced) {
|
|
fixed (StackFrame* frame = &_stack[_framecount++]) {
|
|
byte[] value;
|
|
GetVariable(name, forced, out frame->Type, out value);
|
|
frame->Offset = _goffset;
|
|
frame->Length = value.Length;
|
|
Array.Copy(value, 0, _mem, _goffset, value.Length);
|
|
_goffset += value.Length;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets a variable of the specified name.
|
|
/// </summary>
|
|
/// <param name="name">The name of the variable.</param>
|
|
/// <param name="forced">Whether to produce an error stack instead of an identifier stack if the variable is not found.</param>
|
|
/// <param name="type">The type of the variable.</param>
|
|
/// <param name="value">The value of the variable.</param>
|
|
protected abstract void GetVariable(int name, bool forced, out int type, out byte[] value);
|
|
internal void Operate(PdtOperatorSignature sig) {
|
|
PdtOperator op;
|
|
try { op = GetOperator(sig); }
|
|
catch (Exception ex) {
|
|
for (int i = 0; i < sig.ParamCount; i++)
|
|
DiscardStack();
|
|
throw new EvaluationFailureException(string.Format("Failed to get operator {0}", sig), ex);
|
|
}
|
|
Operate(op, sig.ParamCount);
|
|
}
|
|
/// <summary>
|
|
/// Gets an operator of the specified name and the suggested parameter count.
|
|
/// </summary>
|
|
/// <param name="name">The name of the operator.</param>
|
|
/// <param name="pc">Suggested parameter count.</param>
|
|
/// <returns>An operator of the specific name.</returns>
|
|
/// <remarks>The parameter count of the returned operator does not necessarily equal to <paramref name="pc" />.</remarks>
|
|
protected abstract PdtOperator GetOperator(PdtOperatorSignature sig);
|
|
unsafe void Operate(PdtOperator op, int pc, bool noset = false) {
|
|
fixed (byte* pmem = _mem) {
|
|
op.Begin(this, pc);
|
|
for (int i = 0; i < pc; i++) {
|
|
var frame = _stack[--_framecount];
|
|
op.LoadOperand(new PdtVariableMemory(frame.Type, pmem + frame.Offset, frame.Length));
|
|
_goffset -= frame.Length;
|
|
}
|
|
op.Call(pmem + _goffset, noset);
|
|
}
|
|
}
|
|
internal unsafe void Collapse(int name, LinkedListNode<PdtInstruction> target) {
|
|
fixed (byte* pmem = _mem) {
|
|
var frame = _stack[--_framecount];
|
|
if (Collapse(name, new PdtVariableMemory(frame.Type, pmem + frame.Offset, frame.Length))) {
|
|
_framecount++;
|
|
_rip = target;
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Gets whether to jump to the target of a collapse instruction.
|
|
/// </summary>
|
|
/// <param name="name">The name of the collapse operator.</param>
|
|
/// <param name="param">The top frame in the stack as the parameter.</param>
|
|
/// <returns>Whether to jump to the target of the collapse instruction.</returns>
|
|
protected abstract bool Collapse(int name, PdtVariableMemory param);
|
|
internal unsafe PdtVariableMemory StackAlloc(int type, byte* ptr, int len) {
|
|
fixed (StackFrame* frame = &_stack[_framecount++]) {
|
|
frame->Type = type;
|
|
frame->Offset = _goffset;
|
|
frame->Length = len;
|
|
_goffset += len;
|
|
return new PdtVariableMemory(type, ptr, len);
|
|
}
|
|
}
|
|
internal void DiscardStack() {
|
|
_goffset -= _stack[--_framecount].Length;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The exception that is thrown when the evalution of a <see cref="PdtExpression" /> fails.
|
|
/// </summary>
|
|
public class EvaluationFailureException : Exception {
|
|
/// <inheritdoc />
|
|
public EvaluationFailureException() : base("Evaluation failed") { }
|
|
/// <inheritdoc />
|
|
public EvaluationFailureException(string message) : base(message) { }
|
|
/// <inheritdoc />
|
|
public EvaluationFailureException(string message, Exception innerException) : base(message, innerException) { }
|
|
/// <inheritdoc />
|
|
protected EvaluationFailureException(SerializationInfo info, StreamingContext context) : base(info, context) { }
|
|
}
|
|
}
|