/// <summary>
/// Backtracks to the current choice point
/// </summary>
public void BacktrackToChoicePoint()
{
// Restore the environment permanent variables
if (!ReferenceEquals(_choicePoint.Environment, _environment))
{
for (var varIndex = 0; varIndex < _choicePoint.Environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = _choicePoint.Environment.Variables[varIndex];
}
for (var varIndex = _choicePoint.Environment.Variables.Length; varIndex < _environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = new SimpleReference();
}
}
// Restore the argument registers
var argumentIndex = _choicePoint.Environment.Variables.Length;
foreach (var argument in _choicePoint.Arguments)
{
_registers[argumentIndex].SetTo(argument);
++argumentIndex;
}
// Environment is reset to the choice point environment
_environment = _choicePoint.Environment;
// Reset the trail
_choicePoint.Trail.Reset();
_trail = _choicePoint.Trail;
}
public ChoicePoint(ChoicePoint previousChoice, ByteCodeEnvironment environment, IEnumerable<IReferenceLiteral> arguments, ITrail trail, int nextClause)
{
if (arguments == null) throw new ArgumentNullException(nameof(arguments));
if (trail == null) throw new ArgumentNullException(nameof(trail));
_previousChoicePoint = previousChoice;
_arguments = arguments.Select(arg => new SimpleReference(arg)).ToArray();
_trail = trail;
_nextClause = nextClause;
_environment = environment;
}
public ByteCodeEnvironment(int numVariables, int numArguments, ByteCodeEnvironment continuationEnvironment)
{
Variables = new SimpleReference[numVariables];
NumberOfArguments = numArguments;
for (var x=0; x<numVariables; ++x)
{
Variables[x] = new SimpleReference();
}
ContinuationEnvironment = continuationEnvironment;
ContinuationPointer = -1;
}
public ByteCodeEnvironment(int numVariables, int numArguments, ByteCodeEnvironment continuationEnvironment)
{
Variables = new SimpleReference[numVariables];
NumberOfArguments = numArguments;
for (var x = 0; x < numVariables; ++x)
{
Variables[x] = new SimpleReference();
}
ContinuationEnvironment = continuationEnvironment;
ContinuationPointer = -1;
}
public ByteCodeExecutor(ByteCodePoint[] program, ILiteral[] literals, int maxVariableIndex)
{
if (program == null) throw new ArgumentNullException(nameof(program));
_program = program;
_literals = literals;
_programCounter = 0;
_environment = new ByteCodeEnvironment(0, 0, null);
_registers = new SimpleReference[maxVariableIndex];
for (var registerIndex = 0; registerIndex<_registers.Length; ++registerIndex)
{
_registers[registerIndex] = new SimpleReference();
}
}
public ChoicePoint(ChoicePoint previousChoice, ByteCodeEnvironment environment, IEnumerable <IReferenceLiteral> arguments, ITrail trail, int nextClause)
{
if (arguments == null)
{
throw new ArgumentNullException(nameof(arguments));
}
if (trail == null)
{
throw new ArgumentNullException(nameof(trail));
}
_previousChoicePoint = previousChoice;
_arguments = arguments.Select(arg => new SimpleReference(arg)).ToArray();
_trail = trail;
_nextClause = nextClause;
_environment = environment;
}
/// <summary>
/// Allocates space for a number of permanent and argument variables.
/// </summary>
/// <remarks>
/// Permanent variables are stored in the environment and are numbered from 0.
/// Arguments occur after the temporary variables and have their values preserved
/// from the previous state by this call.
/// </remarks>
private void Allocate(int numPermanent, int numArguments)
{
// Allocate a new environment
var newEnvironment = new ByteCodeEnvironment(numPermanent, numArguments, _environment);
newEnvironment.ContinuationEnvironment = _environment;
// Make sure that we don't overwrite arguments in the previous environment by replacing them with new temporary variables
if (numPermanent + numArguments < _environment.Variables.Length)
{
for (int oldPermanent = numPermanent + numArguments; oldPermanent < _environment.Variables.Length; ++oldPermanent)
{
_registers[oldPermanent] = new SimpleReference();
}
}
// Move arguments to their new position
int oldArgStart = _environment.Variables.Length;
if (oldArgStart > numPermanent)
{
// Moving arguments 'down', leaving a hole
for (int argument = 0; argument < numArguments; ++argument)
{
_registers[argument + numPermanent] = _registers[argument + oldArgStart];
_registers[argument + oldArgStart] = new SimpleReference();
}
}
else if (oldArgStart < numPermanent)
{
// Moving arguments 'up', old locations will be overwritten by new permanent variables
for (int argument = numArguments - 1; argument >= 0; --argument)
{
_registers[argument + numPermanent] = _registers[argument + oldArgStart];
}
}
// Copy in the new permanent variables
for (int permanent = 0; permanent < numPermanent; ++permanent)
{
_registers[permanent] = newEnvironment.Variables[permanent];
}
_environment = newEnvironment;
}
public ByteCodeExecutor(ByteCodePoint[] program, ILiteral[] literals, int maxVariableIndex)
{
if (program == null)
{
throw new ArgumentNullException(nameof(program));
}
_program = program;
_literals = literals;
_programCounter = 0;
_environment = new ByteCodeEnvironment(0, 0, null);
_registers = new SimpleReference[maxVariableIndex];
for (var registerIndex = 0; registerIndex < _registers.Length; ++registerIndex)
{
_registers[registerIndex] = new SimpleReference();
}
}
/// <summary>
/// Deallocates the last allocated block, restoring the permanent variables from the preceding environment
/// </summary>
private void Deallocate()
{
var oldEnvironment = _environment.ContinuationEnvironment;
if (oldEnvironment == null)
{
return;
}
// Restore any permanent variables from the new environment
for (var varIndex = 0; varIndex < oldEnvironment.Variables.Length; ++varIndex)
{
_registers[varIndex] = oldEnvironment.Variables[varIndex];
}
// Reallocate any temporary variables that have newly appeared
for (var varIndex = oldEnvironment.Variables.Length; varIndex < _environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = new SimpleReference();
}
// Finally, restore the environment
_environment = oldEnvironment;
}
/// <summary>
/// Backtracks to the current choice point
/// </summary>
public void BacktrackToChoicePoint()
{
// Restore the environment permanent variables
if (!ReferenceEquals(_choicePoint.Environment, _environment))
{
for (var varIndex = 0; varIndex < _choicePoint.Environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = _choicePoint.Environment.Variables[varIndex];
}
for (var varIndex = _choicePoint.Environment.Variables.Length; varIndex < _environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = new SimpleReference();
}
}
// Restore the argument registers
var argumentIndex = _choicePoint.Environment.Variables.Length;
foreach (var argument in _choicePoint.Arguments)
{
_registers[argumentIndex].SetTo(argument);
++argumentIndex;
}
// Environment is reset to the choice point environment
_environment = _choicePoint.Environment;
// Reset the trail
_choicePoint.Trail.Reset();
_trail = _choicePoint.Trail;
}
/// <summary>
/// Deallocates the last allocated block, restoring the permanent variables from the preceding environment
/// </summary>
private void Deallocate()
{
var oldEnvironment = _environment.ContinuationEnvironment;
if (oldEnvironment == null) return;
// Restore any permanent variables from the new environment
for (var varIndex = 0; varIndex < oldEnvironment.Variables.Length; ++varIndex)
{
_registers[varIndex] = oldEnvironment.Variables[varIndex];
}
// Reallocate any temporary variables that have newly appeared
for (var varIndex = oldEnvironment.Variables.Length; varIndex < _environment.Variables.Length; ++varIndex)
{
_registers[varIndex] = new SimpleReference();
}
// Finally, restore the environment
_environment = oldEnvironment;
}
/// <summary>
/// Allocates space for a number of permanent and argument variables.
/// </summary>
/// <remarks>
/// Permanent variables are stored in the environment and are numbered from 0.
/// Arguments occur after the temporary variables and have their values preserved
/// from the previous state by this call.
/// </remarks>
private void Allocate(int numPermanent, int numArguments)
{
// Allocate a new environment
var newEnvironment = new ByteCodeEnvironment(numPermanent, numArguments, _environment);
newEnvironment.ContinuationEnvironment = _environment;
// Make sure that we don't overwrite arguments in the previous environment by replacing them with new temporary variables
if (numPermanent + numArguments < _environment.Variables.Length)
{
for (int oldPermanent = numPermanent + numArguments; oldPermanent < _environment.Variables.Length; ++oldPermanent)
{
_registers[oldPermanent] = new SimpleReference();
}
}
// Move arguments to their new position
int oldArgStart = _environment.Variables.Length;
if (oldArgStart > numPermanent)
{
// Moving arguments 'down', leaving a hole
for (int argument = 0; argument < numArguments; ++argument)
{
_registers[argument + numPermanent] = _registers[argument + oldArgStart];
_registers[argument + oldArgStart] = new SimpleReference();
}
}
else if (oldArgStart < numPermanent)
{
// Moving arguments 'up', old locations will be overwritten by new permanent variables
for (int argument = numArguments-1; argument >=0; --argument)
{
_registers[argument + numPermanent] = _registers[argument + oldArgStart];
}
}
// Copy in the new permanent variables
for (int permanent = 0; permanent < numPermanent; ++permanent)
{
_registers[permanent] = newEnvironment.Variables[permanent];
}
_environment = newEnvironment;
}