private IMatchData ConvertToBinaryTree(FragmentMatchData matchData, IMatchData rootPart)
{
foreach (ExpressionPartInfo partInfo in ExtractExpressionParts(matchData).OrderBy(part => part.ExpressionOrder ?? int.MaxValue))
{
if (partInfo.ExpressionOrder != null)
{
FragmentMatchData fragment = (FragmentMatchData)partInfo.Part;
fragment.Parts.Insert(0, partInfo.Previous.Part);
fragment.Parts.Add(partInfo.Next.Part);
if (partInfo.Previous.Previous is ExpressionPartInfo newPreviousPartInfo)
{
newPreviousPartInfo.Next = partInfo;
partInfo.Previous = newPreviousPartInfo;
}
if (partInfo.Next.Next is ExpressionPartInfo newNextPartInfo)
{
newNextPartInfo.Previous = partInfo;
partInfo.Next = newNextPartInfo;
}
rootPart = fragment;
}
}
return(rootPart);
}
private IMatchData ConvertToLikeNameTree(FragmentMatchData matchData, IMatchData rootPart)
{
foreach (ExpressionPartInfo partInfo in ExtractExpressionParts(matchData).OrderBy(part => part.ExpressionOrder ?? int.MaxValue))
{
if (partInfo.ExpressionOrder != null)
{
FragmentMatchData fragment = (FragmentMatchData)partInfo.Part;
if (partInfo.Previous.Part is FragmentMatchData previousFragment && previousFragment.Name == fragment.Name)
{
fragment.Parts.InsertRange(0, previousFragment.Parts);
}
else
{
fragment.Parts.Insert(0, partInfo.Previous.Part);
}
fragment.Parts.Add(partInfo.Next.Part);
if (partInfo.Previous.Previous is ExpressionPartInfo newPreviousPartInfo)
{
newPreviousPartInfo.Next = partInfo;
partInfo.Previous = newPreviousPartInfo;
}
if (partInfo.Next.Next is ExpressionPartInfo newNextPartInfo)
{
newNextPartInfo.Previous = partInfo;
partInfo.Next = newNextPartInfo;
}
rootPart = fragment;
}
}
public static JsonItem GetJsonItem(IMatchData matchData)
{
switch (matchData.Name)
{
case "Object":
return(new JsonObject((FragmentMatchData)matchData));
case "Array":
return(new JsonArray((FragmentMatchData)matchData));
case "Boolean":
return(new JsonValue((StringMatchData)matchData, JsonDataType.Boolean));
case "Number":
return(new JsonValue((StringMatchData)matchData, JsonDataType.Number));
case "Null":
return(new JsonValue((StringMatchData)matchData, JsonDataType.Null));
case "String":
return(new JsonValue((StringMatchData)matchData, JsonDataType.String));
default:
return(null);
}
}
private void AddItem(IMatchData matchData)
{
switch (matchData.Name)
{
case "MathParensValuable":
case "BooleanParensValuable":
AddParensValuable((FragmentMatchData)matchData);
break;
case "Boolean":
AddBoolean((StringMatchData)matchData);
break;
case "Number":
AddNumber((FragmentMatchData)matchData);
break;
case "OperatedMathValuable":
case "MathExpression":
case "RelationalExpression":
case "EqualityExpression":
case "BooleanOrExpression":
case "BooleanAndExpression":
case "MathOrExpression":
case "MathAndExpression":
AddPartItem((FragmentMatchData)matchData);
break;
case "FactorialMathValuable":
AddFactorialMathValuable((FragmentMatchData)matchData);
break;
case "SquareRootMathValuable":
AddSquareRootMathValuable((FragmentMatchData)matchData);
break;
case "OperatedBooleanValuable":
AddOperatedBooleanValuable((FragmentMatchData)matchData);
break;
case "MultiplicativeSuffix":
case "AdditiveSuffix":
case "SubtractiveSuffix":
case "ExponentSuffix":
case "EqualitySuffix":
case "RelationalSuffix":
case "BooleanAndSuffix":
case "BooleanOrSuffix":
case "MathAndSuffix":
case "MathOrSuffix":
case "SimpleMathAndSuffix":
case "SimpleMathOrSuffix":
AddTreedExpression((FragmentMatchData)matchData);
break;
default:
throw new NotImplementedException($"Matcher '{matchData.Name}' is unhandled");
}
}
public MatcherResult(IMatchData matchData = default, bool success = default, int endIndex = default, int?failureIndex = default, string matchLog = default)
{
MatchData = matchData;
Success = success;
EndIndex = endIndex;
FailureIndex = failureIndex;
MatchLog = matchLog;
}
public void Deconstruct(out IMatchData matchData, out bool success, out int endIndex, out int?failureIndex, out string matchLog)
{
matchData = MatchData;
success = Success;
endIndex = EndIndex;
failureIndex = FailureIndex;
matchLog = MatchLog;
}
public IList <Instruction <GroupState> > Generate(IMatchData matchData)
{
_action = new ActionInfo();
_instructions = new List <Instruction <GroupState> >();
_reprocessRequiredIndexes = new Dictionary <InstructionCode, List <int> >();
foreach (IMatchData partMatchData in ((FragmentMatchData)matchData).Parts)
{
AddItem(partMatchData);
}
if (_reprocessRequiredIndexes.Count > 0)
{
throw new LanguageConstraintException("Invalid operation", _reprocessRequiredIndexes.Values.FirstOrDefault()?.FirstOrDefault());
}
return(_instructions);
}
public override MatcherResult Match(string code, string fragmentMatcher, bool matchFullText = true)
{
FragmentMatchData matchData = new FragmentMatchData {
StartIndex = 0
};
Span <int> checkFlags = stackalloc int[7];
State state = new State()
{
Code = code, DistinctStringMatches = new List <StringMatchData>(2000), CheckFlags = checkFlags
};
bool success = false;
switch (fragmentMatcher)
{
case "NotCharacterClassBody":
success = MatchFragmentNotCharacterClassBody(ref state, matchData);
break;
case "CharacterClassBody":
success = MatchFragmentCharacterClassBody(ref state, matchData);
break;
case "CharacterRange":
success = MatchFragmentCharacterRange(ref state, matchData);
break;
case "HexRange":
success = MatchFragmentHexRange(ref state, matchData);
break;
}
IMatchData resultMatchData = matchData.Parts.FirstOrDefault();
int? failureIndex = success ? null : state.FailureIndex;
if (success && matchFullText && state.CurrentIndex != state.Code.Length)
{
success = false;
failureIndex = state.CurrentIndex;
}
return(new MatcherResult(resultMatchData, success, state.CurrentIndex, failureIndex, state.MatchLogBuilder?.ToString()));
}
protected void ConvertToExpressionTree(FragmentMatchData matchData, ExpressionMode expressionMode)
{
IMatchData rootPart = matchData.Parts.ElementAtOrDefault(0);
switch (expressionMode)
{
case ExpressionMode.BinaryTree:
rootPart = ConvertToBinaryTree(matchData, rootPart);
break;
case ExpressionMode.LikeNameTree:
rootPart = ConvertToLikeNameTree(matchData, rootPart);
break;
}
matchData.Parts.Clear();
if (rootPart != null)
{
matchData.Parts.Add(rootPart);
}
}
private void AddTreedExpression(FragmentMatchData matchData)
{
IMatchData operatorData = matchData.Parts[1];
AddItem(matchData.Parts[0]);
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.PHR, sourcePosition: matchData.StartIndex));
AddItem(matchData.Parts[2]);
switch (operatorData.ToString())
{
case "*":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RMultiply, sourcePosition: operatorData.StartIndex));
break;
case "/":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RDivide, sourcePosition: operatorData.StartIndex));
break;
case "+":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RPlus, sourcePosition: operatorData.StartIndex));
break;
case "-":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RSubtract, sourcePosition: operatorData.StartIndex));
break;
case "^":
_instructions.Add(_instructionProvider.GetSpecialInstruction(new string[] { "RPOW" }, sourcePosition: operatorData.StartIndex));
break;
case ">":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RGreaterThan, sourcePosition: operatorData.StartIndex));
break;
case ">=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RGreaterThanOrEquals, sourcePosition: operatorData.StartIndex));
break;
case "<":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RLessThan, sourcePosition: operatorData.StartIndex));
break;
case "<=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RLessThanOrEquals, sourcePosition: operatorData.StartIndex));
break;
case "==":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.REquals, sourcePosition: operatorData.StartIndex));
break;
case "!=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RNotEquals, sourcePosition: operatorData.StartIndex));
break;
case "&":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RAnd, sourcePosition: operatorData.StartIndex));
break;
case "|":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.ROr, sourcePosition: operatorData.StartIndex));
break;
}
}
public IList <Instruction <GroupState> > Generate(IMatchData matchData)
{
_instructions = new List <Instruction <GroupState> >();
AddItem(matchData);
return(_instructions);
}
private void AddExpressionSuffix(FragmentMatchData matchData)
{
IMatchData operatorData = matchData.Parts[1];
AddItem((FragmentMatchData)matchData.Parts[0]);
int?shortcutInstruction = null;
switch (operatorData.ToString())
{
case "&&":
{
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.CPHR, sourcePosition: operatorData.StartIndex));
shortcutInstruction = _instructions.Count;
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.NC, sourcePosition: operatorData.StartIndex));
}
break;
case "||":
{
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.CPHR, sourcePosition: operatorData.StartIndex));
shortcutInstruction = _instructions.Count;
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.C, sourcePosition: operatorData.StartIndex));
}
break;
}
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.PHR, sourcePosition: matchData.StartIndex));
AddItem((FragmentMatchData)matchData.Parts[2]);
switch (operatorData.ToString())
{
case ">":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RGreaterThan, sourcePosition: operatorData.StartIndex));
break;
case ">=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RGreaterThanOrEquals, sourcePosition: operatorData.StartIndex));
break;
case "<":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RLessThan, sourcePosition: operatorData.StartIndex));
break;
case "<=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RLessThanOrEquals, sourcePosition: operatorData.StartIndex));
break;
case "==":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.REquals, sourcePosition: operatorData.StartIndex));
break;
case "!=":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RNotEquals, sourcePosition: operatorData.StartIndex));
break;
case "&&":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RAnd, sourcePosition: operatorData.StartIndex));
break;
case "&":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RAnd, sourcePosition: operatorData.StartIndex));
break;
case "||":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.ROr, sourcePosition: operatorData.StartIndex));
break;
case "|":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.ROr, sourcePosition: operatorData.StartIndex));
break;
case "*":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RMultiply, sourcePosition: operatorData.StartIndex));
break;
case "/":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RDivide, sourcePosition: operatorData.StartIndex));
break;
case "+":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RPlus, sourcePosition: operatorData.StartIndex));
break;
case "-":
_instructions.Add(InstructionProvider <GroupState> .GetInstruction(InstructionCode.RSubtract, sourcePosition: operatorData.StartIndex));
break;
}
if (shortcutInstruction != null)
{
_instructions[shortcutInstruction.Value] = InstructionProvider <GroupState> .GetInstruction(_instructions[shortcutInstruction.Value].Code, payload : new object[] { _instructions.Count }, sourcePosition : operatorData.StartIndex);
}
}
private void AddItem(IMatchData matchData, bool interruptable = false)
{
switch (matchData.Name)
{
case "WhileBlock":
AddWhileBlock((FragmentMatchData)matchData);
break;
case "IfElseBlock":
AddIfElseBlock((FragmentMatchData)matchData);
break;
case "Block":
AddBlock((FragmentMatchData)matchData);
break;
case "ItemReturn":
AddItemReturn((FragmentMatchData)matchData);
break;
case "Break":
AddBreak((StringMatchData)matchData);
break;
case "Continue":
AddContinue((StringMatchData)matchData);
break;
case "DeclarationAssignment":
AddDeclarationAssignment((FragmentMatchData)matchData);
break;
case "Declaration":
AddDeclaration((FragmentMatchData)matchData);
break;
case "Assignment":
AddAssignment((FragmentMatchData)matchData);
break;
case "DirectedValuableChain":
AddDirectedValuableChain((FragmentMatchData)matchData);
break;
case "NewArray":
AddNewArray((FragmentMatchData)matchData);
break;
case "ParensValuable":
AddParensValuable((FragmentMatchData)matchData);
break;
case "Identifier":
AddGetVariable((FragmentMatchData)matchData, interruptable);
break;
case "ValuedIndex":
AddValuedIndex((FragmentMatchData)matchData);
break;
case "ArgumentValues":
AddArgumentValues((FragmentMatchData)matchData);
break;
case "AnonymousFunction":
AddAnonymousFunction((FragmentMatchData)matchData);
break;
case "Boolean":
AddBoolean((StringMatchData)matchData);
break;
case "Null":
AddNull((StringMatchData)matchData);
break;
case "StringLiteral":
AddStringLiteral((StringMatchData)matchData);
break;
case "Number":
AddNumber((FragmentMatchData)matchData);
break;
case "Valuable":
case "Value":
case "OpenEndedStatements":
AddInnerItem((FragmentMatchData)matchData);
break;
case "MultiplicativeSuffix":
case "AdditiveSuffix":
case "SubtractiveSuffix":
case "EqualitySuffix":
case "RelationalSuffix":
case "AndSuffix":
case "OrSuffix":
case "BitwiseAndSuffix":
case "BitwiseOrSuffix":
AddExpressionSuffix((FragmentMatchData)matchData);
break;
default:
throw new NotImplementedException($"Matcher '{matchData.Name}' is unhandled");
}
}
