protected Parsed.VariableAssignment ListDeclaration()
{
Whitespace();
var id = Parse(Identifier);
if (id != "LIST")
{
return(null);
}
Whitespace();
var varName = Expect(Identifier, "list name") as string;
Whitespace();
Expect(String("="), "the '=' for an assignment of the list definition");
Whitespace();
var definition = Expect(ListDefinition, "list item names") as ListDefinition;
if (definition)
{
definition.name = varName;
var result = new VariableAssignment(varName, definition);
return(result);
}
return(null);
}
private static VariableAssignment CreateVariables2()
{
var variables = new VariableAssignment();
variables.Assign("x", 3);
return(variables);
}
public void GenerateVarAssignment(VariableAssignment varAssignmentNode, ILGenerator ilGenerator)
{
GenerateExpression(varAssignmentNode.AssignmentValue, ilGenerator);
PopAndStore(varAssignmentNode.VariableName.VariableDeclaration.FullName,
varAssignmentNode.VariableName.VariableDeclaration.Index, ilGenerator);
}
public override bool TryParse(TokenStack tokens, out GraphNode node)
{
if (tokens.ExpectSequence(TokenType.Identifier, TokenType.ColonSymbol))
{
var queue = new Queue <Token>();
var identifier = tokens.Pop();
var colon = tokens.Pop();
queue.Enqueue(identifier);
queue.Enqueue(colon);
var valueSyntax = new ValueSyntax();
var valueToken = tokens.Peek();
if (valueSyntax.TryParse(tokens, out GraphNode value))
{
queue.Enqueue(valueToken);
node = new VariableAssignment(queue, identifier.Value, (Value)value);
return(true);
}
else
{
while (queue.Count > 0)
{
tokens.Push(queue.Dequeue());
}
}
}
node = null;
return(false);
}
public static void GenerateCode(VariableAssignment assignment, GeneratorContext builder)
{
if (assignment.IsDeclaration)
{
if (assignment.HasValue)
{
builder.AddCode(assignment.Value);
}
else
{
builder.AddOp(new LiteralValue(assignment.DeclarationType.Default()), assignment.TypeToken);
}
builder.AddOp(new VariableCreate(assignment.Name), assignment.NameToken);
}
else
{
if (assignment.Indices.Count > 1)
{
throw new NotImplementedException("Only one level of indexing is supported at the moment");
}
if (assignment.BuiltInFunctionHint != null)
{
if (assignment.Indices.Count == 0)
{
builder.AddOp(new VariableGet(assignment.Name), assignment.NameToken);
}
else
{
builder.AddOp(new VariableGet(assignment.Name));
builder.AddCode(assignment.Indices[0].Index);
builder.AddOp(new ArrayElementGet());
}
}
if (assignment.Value != null)
{
builder.AddCode(assignment.Value);
}
if (assignment.BuiltInFunctionHint != null)
{
builder.AddOp(new CallBuiltIn(assignment.BuiltInFunctionHint), assignment.OperatorToken);
}
if (assignment.Indices.Count == 0)
{
builder.AddOp(new VariableSet(assignment.Name), assignment.NameToken);
}
else
{
builder.AddCode(assignment.Indices[0].Index);
builder.AddOp(new ArrayElementSet(assignment.Name),
assignment.NameToken);
}
}
}
protected Parsed.Object TempDeclarationOrAssignment()
{
Whitespace();
bool isNewDeclaration = ParseTempKeyword();
Whitespace();
Identifier varIdentifier = null;
if (isNewDeclaration)
{
varIdentifier = (Identifier)Expect(IdentifierWithMetadata, "variable name");
}
else
{
varIdentifier = Parse(IdentifierWithMetadata);
}
if (varIdentifier == null)
{
return(null);
}
Whitespace();
// += -=
bool isIncrement = ParseString("+") != null;
bool isDecrement = ParseString("-") != null;
if (isIncrement && isDecrement)
{
Error("Unexpected sequence '+-'");
}
if (ParseString("=") == null)
{
// Definitely in an assignment expression?
if (isNewDeclaration)
{
Error("Expected '='");
}
return(null);
}
Expression assignedExpression = (Expression)Expect(Expression, "value expression to be assigned");
if (isIncrement || isDecrement)
{
var result = new IncDecExpression(varIdentifier, assignedExpression, isIncrement);
return(result);
}
else
{
var result = new VariableAssignment(varIdentifier, assignedExpression);
result.isNewTemporaryDeclaration = isNewDeclaration;
return(result);
}
}
protected override void visitVariableAssignment(VariableAssignment statement)
{
appendLabel(statement);
output.writeVariableAssignmentTarget(statement.Target);
writer.Append(" := ");
output.writeExpression(statement.Value);
writer.Append(";").NewLine();
}
public void VisitVariableAssignment(VariableAssignment variableAssignment)
{
if (!Variables.ContainsKey(variableAssignment.VariableName))
{
throw MakeError(variableAssignment.Expr, $"Присваивание в неизвестную переменную {variableAssignment.VariableName}");
}
Variables[variableAssignment.VariableName] = Calc(variableAssignment.Expr);
}
private static VariableAssignment CreateVariables3()
{
var variables = new VariableAssignment();
variables.Assign("a", 1);
variables.Assign("b", 1);
variables.Assign("c", 1);
return(variables);
}
public void VisitVariableAssignment(VariableAssignment variableAssignment)
{
if (!variables.TryGetValue(variableAssignment.VariableName, out var variable))
{
throw MakeError(variableAssignment.Expr, $"Присваивание в неизвестную переменную {variableAssignment.VariableName}");
}
CompileExpression(variableAssignment.Expr);
cil.Emit(OpCodes.Stloc, variable);
}
private static IEnumerable <IInstruction> GetVariableAssignmentInstructions(
this VariableAssignment variableAssignment)
{
List <IInstruction> instructions = new List <IInstruction>();
instructions.AddRange(variableAssignment.AssignmentValue.GetInstructions());
instructions.Add(GetStoreInstruction(variableAssignment.VariableName.VariableDeclaration));
return(instructions);
}
public override void ResolveReferences(Story context)
{
base.ResolveReferences(context);
if (VariableAssignment.IsReservedKeyword(constantName))
{
Error("cannot use '" + constantName + "' as a constant since it's a reserved ink keyword");
return;
}
}
protected Expression ExpressionVariableName()
{
List <string> path = Interleave <string> (Identifier, Exclude(Spaced(String("."))));
if (path == null || VariableAssignment.IsReservedKeyword(path[0]))
{
return(null);
}
return(new VariableReference(path));
}
protected Parsed.Object VariableDeclaration()
{
Whitespace();
var id = Parse(Identifier);
if (id != "VAR")
{
return(null);
}
Whitespace();
var varName = Expect(Identifier, "variable name") as string;
Whitespace();
Expect(String("="), "the '=' for an assignment of a value, e.g. '= 5' (initial values are mandatory)");
Whitespace();
var definition = Expect(Expression, "initial value for ");
var expr = definition as Parsed.Expression;
if (expr)
{
if (!(expr is Number || expr is StringExpression || expr is DivertTarget || expr is VariableReference || expr is List))
{
Error("initial value for a variable must be a number, constant, list or divert target");
}
if (Parse(ListElementDefinitionSeparator) != null)
{
Error("Unexpected ','. If you're trying to declare a new list, use the LIST keyword, not VAR");
}
// Ensure string expressions are simple
else if (expr is StringExpression)
{
var strExpr = expr as StringExpression;
if (!strExpr.isSingleString)
{
Error("Constant strings cannot contain any logic.");
}
}
var result = new VariableAssignment(varName, expr);
result.isGlobalDeclaration = true;
return(result);
}
return(null);
}
protected Parsed.Object TempDeclarationOrAssignment()
{
Whitespace();
bool isNewDeclaration = ParseTempKeyword();
Whitespace();
string varName = null;
if (isNewDeclaration)
{
varName = (string)Expect(Identifier, "variable name");
}
else
{
varName = Parse(Identifier);
}
if (varName == null)
{
return(null);
}
Whitespace();
// Optional assignment
Expression assignedExpression = null;
if (ParseString("=") != null)
{
assignedExpression = (Expression)Expect(Expression, "value expression to be assigned to temporary variable");
}
// If it's neither an assignment nor a new declaration,
// it's got nothing to do with this rule (e.g. it's actually just "~ myExpr" or even "~ myFunc()"
else if (!isNewDeclaration)
{
return(null);
}
// Default zero assignment
else
{
assignedExpression = new Number(0);
}
var result = new VariableAssignment(varName, assignedExpression);
result.isNewTemporaryDeclaration = isNewDeclaration;
return(result);
}
public void EnvironmentTest(Tuple <IFifthType, object> a)
{
(IFifthType t, object o) = a;
var sut = new fifth.VirtualMachine.Environment(null);
sut.Should().NotBeNull();
sut.IsEmpty.Should().BeTrue();
sut[new VariableReference("hello")] = new VariableAssignment(t, o);
sut.IsEmpty.Should().BeFalse();
IVariableAssignment x = sut[new VariableReference("hello")];
x.Value.Should().Be(o);
x.FifthType.Should().Be(t);
}
private Color GetColor(SprakExpression item)
{
return(item switch
{
Block block => GetColor(block.Header),
Command _ => Colors.Blue,
FunctionCall _ => Colors.Orange,
FunctionHeader _ => Colors.Blue,
IfHeader _ => Colors.DarkRed,
LiteralArrayGet _ => Colors.Yellow,
LiteralGet _ => Colors.Yellow,
LoopHeader _ => Colors.Red,
MainHeader _ => Colors.Orange,
OperatorCall _ => Colors.Green,
Return _ => Colors.Blue,
VariableAssignment _ => Colors.Orange,
VariableReference _ => Colors.Yellow,
_ => Colors.Black
});
public void TestEvolution()
{
Profiler.Reset();
var random = new SystemRandom(42);
var configuration = new ZeldaConfiguration(random);
var factory = new ZeldaGenomeFactory(configuration);
var initialVariables = new VariableAssignment();
var environment = new ZeldaEnvironment(new[] { initialVariables }, 10000);
var writer = File.CreateText("stats.csv");
var evolution = new ElitistEvolution(200, 100, factory, environment, ZeldaIndividual.NumAttributes, writer);
var genomes = evolution.Initialize();
// TODO Jonas: replace fixed weight multirank optimization by dynamic randomized weighting
// i.e. in some generations prefer some attribute over others
// evolve
for (int i = 0; i < 1000; i++)
{
Profiler.BeginFrame();
Console.WriteLine("gen " + i);
genomes = evolution.Evolve(genomes, random);
Profiler.EndFrame();
}
writer.Close();
var best = (ZeldaIndividual)evolution.GetBest(new TestComparer());
Console.WriteLine(best);
var crawler = best.Crawler;
var builder = new DotBuilder();
crawler.Express(builder);
// TODO: output genome to puzzle unit test (puzzle building statements)
Profiler.ExportToUnityProfileAnalyzer("w:\\EvolutionTest-TestEvolution.pdata");
}
public void CreateIndividual()
{
Profiler.Reset();
Profiler.BeginFrame();
var random = new SystemRandom(42);
var configuration = new ZeldaConfiguration(random);
var factory = new ZeldaGenomeFactory(configuration);
var initialVariables = new VariableAssignment();
var environment = new ZeldaEnvironment(new[] { initialVariables }, 10000);
var example = factory.CreateGenome();
var individual = environment.Evaluate(example);
Console.WriteLine("test: " + individual);
Profiler.EndFrame();
Profiler.ExportToUnityProfileAnalyzer("w:\\EvolutionTest-CreateIndividual.pdata");
}
private static void Process(this VariableAssignment variableAssignment)
{
var scope = variableAssignment;
variableAssignment.VariableName.Process();
var variableReturnType = variableAssignment.VariableName.ReturnType;
var assignmentValue = variableAssignment.AssignmentValue;
assignmentValue.Process();
if (assignmentValue.ReturnType != variableReturnType)
{
if (assignmentValue.ReturnType.IsCastableTo(variableReturnType))
{
assignmentValue.CastToType = variableReturnType;
}
else
{
throw new ScopeException(
$"Return type {assignmentValue.ReturnType} does not match {variableReturnType}");
}
}
}
internal List <Statement> GetStatements()
{
return(_variables.Select(variable =>
{
Expression literal;
if (variable.Value is int i)
{
literal = new IntegerLiteral("IntegerLiteral", Convert.ToString(i));
}
else if (variable.Value is bool b)
{
literal = new BooleanLiteral("BooleanLiteral", b);
}
else if (variable.Value is float f)
{
literal = new FloatLiteral("FloatLiteral", Convert.ToDecimal(f));
}
else if (variable.Value is DateTime d)
{
literal = new DateTimeLiteral("DateTimeLiteral", d);
}
else if (variable.Value is DateTimeOffset o)
{
literal = new DateTimeLiteral("DateTimeLiteral", o.UtcDateTime);
}
else
{
literal = new StringLiteral("StringLiteral", Convert.ToString(variable.Value));
}
var assignment = new VariableAssignment("VariableAssignment",
new Identifier("Identifier", variable.Name), literal);
return new OptionStatement("OptionStatement", assignment) as Statement;
}).ToList());
}
public virtual T applyToVariableAssignment(VariableAssignment operand)
{
return(applyToParseTreeNode(operand));
}
private void ResolveAssignment(VariableAssignment assignment, CompilationEnvironment env)
{
if (assignment.Indices.Count > 1)
{
env.Messages.AtExpression(assignment.Indices.Last().Index,
Messages.MultipleIndices);
}
if (!assignment.ParentBlockHint
.TryGetVariableInfo(assignment.Name, out VariableInfo nameInfo))
{
env.Messages.AtToken(assignment.NameToken,
Messages.UnrecognizedName, assignment.NameToken.Content);
return;
}
if (!assignment.IsDeclaration)
{
Block ancestor = assignment.ParentBlockHint;
while (ancestor != null && ancestor != nameInfo.Source)
{
ancestor = ancestor.ParentBlockHint;
}
if (ancestor == null)
{
env.Messages.AtToken(assignment.NameToken,
Messages.VariableFromDisconnectedBlock);
}
}
if (nameInfo.DeclaredType == null)
{
// I don't think this should be possible, but this is all
// very convoluted. I wish C# was more nullable-aware.
throw new Exception("Declaration with Declaration Type");
}
SprakType dstType;
if (assignment.Indices.Count == 0)
{
dstType = nameInfo.DeclaredType;
}
else
{
if (nameInfo.DeclaredType != SprakType.Array)
{
env.Messages.AtToken(assignment.NameToken,
Messages.CanOnlyIndexArrays, nameInfo.DeclaredType);
}
// Best we can do with array assignments until generic
// type tracking is introduced.
dstType = SprakType.Any;
}
SprakType srcType;
if (assignment.Value == null)
{
srcType = nameInfo.DeclaredType;
}
else if (assignment.Value.TypeHint != null)
{
srcType = assignment.Value.TypeHint;
}
else
{
srcType = SprakType.Any;
}
if (assignment.IsDeclaration)
{
if (assignment.Operator != Operator.Set)
{
env.Messages.AtToken(assignment.OperatorToken,
Messages.InvalidDeclarationOperator);
}
if (assignment.Indices.Count > 0)
{
env.Messages.AtExpression(assignment.Indices.First().Index,
Messages.InvalidIndexDeclaration);
}
}
else if (!assignment.Operator.IsAssignment)
{
env.Messages.AtToken(assignment.OperatorToken,
Messages.ExpectedAssignmentOperator, assignment.Operator.Text);
return;
}
else if (assignment.Operator.AssignmentOperation != null)
{
// I doubt I'll bother implementing right-only inputs.
// (Like --i) They don't show up much.
InputSides inputs;
SprakType left;
SprakType right;
if (!assignment.HasValue)
{
inputs = InputSides.Left;
left = srcType;
right = null;
}
else
{
inputs = InputSides.Both;
left = srcType;
right = dstType;
}
// We need the name of the function to called before assignment.
// That may or may not be the same name as that of the operator.
string name = assignment.Operator.AssignmentOperation;
OperatorTypeSignature signature
= new OperatorTypeSignature(left, right, inputs);
SignatureLookupResult lookupResult = env.SignatureLookup
.TryFindMatch(name, signature);
if (lookupResult.Success)
{
assignment.BuiltInFunctionHint = lookupResult.BuiltInFunction;
assignment.OpHint = lookupResult.OpBuilder;
srcType = lookupResult.BuiltInFunction.ReturnType;
}
else
{
string operation = assignment.ToString();
env.Messages.AtExpression(assignment,
Messages.UnresolvedOperation, operation);
srcType = SprakType.Any;
}
}
if (!env.AssignmentLookup.IsAssignable(srcType, dstType))
{
env.Messages.AtExpression(
assignment, Messages.AssignmentTypeMismatch, srcType, dstType);
}
}
public void ObserveVariableAssignmentStatement(VHDLCompilerInterface compiler, VariableAssignment statement)
{
IVariableAssignmentTarget interpretedTarget = statement.Target;
if (interpretedTarget is Expression)
{
string target = VHDLOperandGenerator.GetOperand(interpretedTarget as Expression, compiler, false);
string targetType = VHDLExpressionTypeGenerator.GetExpressionType(interpretedTarget as Expression, compiler);
string value = VHDLOperandGenerator.GetOperand(statement.Value, compiler);
VariableAssignTemplate template = new VariableAssignTemplate(target, value, targetType);
code = template.TransformText();
return;
}
}
public virtual void VisitVariableAssignmentInstruction(VariableAssignment variableAssignment) => Default(variableAssignment);
public DualNumber ComputeDelta(IPoint point, int index, double delta)
{
if (index < 0 || index >= n)
{
throw new IndexOutOfRangeException();
}
VariableAssignment[] assignments = new VariableAssignment[n];
for (int i = 0; i < n; i++)
{
Variable variable = variables[i];
double value = point[variable];
// Add delta to the selected variable.
if (i == index)
{
value += delta;
}
assignments[i] = new VariableAssignment(variable, value);
}
return Compute(new Point(assignments));
}
