public CutPoint(ISymbolicExpressionTreeNode parent, int childIndex)
{
this.Parent = parent;
this.ChildIndex = childIndex;
this.Child = null;
this.grammar = parent.Grammar;
}
public CutPoint(ISymbolicExpressionTreeNode parent, ISymbolicExpressionTreeNode child)
{
this.Parent = parent;
this.Child = child;
this.ChildIndex = parent.IndexOfSubtree(child);
this.grammar = parent.Grammar;
}
internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable <int> argumentIndexes, IEnumerable <CutPoint> argumentCutPoints)
{
foreach (var pair in argumentIndexes.Zip(argumentCutPoints, (a, b) => new { Index = a, CutPoint = b }))
{
var argSymbol = new Argument(pair.Index);
grammar.AddSymbol(argSymbol);
grammar.SetSubtreeCount(argSymbol, 0, 0);
foreach (var symb in grammar.Symbols)
{
if (symb is ProgramRootSymbol || symb is StartSymbol)
{
continue;
}
if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol))
{
grammar.AddAllowedChildSymbol(symb, argSymbol);
}
else
{
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++)
{
if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol, i))
{
grammar.AddAllowedChildSymbol(symb, argSymbol, i);
}
}
}
}
}
}
internal static void SetAllowedParentSymbols(ISymbolicExpressionTreeGrammar grammar, ISymbol symbol, ISymbol newSymbol)
{
foreach (var symb in grammar.Symbols)
{
if (symb is ProgramRootSymbol)
{
continue;
}
if (newSymbol is Argument && symb is StartSymbol)
{
continue;
}
if (grammar.IsAllowedChildSymbol(symb, symbol))
{
grammar.AddAllowedChildSymbol(symb, newSymbol);
}
else
{
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++)
{
if (grammar.IsAllowedChildSymbol(symb, symbol, i))
{
grammar.AddAllowedChildSymbol(symb, newSymbol, i);
}
}
}
}
}
public static IEnumerable <string> GetSemanticProductionNames(ISymbolicExpressionTreeGrammar grammar)
{
var symbolNames = grammar.Symbols.Select(x => x.Name);
var statementProductionNames = new List <string>();
foreach (var ruleName in SemanticOperatorHelper.StatementProductionRules)
{
if (symbolNames.Contains(ruleName))
{
statementProductionNames.AddRange(((GroupSymbol)grammar.GetSymbol(ruleName)).Symbols.Select(x => x.Name));
}
}
return(statementProductionNames);
}
internal static void SetAllowedParentSymbols(ISymbolicExpressionTreeGrammar grammar, ISymbol symbol, ISymbol newSymbol) {
foreach (var symb in grammar.Symbols) {
if (symb is ProgramRootSymbol) continue;
if (newSymbol is Argument && symb is StartSymbol) continue;
if (grammar.IsAllowedChildSymbol(symb, symbol))
grammar.AddAllowedChildSymbol(symb, newSymbol);
else {
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) {
if (grammar.IsAllowedChildSymbol(symb, symbol, i))
grammar.AddAllowedChildSymbol(symb, newSymbol, i);
}
}
}
}
internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable<int> argumentIndexes, IEnumerable<CutPoint> argumentCutPoints) {
foreach (var pair in argumentIndexes.Zip(argumentCutPoints, (a, b) => new { Index = a, CutPoint = b })) {
var argSymbol = new Argument(pair.Index);
grammar.AddSymbol(argSymbol);
grammar.SetSubtreeCount(argSymbol, 0, 0);
foreach (var symb in grammar.Symbols) {
if (symb is ProgramRootSymbol || symb is StartSymbol) continue;
if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol))
grammar.AddAllowedChildSymbol(symb, argSymbol);
else {
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) {
if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol, i))
grammar.AddAllowedChildSymbol(symb, argSymbol, i);
}
}
}
}
}
protected SymbolicExpressionGrammar(SymbolicExpressionGrammar original, Cloner cloner)
: base(original, cloner)
{
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
foreach (ISymbol symbol in symbols.Values)
{
RegisterSymbolEvents(symbol);
}
programRootSymbol = cloner.Clone(original.programRootSymbol);
startSymbol = cloner.Clone(original.StartSymbol);
defunSymbol = cloner.Clone(original.defunSymbol);
maximumFunctionArguments = original.maximumFunctionArguments;
minimumFunctionArguments = original.minimumFunctionArguments;
maximumFunctionDefinitions = original.maximumFunctionDefinitions;
minimumFunctionDefinitions = original.minimumFunctionDefinitions;
}
protected SymbolicExpressionGrammar(string name, string description)
: base(name, description)
{
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
programRootSymbol = new ProgramRootSymbol();
AddSymbol(programRootSymbol);
SetSubtreeCount(programRootSymbol, 1, 1);
startSymbol = new StartSymbol();
AddSymbol(startSymbol);
SetSubtreeCount(startSymbol, 1, 1);
defunSymbol = new Defun();
AddSymbol(defunSymbol);
SetSubtreeCount(defunSymbol, 1, 1);
AddAllowedChildSymbol(programRootSymbol, startSymbol, 0);
UpdateAdfConstraints();
}
public static void IsValid(ISymbolicExpressionTreeGrammar grammar)
{
Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count());
foreach (ISymbol symbol in grammar.AllowedSymbols)
{
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count());
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++)
{
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count());
}
}
foreach (var symbol in grammar.ModifyableSymbols)
{
//check if every symbol has at least one allowed child
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++)
{
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Any());
}
}
}
internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable<CutPoint> argumentCutPoints) {
if (!grammar.ContainsSymbol(startCutPoint.Child.Symbol)) return;
var invokeSym = new InvokeFunction(functionName);
grammar.AddSymbol(invokeSym);
grammar.SetSubtreeCount(invokeSym, nArgs, nArgs);
//allow invoke symbol everywhere, where the child of the startCutPoint was allowed
SetAllowedParentSymbols(grammar, startCutPoint.Child.Symbol, invokeSym);
if (nArgs > 0) {
//set allowed child symbols of invoke symbol
foreach (ISymbol child in grammar.Symbols) {
if (child.Name == invokeSym.Name) continue;
int i = 0;
foreach (CutPoint argumentCutPoint in argumentCutPoints) {
if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex))
grammar.AddAllowedChildSymbol(invokeSym, child, i);
i++;
}
}
}
}
private ISymbolicExpressionTree GenerateSimpleTree(ISymbolicExpressionTreeGrammar grammar)
{
var branch = new SimpleSymbol("branch", "", 2, 2);
var leaf = new SimpleSymbol("leaf", "", 0, 0);
var root = new SymbolicExpressionTreeTopLevelNode(branch);
root.SetGrammar(grammar);
var branch0 = new SymbolicExpressionTreeNode(branch);
var branch1 = new SymbolicExpressionTreeNode(branch);
var leaf0 = new SymbolicExpressionTreeNode(leaf);
var leaf1 = new SymbolicExpressionTreeNode(leaf);
var leaf2 = new SymbolicExpressionTreeNode(leaf);
var leaf3 = new SymbolicExpressionTreeNode(leaf);
root.AddSubtree(branch0);
root.AddSubtree(branch1);
branch0.AddSubtree(leaf0);
branch0.AddSubtree(leaf1);
branch1.AddSubtree(leaf2);
branch1.AddSubtree(leaf3);
return(new SymbolicExpressionTree(root));
}
internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable <CutPoint> argumentCutPoints)
{
if (!grammar.ContainsSymbol(startCutPoint.Child.Symbol))
{
return;
}
var invokeSym = new InvokeFunction(functionName);
grammar.AddSymbol(invokeSym);
grammar.SetSubtreeCount(invokeSym, nArgs, nArgs);
//allow invoke symbol everywhere, where the child of the startCutPoint was allowed
SetAllowedParentSymbols(grammar, startCutPoint.Child.Symbol, invokeSym);
if (nArgs > 0)
{
//set allowed child symbols of invoke symbol
foreach (ISymbol child in grammar.Symbols)
{
if (child.Name == invokeSym.Name)
{
continue;
}
int i = 0;
foreach (CutPoint argumentCutPoint in argumentCutPoints)
{
if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex))
{
grammar.AddAllowedChildSymbol(invokeSym, child, i);
}
i++;
}
}
}
}
protected SymbolicExpressionGrammar(bool deserializing)
: base(deserializing)
{
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
}
protected SymbolicExpressionGrammar(SymbolicExpressionGrammar original, Cloner cloner)
: base(original, cloner) {
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
foreach (ISymbol symbol in symbols.Values)
RegisterSymbolEvents(symbol);
programRootSymbol = cloner.Clone(original.programRootSymbol);
startSymbol = cloner.Clone(original.StartSymbol);
defunSymbol = cloner.Clone(original.defunSymbol);
maximumFunctionArguments = original.maximumFunctionArguments;
minimumFunctionArguments = original.minimumFunctionArguments;
maximumFunctionDefinitions = original.maximumFunctionDefinitions;
minimumFunctionDefinitions = original.minimumFunctionDefinitions;
}
protected SymbolicExpressionGrammar(string name, string description)
: base(name, description) {
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
programRootSymbol = new ProgramRootSymbol();
AddSymbol(programRootSymbol);
SetSubtreeCount(programRootSymbol, 1, 1);
startSymbol = new StartSymbol();
AddSymbol(startSymbol);
SetSubtreeCount(startSymbol, 1, 1);
defunSymbol = new Defun();
AddSymbol(defunSymbol);
SetSubtreeCount(defunSymbol, 1, 1);
AddAllowedChildSymbol(programRootSymbol, startSymbol, 0);
UpdateAdfConstraints();
}
protected SymbolicExpressionTreeTopLevelNode(SymbolicExpressionTreeTopLevelNode original, Cloner cloner)
: base(original, cloner)
{
grammar = cloner.Clone(original.Grammar);
}
public void SetGrammar(ISymbolicExpressionTreeGrammar grammar)
{
this.grammar = grammar;
}
public CutPoint(ISymbolicExpressionTreeNode parent, int childIndex) {
this.Parent = parent;
this.ChildIndex = childIndex;
this.Child = null;
this.grammar = parent.Grammar;
}
public CutPoint(ISymbolicExpressionTreeNode parent, ISymbolicExpressionTreeNode child) {
this.Parent = parent;
this.Child = child;
this.ChildIndex = parent.IndexOfSubtree(child);
this.grammar = parent.Grammar;
}
protected SymbolicExpressionGrammar(StorableConstructorFlag _) : base(_)
{
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
}
protected SymbolicExpressionTreeTopLevelNode(SymbolicExpressionTreeTopLevelNode original, Cloner cloner)
: base(original, cloner) {
grammar = cloner.Clone(original.Grammar);
}
public void SetGrammar(ISymbolicExpressionTreeGrammar grammar) {
this.grammar = grammar;
}
public static void IsValid(ISymbolicExpressionTreeGrammar grammar) {
Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count());
foreach (ISymbol symbol in grammar.AllowedSymbols) {
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count());
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) {
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count());
}
}
foreach (var symbol in grammar.ModifyableSymbols) {
//check if every symbol has at least one allowed child
for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++)
Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Any());
}
}
protected SymbolicExpressionGrammar(bool deserializing)
: base(deserializing) {
emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this);
}
