internal string ToCode(GrammaticalObject go)
{
int moddedCodon = 0;
if (go[NewNonTerminalName] == null || go[NewNonTerminalName].Count == 0)
{
throw new EmptyProductionRuleCollection(NewNonTerminalName, go);
}
if (go[NewNonTerminalName].Count > 1)
{
byte codon = go.instance.NextCodon();
if (go.FirstUsedIndex == -1)
{
go.FirstUsedIndex = go.instance.codonPosition;
}
go.LastUsedIndex = go.instance.codonPosition;
moddedCodon = (int)codon % go[NewNonTerminalName].Count;
}
ProductionRule chosenProductionRule = go[NewNonTerminalName][moddedCodon];
return(go.ConvertToCode(chosenProductionRule));
}
private static Tuple <int, bool> EvaluateExpression(string code, GrammaticalObject go)
{
bool canExecute = !code.Contains("a") && !code.Contains("b") && !code.Contains("c") && !code.Contains("d") && !code.Contains("e") && !code.Contains("f");
bool canParse = canExecute && code.Length == 1;
ExecutionParameters parameters = new ExecutionParameters(genericCodeWrapper.Replace("TYPE", "int"), "CodeExecutor.Executor", "Execute");
int calculatedValue = 0;
if (canParse)
{
calculatedValue = int.Parse(code);
}
else if (canExecute)
{
try
{
calculatedValue = (int)Executor.Execute(parameters, "return " + code + ";");
}
catch
{
canExecute = false;
}
}
return(new Tuple <int, bool>(calculatedValue, canExecute));
}
public void Check(GrammaticalObject go)
{
if (!Lambda(go))
{
throw new ErrorCheckFailException(go, this);
}
}
internal string Generate(Chromosome genome, GenerationStats currentGenerationStats)
{
_genome = genome;
_currentGenerationStats = currentGenerationStats;
string code = "";
bool compileAgain = true;
bool correctionApplied = false;
while (compileAgain)
{
try
{
codonPosition = -1;
GrammaticalObject go = (GrammaticalObject)Activator.CreateInstance(StartingGO.GetType());
go.instance = this;
go.Initialize(go.GetInitialProductionRules());
code = ConvertToCode(StartingProductionRule, go);
break;
}
catch (ErrorCheck.ErrorCheckFailException e)
{
compileAgain = false;
List <GrammaticalObject> stackTrace = e.exceptionGO.GetStackTrace();
_currentGenerationStats.failedErrorChecks++;
for (int stackTracePosition = 0; stackTracePosition < stackTrace.Count && !compileAgain; stackTracePosition++)
{
int initialPosition = stackTrace[stackTracePosition].FirstUsedIndex;
int finalPosition = stackTrace[stackTracePosition].LastUsedIndex;
if (CanCorrectChromosome(_genome, initialPosition, finalPosition))
{
compileAgain = true;
correctionApplied = true;
CorrectChromosome(_genome, initialPosition, finalPosition);
}
}
if (!compileAgain)
{
_currentGenerationStats.failedErrorCorrections++;
throw new ErrorCorrectionFailedException();
}
}
}
if (correctionApplied)
{
_currentGenerationStats.successfulErrorCorrections++;
}
return(code);
}
public T CreateChild <T>() where T : GrammaticalObject
{
GrammaticalObject blueprintGO = instance.BluePrintGOs.Find(x => x.GetType() == typeof(T));
if (blueprintGO == null)
{
throw new BluePrintGONotFound(typeof(T));
}
GrammaticalObject go = blueprintGO.GetClone();
go.instance = instance;
go.Initialize(this);//Creates a copy that has the same production rules as the parent
go.Parent = this;
return((T)go);
}
internal string ConvertToCode(ProductionRule productionRule, GrammaticalObject go)
{
string finalCode = "";
foreach (Expression expr in productionRule)
{
if (expr is Terminal)
{
finalCode += (Terminal)expr;
}
else if (expr is NonTerminal)
{
NonTerminal nonTerminal = (NonTerminal)expr;
if (nonTerminal.NewGrammaticalObjectLambda == null)
{
finalCode += nonTerminal.ToCode(go);
}
else
{
finalCode += nonTerminal.ToCode(nonTerminal.NewGrammaticalObjectLambda(go));
}
}
else if (expr is ErrorCheck)
{
((ErrorCheck)expr).Check(go);
//If an exception is not thrown, the check was passed
_currentGenerationStats.passedErrorChecks++;
}
else if (expr is ObjectAction)
{
(((ObjectAction)expr)).Execute(go);
}
else if (expr is ObjectFunction)
{
finalCode += ConvertToCode(((ObjectFunction)expr).Execute(go), go);
}
else
{
throw new NotImplementedException();
}
}
return(finalCode);
}
internal void Execute(GrammaticalObject go)
{
Lambda(go);
}
public ErrorCheckFailException(GrammaticalObject exceptionGO, ErrorCheck failedEC) : base("Failed Error Check in GrammaticalObject \"" + exceptionGO.ToString() + "\".")
{
this.exceptionGO = exceptionGO;
this.failedEC = failedEC;
}
public EmptyProductionRuleCollection(string nonTerminalName, GrammaticalObject go) : base("The nonterminal \"" + nonTerminalName + "\" in Grammatical Object \"" + go.GetType().FullName + "\" is empty or null.")
{
}
internal ProductionRule Execute(GrammaticalObject go)
{
return(Lambda(go));
}
