// Moves the buffer to the next token at the same level of nesting as the current token.
// Should never be called if we're on an end token!!!
// Returns false if no next token can be found at the same level.
// this is probably indicative of a template authoring problem, or possibly a buffer problem.
private bool SeekToNextTokenAtSameLevel(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, out int token)
{
if (_definition.WholeLine)
{
processor.SeekForwardThrough(processor.EncodingConfig.LineEndings, ref bufferLength, ref currentBufferPosition);
}
bool seekSucceeded = SeekToToken(processor, ref bufferLength, ref currentBufferPosition, out token);
//Keep on scanning until we've hit a balancing token that belongs to us
// each "if" found opens a new level of nesting
while (IsTokenIndexOfType(token, IfTokenBaseIndex) || IsTokenIndexOfType(token, IfTokenActionableBaseIndex))
{
int open = 1;
while (open != 0)
{
seekSucceeded &= SeekToToken(processor, ref bufferLength, ref currentBufferPosition, out token);
if (IsTokenIndexOfType(token, IfTokenBaseIndex) || IsTokenIndexOfType(token, IfTokenActionableBaseIndex))
{
++open;
}
else if (IsTokenIndexOfType(token, EndTokenBaseIndex))
{
--open;
}
}
seekSucceeded &= SeekToToken(processor, ref bufferLength, ref currentBufferPosition, out token);
}
// this may be irrelevant. If it happens, the template is malformed (i think)
return(seekSucceeded);
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
TokenTrie structureTrie = new TokenTrie();
TokenTrie closeConditionTrie = new TokenTrie();
TokenTrie scanBackTrie = new TokenTrie();
IToken openOpenElementTokenBytes = Tokens.OpenOpenElementToken.ToToken(processorState.Encoding);
scanBackTrie.AddToken(openOpenElementTokenBytes);
int openOpenElementToken = structureTrie.AddToken(openOpenElementTokenBytes);
int openCloseElementToken = structureTrie.AddToken(Tokens.OpenCloseElementToken.ToToken(processorState.Encoding));
int closeCloseElementToken = structureTrie.AddToken(Tokens.CloseElementTagToken.ToToken(processorState.Encoding));
int selfClosingElementEndToken = -1;
if (Tokens.SelfClosingElementEndToken != null)
{
selfClosingElementEndToken = structureTrie.AddToken(Tokens.SelfClosingElementEndToken.ToToken(processorState.Encoding));
}
closeConditionTrie.AddToken(Tokens.CloseConditionExpression.ToToken(processorState.Encoding));
MarkupTokenMapping mapping = new MarkupTokenMapping(
openOpenElementToken,
openCloseElementToken,
closeCloseElementToken,
selfClosingElementEndToken
);
IReadOnlyList <IToken> start = new[] { Tokens.OpenConditionExpression.ToToken(processorState.Encoding) };
return(new Impl(this, start, structureTrie, closeConditionTrie, scanBackTrie, mapping, _id, _initialState));
}
public int HandleMatch(IProcessorState processor, int bufferLength, ref int currentBufferPosition, int token, Stream target)
{
bool flagsOn;
if (!processor.Config.Flags.TryGetValue(SetFlag.OperationName, out flagsOn))
{
flagsOn = true;
}
bool emit = token < 2 || !flagsOn;
bool turnOn = (token % 2) == 0;
int written = 0;
if (emit)
{
byte[] tokenValue = Tokens[token];
target.Write(tokenValue, 0, tokenValue.Length);
written = tokenValue.Length;
}
//Only turn the flag in question back on if it's the "flags" flag.
// Yes, we still need to emit it as the common case is for this
// to be done in the template definition file
if (flagsOn)
{
processor.Config.Flags[_owner.Name] = token == 0;
}
else if (_owner.Name == SetFlag.OperationName && turnOn)
{
processor.Config.Flags[SetFlag.OperationName] = true;
}
return(written);
}
public static bool Evaluate(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, out bool faulted)
{
ITokenTrie tokens = Instance.GetSymbols(processor);
ScopeBuilder <Operators, TTokens> builder = processor.ScopeBuilder(tokens, Map, DereferenceInLiteralsSetting);
bool isFaulted = false;
IEvaluable result = builder.Build(ref bufferLength, ref currentBufferPosition, x => isFaulted = true);
if (isFaulted)
{
faulted = true;
return(false);
}
try
{
object evalResult = result.Evaluate();
bool r = (bool)Convert.ChangeType(evalResult, typeof(bool));
faulted = false;
return(r);
}
catch
{
faulted = true;
return(false);
}
}
public ScopeBuilder(IProcessorState processor, ITokenTrie tokens, IOperatorMap <TOperator, TToken> operatorMap, bool dereferenceInLiterals)
{
TokenTrie trie = new TokenTrie();
trie.Append(tokens);
_badSyntaxTokens = operatorMap.BadSyntaxTokens;
_noops = operatorMap.NoOpTokens;
_openGroup = operatorMap.OpenGroupToken;
_closeGroup = operatorMap.CloseGroupToken;
_literal = operatorMap.LiteralToken;
_identity = operatorMap.Identity;
_literalSequenceBoundsMarkers = operatorMap.LiteralSequenceBoundsMarkers;
_terminators = operatorMap.Terminators;
_isSymbolDereferenceInLiteralSequenceRequired = dereferenceInLiterals;
_processor = processor;
_knownTokensCount = tokens.Count;
_valueEncoder = operatorMap.Encode;
_valueDecoder = operatorMap.Decode;
List <object> symbolValues = new List <object>();
foreach (KeyValuePair <string, object> variable in processor.Config.Variables)
{
trie.AddToken(processor.Encoding.GetBytes(string.Format(processor.Config.VariableFormatString, variable.Key)));
symbolValues.Add(variable.Value);
}
_symbolValues = symbolValues;
_tokenToOperatorMap = operatorMap.TokensToOperatorsMap;
_operatorScopeFactory = operatorMap.OperatorScopeLookupFactory;
_tokens = trie;
}
public VerticesListProcessor()
{
this.vertices = new List <Vertex>();
this.processorState = NodeIDState.Instance;
this.paramsToReadLeft = 0;
this.finished = false;
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
byte[] ifToken = encoding.GetBytes(_ifToken);
byte[] endToken = encoding.GetBytes(_endIfToken);
List <byte[]> tokens = new List <byte[]>
{
ifToken,
endToken
};
SimpleTrie trie = new SimpleTrie();
trie.AddToken(ifToken, 0);
trie.AddToken(endToken, 1);
int elseIfTokenIndex = -1;
if (!string.IsNullOrEmpty(_elseToken))
{
byte[] elseToken = encoding.GetBytes(_elseToken);
trie.AddToken(elseToken, tokens.Count);
tokens.Add(elseToken);
}
if (!string.IsNullOrEmpty(_elseIfToken))
{
byte[] elseIfToken = encoding.GetBytes(_elseIfToken);
elseIfTokenIndex = tokens.Count;
trie.AddToken(elseIfToken, elseIfTokenIndex);
tokens.Add(elseIfToken);
}
return(new Impl(this, tokens, elseIfTokenIndex, trie));
}
// moves to the next token
// returns false if the end of the buffer was reached without finding a token.
private bool SeekToToken(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition, out int token)
{
bool bufferAdvanceFailed = false;
while (bufferLength >= _trie.MinLength)
{
for (; currentBufferPosition < bufferLength - _trie.MinLength + 1; ++currentBufferPosition)
{
if (_trie.GetOperation(processor.CurrentBuffer, bufferLength, ref currentBufferPosition, out token))
{
if (bufferAdvanceFailed || (currentBufferPosition != bufferLength))
{
return(true);
}
}
}
if (bufferAdvanceFailed)
{
break;
}
bufferAdvanceFailed = !processor.AdvanceBuffer(bufferLength - _trie.MaxLength + 1);
currentBufferPosition = processor.CurrentBufferPosition;
bufferLength = processor.CurrentBufferLength;
}
//If we run out of places to look, assert that the end of the buffer is the end
token = EndTokenBaseIndex;
currentBufferPosition = bufferLength;
return(false); // no terminator found
}
/// <inheritdoc/>
public override void PerformAction(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu)
{
ushort addressA = (ushort)state.Registers[instruction.Register1];
ushort addressB = (ushort)state.Registers[instruction.Register2];
byte a = 0;
byte b = 0;
for (ushort i = 0; i < instruction.Immediate; i++)
{
a = (byte)memory.GetValue(0, (ushort)(addressA + i));
b = (byte)memory.GetValue(0, (ushort)(addressB + i));
if (a != b)
{
break;
}
}
state.High = a > b;
state.Equal = a == b;
state.Low = !state.High;
}
/// <summary>
/// Initializes a new instance of the <see cref="PC"/> class.
/// </summary>
public PC()
{
this.SetupContainerGraph();
this.processor = this.container.GetInstance <IProcessor>();
this.memory = this.container.GetInstance <IEmulatedMemory>();
this.state = this.container.GetInstance <IProcessorState>();
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
IToken startToken = _start.ToToken(encoding);
IToken endToken = _end.ToToken(encoding);
return(new Impl(this, startToken, endToken, _include, _toggle, _id, _initialState));
}
/// <summary>
/// Initializes a new instance of the <see cref="Processor"/> class.
/// </summary>
/// <param name="parsedInstruction">Parsed instruction.</param>
/// <param name="memory">Memory.</param>
/// <param name="alu">ALU.</param>
/// <param name="state">Processor state.</param>
public Processor(IParsedInstruction parsedInstruction, IEmulatedMemory memory, IALU alu, IProcessorState state)
{
this.parsedInstruction = parsedInstruction;
this.memory = memory;
this.alu = alu;
this.state = state;
}
internal bool Evaluate(IProcessorState processor, ref int bufferLength, ref int currentBufferPosition)
{
bool faulted;
BranchTaken = _impl._definition._evaluator(processor, ref bufferLength, ref currentBufferPosition, out faulted);
return(BranchTaken);
}
public EdgeListProcessor()
{
this.outEdges = new List <OutEdge>();
this.inEdges = new List <InEdge>();
this.finished = false;
this.processorState = EdgeIDState.Instance;
this.paramsToReadLeft = 0;
}
public TableDictProcessor()
{
this.dict = new Dictionary <string, Table>();
this.finished = false;
this.processorState = TableDictLeftSquareBraceState.Instance;
this.newTable = null;
this.newPropName = null;
}
/// <inheritdoc/>
public override void PerformAction(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu)
{
alu.PerformAction(this.calculation, instruction.Immediate);
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
IToken startToken = _startToken.ToToken(encoding);
IToken realEndToken = _realEndToken.ToToken(encoding);
IToken pseudoEndToken = _pseudoEndToken.ToToken(encoding);
return(new Impl(startToken, realEndToken, pseudoEndToken, _id, _resetFlag, _initialState));
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
byte[] startToken = encoding.GetBytes(_startToken);
byte[] realEndToken = encoding.GetBytes(_realEndToken);
byte[] pseudoEndToken = encoding.GetBytes(_pseudoEndToken);
return(new Impl(startToken, realEndToken, pseudoEndToken, _id, _resetFlag));
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
state.Registers[instruction.Register2] = value;
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
memory.SetValue(instruction.Width, (ulong)value, (ushort)state.Registers[instruction.Register1]);
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
alu.StageValue(0, value);
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
state.ProgramCounter = (ushort)value;
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
byte[] tokenBytes = encoding.GetBytes(StartToken);
byte[] endTokenBytes = encoding.GetBytes(EndToken);
TokenTrie endTokenMatcher = new TokenTrie();
endTokenMatcher.AddToken(endTokenBytes);
return(new Impl(tokenBytes, endTokenMatcher, this, _id));
}
/// <inheritdoc/>
public void PutData(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu,
long value)
{
memory.SetValue(instruction.Width, (ulong)value, instruction.Address);
}
public IOperation GetOperation(Encoding encoding, IProcessorState processorState)
{
IToken tokenBytes = StartToken.ToToken(encoding);
IToken endTokenBytes = EndToken.ToToken(encoding);
TokenTrie endTokenMatcher = new TokenTrie();
endTokenMatcher.AddToken(endTokenBytes);
return(new Impl(tokenBytes, endTokenMatcher, this, _id, _initialState));
}
public void ToggleActionableOperations(bool enabled, IProcessorState processor)
{
ActionableOperationsEnabled = enabled;
foreach (string otherOptionDisableFlag in _impl._definition.Tokens.ActionableOperations)
{
processor.Config.Flags[otherOptionDisableFlag] = enabled;
}
}
private static ITokenTrie GetSymbols(IProcessorState processor)
{
if (!TokenCache.TryGetValue(processor.Encoding, out ITokenTrie tokens))
{
TokenTrie trie = new TokenTrie();
//Logic
trie.AddToken(processor.Encoding.GetBytes("&&"));
trie.AddToken(processor.Encoding.GetBytes("||"));
trie.AddToken(processor.Encoding.GetBytes("!"));
trie.AddToken(processor.Encoding.GetBytes(">"));
trie.AddToken(processor.Encoding.GetBytes(">="));
trie.AddToken(processor.Encoding.GetBytes("<"));
trie.AddToken(processor.Encoding.GetBytes("<="));
trie.AddToken(processor.Encoding.GetBytes("=="));
trie.AddToken(processor.Encoding.GetBytes("!="));
//Braces
trie.AddToken(processor.Encoding.GetBytes("("));
trie.AddToken(processor.Encoding.GetBytes(")"));
//Whitespace
trie.AddToken(processor.Encoding.GetBytes(" "));
trie.AddToken(processor.Encoding.GetBytes("\t"));
//EOLs
trie.AddToken(processor.Encoding.GetBytes("\r\n"));
trie.AddToken(processor.Encoding.GetBytes("\n"));
trie.AddToken(processor.Encoding.GetBytes("\r"));
// quotes
trie.AddToken(processor.Encoding.GetBytes("'"));
//Shifts
trie.AddToken(processor.Encoding.GetBytes("<<"));
trie.AddToken(processor.Encoding.GetBytes(">>"));
//Maths
trie.AddToken(processor.Encoding.GetBytes("+"));
trie.AddToken(processor.Encoding.GetBytes("-"));
trie.AddToken(processor.Encoding.GetBytes("*"));
trie.AddToken(processor.Encoding.GetBytes("/"));
//Bitwise operators
trie.AddToken(processor.Encoding.GetBytes("&"));
trie.AddToken(processor.Encoding.GetBytes("|"));
// quotes
trie.AddToken(processor.Encoding.GetBytes("'"));
trie.AddToken(processor.Encoding.GetBytes("\""));
TokenCache[processor.Encoding] = tokens = trie;
}
return(tokens);
}
/// <inheritdoc/>
public override void PerformAction(
IParsedInstruction instruction,
IEmulatedMemory memory,
IProcessorState state,
IALU alu)
{
long value = this.from.GetData(instruction, memory, state, alu);
this.to.PutData(instruction, memory, state, alu, value);
}
protected override ITokenTrie GetSymbols(IProcessorState processor)
{
if (!TokenCache.TryGetValue(processor.Encoding, out ITokenTrie tokens))
{
TokenTrie trie = new TokenTrie();
//Logic
trie.AddToken(processor.Encoding.GetBytes("And"));
trie.AddToken(processor.Encoding.GetBytes("AndAlso"));
trie.AddToken(processor.Encoding.GetBytes("Or"));
trie.AddToken(processor.Encoding.GetBytes("OrElse"));
trie.AddToken(processor.Encoding.GetBytes("Not"));
trie.AddToken(processor.Encoding.GetBytes(">"));
trie.AddToken(processor.Encoding.GetBytes(">="));
trie.AddToken(processor.Encoding.GetBytes("<"));
trie.AddToken(processor.Encoding.GetBytes("<="));
trie.AddToken(processor.Encoding.GetBytes("="));
trie.AddToken(processor.Encoding.GetBytes("<>"));
trie.AddToken(processor.Encoding.GetBytes("Xor"));
//Braces
trie.AddToken(processor.Encoding.GetBytes("("));
trie.AddToken(processor.Encoding.GetBytes(")"));
//Whitespace
trie.AddToken(processor.Encoding.GetBytes(" "));
trie.AddToken(processor.Encoding.GetBytes("\t"));
//EOLs
trie.AddToken(processor.Encoding.GetBytes("\r\n"));
trie.AddToken(processor.Encoding.GetBytes("\n"));
trie.AddToken(processor.Encoding.GetBytes("\r"));
// quotes
trie.AddToken(processor.Encoding.GetBytes("'"));
//Shifts
trie.AddToken(processor.Encoding.GetBytes("<<"));
trie.AddToken(processor.Encoding.GetBytes(">>"));
//Maths
trie.AddToken(processor.Encoding.GetBytes("+"));
trie.AddToken(processor.Encoding.GetBytes("-"));
trie.AddToken(processor.Encoding.GetBytes("*"));
trie.AddToken(processor.Encoding.GetBytes("/"));
trie.AddToken(processor.Encoding.GetBytes("^"));
// quotes
trie.AddToken(processor.Encoding.GetBytes("\""));
TokenCache[processor.Encoding] = tokens = trie;
}
return(tokens);
}
