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)); }