public void TestAssignAdd() { var buildResult = buildParser(); Assert.False(buildResult.IsError); var parser = buildResult.Result; ParseResult <WhileToken, WhileAST> result = parser.Parse("(a:=1+1)"); Assert.False(result.IsError); Assert.NotNull(result.Result); Assert.IsType <SequenceStatement>(result.Result); SequenceStatement seq = result.Result as SequenceStatement; Assert.IsType <AssignStatement>(seq.Get(0)); AssignStatement assign = seq.Get(0) as AssignStatement; Assert.Equal("a", assign.VariableName); Expression val = assign.Value; Assert.IsType <BinaryOperation>(val); BinaryOperation bin = val as BinaryOperation; Assert.Equal(BinaryOperator.ADD, bin.Operator); Assert.Equal(1, (bin.Left as IntegerConstant)?.Value); Assert.Equal(1, (bin.Right as IntegerConstant)?.Value); }
public override void Visit(AssignStatement stmt) { StartElement("assignStatement"); Attribute("identifier", stmt.Name); stmt.ValueExp.AcceptVisitor(this); EndElement(); }
public Void Visit(AssignStatement assignStatement, SortedSet <string> free) { assignStatement.s.Accept(this, free); free.Remove(assignStatement.id); return(null); }
public Type Visit(AssignStatement assignStatement) { if (!Environment.VariableType.ContainsKey(assignStatement.id)) { var err = new TypeErrorMessage(); throw new TypeException(err.ErrorOutput(TypeErrorMessage.ErrorCode.ID, assignStatement)); } var type = Environment.VariableType[assignStatement.id]; var type_text = type.GetType().Name; var result = assignStatement.s.Accept(this); if (result == null) { var err = new TypeErrorMessage(); throw new TypeException(err.ErrorOutput(TypeErrorMessage.ErrorCode.ASN_1, assignStatement)); } var result_type_text = result.GetType().Name; if (IsVoidType(result_type_text)) { var err = new TypeErrorMessage(); throw new TypeException(err.ErrorOutput(TypeErrorMessage.ErrorCode.ASN_1, assignStatement)); } if (result_type_text != type_text) { var err = new TypeErrorMessage(); throw new TypeException(err.ErrorOutput(TypeErrorMessage.ErrorCode.ASN_2, assignStatement)); } return(type); }
public WhileAST assignStmt(Token <WhileTokenGeneric> variable, Token <WhileTokenGeneric> discardAssign, Expression value) { var assign = new AssignStatement(variable.StringWithoutQuotes, value); return(assign); }
// public AstPrinterNode Visit(BinOperator node) // { // var printer = new AstPrinterNode(node.ToString()); // printer.AddChild(node.Left.Accept(this)); // printer.AddChild(node.Right.Accept(this)); // return printer; // } public AstPrinterNode Visit(AssignStatement node) { var printer = new AstPrinterNode(node.ToString()); printer.AddChild(node.Left.Accept(this)); printer.AddChild(node.Right.Accept(this)); return(printer); }
public Statement Visit(AssignStatement assignStatement) { assignStatement.id = State.UnShadow(assignStatement.id); //Console.WriteLine($"**********Assign STATMENT:{assignStatement.id} **********"); assignStatement.s.Accept(this); return(assignStatement); }
private static IEnumerable <UnifiedExpression> CreateAssignStatement( AssignStatement statement) { yield return(UnifiedBinaryExpression.Create( CreatePhrase(statement.Left), UnifiedBinaryOperator.Create("=", UnifiedBinaryOperatorKind.Assign), CreatePhrase(statement.Right))); }
public static AssignStatement CreateAssignStatement(Variable variable, IExpression expression, Token token) { AssignStatement result = CreateNode <AssignStatement>(token); result.SetVariable(variable); result.SetExpression(expression); return(result); }
public static AssignStatement BuildAssignStatement(IEnumerable <IExpression> leftPart, IEnumerable <IExpression> rightPart) { var statement = new AssignStatement(DefaultLineNumber); statement.SetLeftExpressions(leftPart); statement.SetRightExpressions(rightPart); return(statement); }
public void CSharpCodeGenerator_Assign() { var statement = new AssignStatement(new VariableReference("a"), 10); var generator = new CSharpCodeGenerator(); var result = generator.Write(statement); Assert.That.StringEquals(@"a = 10; ", result); }
/// <summary> /// Generates the code for a <see cref="AssignStatement"/>. /// </summary> /// <param name="statement">The statement</param> /// <returns>A BaZic code</returns> private string GenerateAssignStatement(AssignStatement statement) { Requires.NotNull(statement.LeftExpression, nameof(statement.LeftExpression)); Requires.NotNull(statement.RightExpression, nameof(statement.RightExpression)); var leftExpression = GenerateExpression(statement.LeftExpression); var rightExpression = GenerateExpression(statement.RightExpression); return($"{leftExpression} = {rightExpression}"); }
public bool VisitNode(AssignStatement node) { // reference = expression; Write(""); node.Target.AcceptVisitor(this); Append(" = "); node.Value.AcceptVisitor(this); return(true); }
private Statement readAS() { AssignStatement _as = new AssignStatement(); Console.WriteLine("Input variable name:"); _as.setVar(Console.ReadLine()); Console.WriteLine("Input variable value:"); _as.setE(readExpression()); return(_as); }
void ButtonOKClick(object sender, EventArgs e) { String variable = textBoxVariable.Text; AssignStatement asstm = new AssignStatement(); asstm.setVar(variable); asstm.setE(this.expression); stmt = asstm; finished(); }
public override void Visit(AssignStatement stmt) { cb.WriteIndent(); cb.Write("{0} = ", stmt.Name); stmt.ValueExp.AcceptVisitor(this); cb.Write(";"); cb.WriteLine(); }
public void interpretNextMT() { for (int i = 1; i <= r.getNumProg(); ++i) { Statement st = r.getPS(i).es.top(); r.getPS(i).es.pop(); if (st is AssignStatement) { AssignStatement _as = (AssignStatement)st; r.getPS(i).vt.set( _as.getVar(), _as.getE().eval(r.getPS(i).vt, r.getPS(i).hp)); r.getPS(i).vt.printTable(); } else if (st is CompoundStatement) { CompoundStatement cs = (CompoundStatement)st; r.getPS(i).es.push(cs.getS2()); r.getPS(i).es.push(cs.getS1()); } else if (st is IfStatement) { IfStatement _is = (IfStatement)st; if (_is.getE().eval(r.getPS(i).vt, r.getPS(i).hp) != 0) { r.getPS(i).es.push(_is.getS1()); } else { r.getPS(i).es.push(_is.getS2()); } } else if (st is PrintStatement) { PrintStatement pr = (PrintStatement)st; r.getPS(i).ob.add(pr.getE().eval(r.getPS(i).vt, r.getPS(i).hp).ToString()); } else if (st is ForkStatement) { r.addPs(r.getPS(i).ob, r.getPS(i).vt, ((ForkStatement)st).getS()); } else if (st is WHStatement) { WHStatement wh = (WHStatement)st; int addr = r.getPS(i).vt.get(wh.getVN()); r.getPS(i).hp.mod(addr, wh.getV().eval(r.getPS(i).vt, r.getPS(i).hp)); } if (r.getPS(i).es.isEmpty()) { r.removePs(i); --i; } } }
public object Visit_Assign(AssignStatement node) { TreeViewItem item = new TreeViewItem(); item.IsExpanded = true; item.Header = "Assign (=)"; item.Items.Add(node.Variable.Visit(this)); item.Items.Add(node.Expression.Visit(this)); return(item); }
public void Analyze(AssignStatement assignment) { this.assignment = assignment; foreach (Expression e in assignment.Left) { FieldExpression field = e as FieldExpression; if (null != field) { analyzer.SaveFieldExpressionession(field, assignment.Right); } e.Walk(this); } }
protected override void VisitAssignStatement(AssignStatement tree) { _TrySetResult(tree); if (_result != null) { return; } foreach (var exp in tree.var_list) { VisitAnySyntaxTree(exp); } VisitAnySyntaxTree(tree.exp_list); }
private IStatement AssignStatement() { Var var = Variable(); Token token = currentToken; EatToken(TokenType.ASSIGN); IExpression right = Expression(); EatToken(TokenType.SEMICOLON); IStatement node = new AssignStatement(var, right, token); return(node); }
private FieldReference BuildDelegateToken(ClassEmitter proxy) { var callback = proxy.CreateStaticField(namingScope.GetUniqueName("callback_" + method.Method.Name), delegateType); var createDelegate = new MethodInvocationExpression( null, DelegateMethods.CreateDelegate, new TypeTokenExpression(delegateType), NullExpression.Instance, new MethodTokenExpression(method.MethodOnTarget)); var bindDelegate = new AssignStatement(callback, new ConvertExpression(delegateType, createDelegate)); proxy.ClassConstructor.CodeBuilder.AddStatement(bindDelegate); return(callback); }
private bool Visit(AssignStatement stmt) { AssertNotConstant(stmt); var value = Visit(stmt.Value); if (stmt.Truncate != null) { value = value.Resize(stmt.Truncate.Value); } if (stmt.Reference is PortReference port) { switch (port.PortInfo.Target) { case MachinePorts.Input: throw new InterpreterException("Cannot write to input", stmt.Span); case MachinePorts.Output: if (value.Length > port.BitSize) { throw new InterpreterException("Value is longer than output", stmt.Span); } Machine.WriteOutput(port.StartIndex, value.Bits); break; case MachinePorts.Register: Machine.WriteRegister(port.StartIndex, value); break; default: throw new InterpreterException("Unknown assignment target", stmt.Span); } } else if (stmt.Reference is LocalReference local) { Locals[local.Name] = value; } else { throw new InterpreterException("Unknown reference type", stmt.Span); } return(false); }
public void TestIfThenElse() { var buildResult = buildParser(); Assert.False(buildResult.IsError); var parser = buildResult.Result; ParseResult <WhileToken, WhileAST> result = parser.Parse("if true then (a := \"hello\") else (b := \"world\")"); Assert.False(result.IsError); Assert.NotNull(result.Result); Assert.IsType <SequenceStatement>(result.Result); SequenceStatement seq = result.Result as SequenceStatement; Assert.IsType <IfStatement>(seq.Get(0)); IfStatement si = seq.Get(0) as IfStatement; Expression cond = si.Condition; Assert.IsType <BoolConstant>(cond); Assert.True((cond as BoolConstant).Value); Statement s = si.ThenStmt; Assert.IsType <SequenceStatement>(si.ThenStmt); SequenceStatement thenBlock = si.ThenStmt as SequenceStatement; Assert.Equal(1, thenBlock.Count); Assert.IsType <AssignStatement>(thenBlock.Get(0)); AssignStatement thenAssign = thenBlock.Get(0) as AssignStatement; Assert.Equal("a", thenAssign.VariableName); Assert.IsType <StringConstant>(thenAssign.Value); Assert.Equal("hello", (thenAssign.Value as StringConstant).Value); ; Assert.IsType <SequenceStatement>(si.ElseStmt); SequenceStatement elseBlock = si.ElseStmt as SequenceStatement; Assert.Equal(1, elseBlock.Count); Assert.IsType <AssignStatement>(elseBlock.Get(0)); AssignStatement elseAssign = elseBlock.Get(0) as AssignStatement; Assert.Equal("b", elseAssign.VariableName); Assert.IsType <StringConstant>(elseAssign.Value); Assert.Equal("world", (elseAssign.Value as StringConstant).Value); }
private AssignStatement ParseAssignStatement() { var stmt = new AssignStatement { Token = CurToken }; switch (CurToken.Type) { case TokenType.Ident: stmt.Name = new Identifier { Token = CurToken, Value = CurToken.Literal }; break; case TokenType.Constant: stmt.Name = new Constant { Token = CurToken, Value = CurToken.Literal }; break; case TokenType.InstanceVariable: stmt.Name = new InstanceVariable { Token = CurToken, Value = CurToken.Literal }; break; } if (!ExpectPeek(TokenType.Assign)) { return(null); } NextToken(); stmt.Value = ParseExpression(LOWEST); if (PeekTokenIs(TokenType.Semicolon)) { NextToken(); } return(stmt); }
private void CompileAssignStmt(InstructionSet instructionSet, AssignStatement statement, Scope scope, LocalTable localTable) { CompileExpression(instructionSet, statement.Value, scope, localTable); if (statement.Name is Identifier) { var idtfr = statement.Name as Identifier; var indexDepth = localTable.SetLCL(idtfr.Value, localTable.Depth); instructionSet.Define(InstructionType.SetLocal, indexDepth.Item1, indexDepth.Item2); } else if (statement.Name is InstanceVariable) { var iv = statement.Name as InstanceVariable; instructionSet.Define(InstructionType.SetInstanceVariable, iv.Value); } else if (statement.Name is Constant) { instructionSet.Define(InstructionType.SetConstant, statement.Name as Constant); } }
private void SemanticCheck(AssignStatement ast, CompilerContext context) { var valType = expressionTyper.TypeExpression(ast.Value, context); var varExists = context.VariableExists(ast.VariableName); //ast.CompilerScope = context.CurrentScope; if (varExists) { var varType = context.GetVariableType(ast.VariableName); if (varType != valType) { throw new TypingException($"bad assignment : {valType} expecting {varType}"); } } else { var creation = context.SetVariableType(ast.VariableName, valType); ast.IsVariableCreation = creation; ast.CompilerScope = context.CurrentScope; } }
public AssignStatement DecompileAssign() { PopByte(); var left = DecompileExpression(); if (left == null || !typeof(SymbolReference).IsAssignableFrom(left.GetType())) { return(null); //ERROR ? } var right = DecompileExpression(); if (right == null) { return(null); //ERROR ? } var statement = new AssignStatement(left as SymbolReference, right, null, null); StatementLocations.Add(StartPositions.Pop(), statement); return(statement); }
public Type Visit(AssignStatement assignStatement, FunctionGeneratorEnvironment arg) { var type = arg.GetIdentifierType(assignStatement.id); var offset = arg.GetIdentifierOffset(assignStatement.id); Program.Emit(T42Instruction.LVAL(offset)); assignStatement.s.Accept(this, arg); if (type.GetType() == typeof(IntType)) { Program.Emit(T42Instruction.ASSINT); Program.Emit(T42Instruction.RVALINT(offset)); } else { Program.Emit(T42Instruction.ASSBOOL); Program.Emit(T42Instruction.RVALBOOL(offset)); } return(type); }
/// <summary> /// Inline an assignment statement in the case of where the right expression is a method invocation. /// </summary> /// <param name="assignStatement">The assign statement.</param> /// <returns>A list of statement that represents the assignment.</returns> private List <Statement> InlineAssign(AssignStatement assignStatement) { var newStatements = new List <Statement>(); if (assignStatement.RightExpression.IsExactly <InvokeMethodExpression>()) { var stmts = InlineMethodInvocation((InvokeMethodExpression)assignStatement.RightExpression, assignStatement.LeftExpression); if (stmts != null) { newStatements.AddRange(stmts); return(newStatements); } } assignStatement.LeftExpression = OptimizeExpression(assignStatement.LeftExpression); assignStatement.RightExpression = OptimizeExpression(assignStatement.RightExpression); newStatements.Add(assignStatement); return(newStatements); }
/// <summary> /// Parses a statement. /// </summary> public static bool AcceptStatement(string Text, int Start, out Statement Statement, out int LastChar) { // Constant assignment string varname; if (AcceptString(Text, Start, "const", out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { if (AcceptWord(Text, LastChar, out varname, out LastChar) && ValidVariable(varname)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { if (AcceptString(Text, LastChar, "=", out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { Expression value; if (AcceptExpression(Text, LastChar, out value, out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ";", out LastChar)) { Statement = new ConstantStatement(varname, value); return true; } } } } } } } } // Define Expression type; if (AcceptTightExpression(Text, Start, out type, out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { if (AcceptWord(Text, LastChar, out varname, out LastChar) && ValidVariable(varname)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { if (AcceptString(Text, LastChar, "=", out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { Expression value; if (AcceptExpression(Text, LastChar, out value, out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ";", out LastChar)) { Statement = new DefineStatement(type, varname, value); return true; } } } } } } } } // Assign if (AcceptWord(Text, Start, out varname, out LastChar) && ValidVariable(varname)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { if (AcceptString(Text, LastChar, "=", out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { Expression value; if (AcceptExpression(Text, LastChar, out value, out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ";", out LastChar)) { Statement = new AssignStatement(varname, value); return true; } } } } } } // Return if (AcceptString(Text, Start, "return", out LastChar)) { if (AcceptWhitespace(Text, LastChar, out LastChar) > 0) { Expression returnvalue; if (AcceptExpression(Text, LastChar, out returnvalue, out LastChar)) { AcceptWhitespace(Text, LastChar, out LastChar); if (AcceptString(Text, LastChar, ";", out LastChar)) { Statement = new ReturnStatement(returnvalue); return true; } } } } Statement = null; return false; }