public ForStatement(StatementList Conditions, StatementList Body) { this.Initialize = Conditions[0]; this.Condition = Conditions[1]; this.Step = Conditions[2]; this.Body = Body; }
internal Statement(IHost host) : base(host) { Attributes = new AttributeList(host); Children = new StatementList(host); Parameters = new ParameterList(host); }
public TableRowStatement(String var, Expression value, StatementList attributes, StatementList statements) { _var= var; _value = value; _attributes = attributes; _statements = statements; }
public GeneratedCode Parse(List<Token> _tokens) { Dictionary<string, Function> Functions = new Dictionary<string, Function>(); StatementList TopLevelStatements = new StatementList(); Tokens = _tokens; Position = 0; GetNextToken(); //Initialize first token while (true) { if (CurToken.Type == TokenType.EOF) break; if (CurToken.IsCharacter(";")) GetNextToken(); //eat ; else if (CurToken.IsIdentifier("function")) { Function func = ParseFunction(); Functions[func.Name] = func; } else TopLevelStatements.Add(ParseStatement()); } Function TopLevel = new Function(TopLevelStatements); return new GeneratedCode() { TopLevelStatements = TopLevel, Functions = Functions }; }
public override Expression VisitReturnValue(ReturnValue returnValue) { // return a default value of the same type as the return value TypeNode returnType = returnValue.Type; ITypeParameter itp = returnType as ITypeParameter; if (itp != null) { Local loc = new Local(returnType); UnaryExpression loca = new UnaryExpression(loc, NodeType.AddressOf, loc.Type.GetReferenceType()); StatementList statements = new StatementList(2); statements.Add(new AssignmentStatement(new AddressDereference(loca, returnType, false, 0), new Literal(null, SystemTypes.Object))); statements.Add(new ExpressionStatement(loc)); return new BlockExpression(new Block(statements), returnType); } if (returnType.IsValueType) return new Literal(0, returnType); return new Literal(null, returnType); }
public ForStatement(Statement Initialize, Statement Condition, Statement Step, StatementList Body) { this.Initialize = Initialize; this.Condition = Condition; this.Body = Body; this.Step = Step; }
private Statement() { Attributes = new AttributeList(); Children = new StatementList(); Parameters = new ParameterList(); IdentifierParts = new List<Identifier>(); Errors = new List<ParserError>(); }
public Loop(string loopVariable, Expression from, string upDown, Expression to, Expression withClause, StatementList stmts) { LoopVariable = loopVariable; InitialValue = from; EndingValue = to; StepDirection = upDown; Step = withClause; Statements = stmts; }
public Normalizer(TypeSystem typeSystem){ this.typeSystem = typeSystem; this.exitTargets = new StatementList(); this.continueTargets = new StatementList(); this.currentTryStatements = new Stack(); this.exceptionBlockFor = new TrivialHashtable(); this.visitedCompleteTypes = new TrivialHashtable(); this.EndIfLabel = new TrivialHashtable(); this.foreachLength = 7; this.WrapToBlockExpression = true; this.useGenerics = TargetPlatform.UseGenerics; }
public UnlessStatement(Expression condition, StatementList unlessBranch, StatementList elseBranch) { if (condition == null) { throw new ArgumentException("Invalid condition for IF statement."); } _conditionExpr = condition; _unlessBranchStatements = unlessBranch; _elseBranchStatements = elseBranch; }
public string Render(StatementList statements, object model) { var factory = _host.DependencyResolver.Resolve<IRendererFactory>(); StringBuilder sb = new StringBuilder(); foreach (var element in statements) { var renderer = factory.GetRenderer(element.Name); sb.AppendLine(renderer.Render(element, model)); } return sb.ToString().Trim(); }
public override Block VisitBlock(Block block){ if (block == null) return null; StatementList savedStatementList = this.CurrentStatementList; try{ StatementList oldStatements = block.Statements; int n = oldStatements == null ? 0 : oldStatements.Length; StatementList newStatements = this.CurrentStatementList = block.Statements = new StatementList(n); for (int i = 0; i < n; i++) newStatements.Add((Statement)this.Visit(oldStatements[i])); return block; }finally{ this.CurrentStatementList = savedStatementList; } }
public FilterStatement(String filterName, StatementList args) { _filterName = filterName; _filter = Utils.LiquidFilters[filterName]; if (args != null && args.Count > 0) { _arguments = new List<Expression>(); foreach (var statement in args) if (statement is Expression) _arguments.Add((Expression) statement); else throw new ArgumentException(String.Format("Wrong argument to filter: {0}", statement.Print(""))); } }
public OutputStatement(Expression expr, StatementList filters) { _expr = expr; if(filters!= null) { _filters = new List<FilterStatement>(); foreach (var filter in filters) { if(filter is FilterStatement) _filters.Add(filter as FilterStatement); else throw new ArgumentException(filter.Print(""),"filters"); } } }
public override void VisitStatementList(StatementList statements) { if (statements == null) return; for (int i = 0; i < statements.Count; i++) { var stmt = statements[i]; if (stmt == null) continue; if (stmt.SourceContext.IsValid) { this.currentSourceContext = stmt.SourceContext; } this.Visit(stmt); } }
public override Statement VisitBranch(Branch branch){ if (branch == null) return null; if (branch.Target == null) return null; branch.Condition = this.VisitExpression(branch.Condition); int n = this.localsStack.top+1; LocalsStack targetStack = (LocalsStack)this.StackLocalsAtEntry[branch.Target.UniqueKey]; if (targetStack == null){ this.StackLocalsAtEntry[branch.Target.UniqueKey] = this.localsStack.Clone(); return branch; } //Target block has an entry stack that is different from the current stack. Need to copy stack before branching. if (n <= 0) return branch; //Empty stack, no need to copy StatementList statements = new StatementList(n+1); this.localsStack.Transfer(targetStack, statements); statements.Add(branch); return new Block(statements); }
public Node Loop() { var idToken = Expect(TokenCategory.LOOP); var stmtList = new StatementList(); while (firstOfStatement.Contains(CurrentToken)) { stmtList.Add(Statement()); } Expect(TokenCategory.END); Expect(TokenCategory.ENDLINE); var result = new Loop() { stmtList }; result.AnchorToken = idToken; return(result); }
/// <summary> /// Finds the subsequent statement in this block that defines a condition code based on the /// result in expression <paramref name="exp"/>. /// </summary> /// <param name="p"></param> /// <param name="ax"></param> /// <returns></returns> public CondMatch FindConditionOf(StatementList stms, int iStm, Expression exp) { for (int i = iStm + 1; i < stms.Count; ++i) { if (!condm.Match(stms[i].Instruction)) { continue; } var grf = (Identifier)condm.CapturedExpressions("grf"); var condExp = condm.CapturedExpressions("exp"); if (grf.Storage is FlagGroupStorage && exp == condExp) { return(new CondMatch { FlagGroup = grf, src = exp, StatementIndex = i }); } } return(null); }
public void TestSelecColumnsWithAlias() { StatementList statementList = new StatementList() { Statements = new List <Statement>() { new SelectStatement() { SelectElements = new List <Expressions.SelectExpression>() { new SelectScalarExpression() { Expression = new ColumnReference() { Identifiers = new List <string>() { "c1" } }, Alias = "a" }, new SelectScalarExpression() { Expression = new ColumnReference() { Identifiers = new List <string>() { "c2" } }, Alias = "b" } } } } }; var expected = "SELECT c1 AS a, c2 AS b"; var actual = statementList.Print(); actual.Should().Be(expected); }
private string GetTableTypeBody(string sqlText) { var createTableTypeBody = new CodeWriter(); var parser = new TSql120Parser(false); var statementList = new StatementList(); IList <ParseError> errors; var script2 = parser.Parse(new StringReader(sqlText), out errors) as TSqlScript; if (errors.Count > 0) { var errorList = new StringBuilder(); foreach (var error in errors) { errorList.AppendLine($"{error.Message}<br/>"); } throw new ApplicationException(errorList.ToString()); } var scriptGen = new Sql120ScriptGenerator(); foreach (var batch2 in script2.Batches) { foreach (var statement in batch2.Statements) { var createTypeTableStatement = statement as CreateTypeTableStatement; if (createTypeTableStatement == null) { continue; } string scriptOut; scriptGen.GenerateScript(createTypeTableStatement, out scriptOut); createTableTypeBody.WriteLine(scriptOut); } } return(createTableTypeBody.ToString()); }
public void UpdateTwo(Type runnerType) { var runner = (IQueryRunner)Provider.GetRequiredService(runnerType); ResetDb(runner); var stmtList = new StatementList(); stmtList.Update( DB.Products.Where(p => p.ProductId == 1), (_, builder) => builder.Value(b => b.Name, "Not tonight")); stmtList.Update( DB.Products.Where(p => p.ProductId == 2), (_, builder) => builder.Value(b => b.Name, "Nontoonyt Island")); var affectedRows = runner.ExecuteNonQuery(stmtList); Assert.AreEqual(2, affectedRows); }
public FilterStatement(String filterName, StatementList args) { _filterName = filterName; _filter = Utils.LiquidFilters[filterName]; if (args != null && args.Count > 0) { _arguments = new List <Expression>(); foreach (var statement in args) { if (statement is Expression) { _arguments.Add((Expression)statement); } else { throw new ArgumentException(String.Format("Wrong argument to filter: {0}", statement.Print(""))); } } } }
public static string CreateStaticConstructorsCallsProcedure() { StatementList body = new StatementList(); foreach (var staticConstructor in staticConstructors) { var ctor = BoogieMethod.From(staticConstructor); body.Add(BoogieGenerator.Instance().ProcedureCall(ctor, new List <Expression>(), null)); } string procedureName = "$call_static_constructors"; string attributes = String.Empty; StatementList localVariables = new StatementList(); String parametersWithTypes = String.Empty; String returnTypeIfAny = String.Empty; BoogieProcedureTemplate temp = new BoogieProcedureTemplate(procedureName, attributes, localVariables, body, parametersWithTypes, returnTypeIfAny, false); return(temp.TransformText()); }
/// <summary> /// Walks the statement list of the given block gathering information from declarations for use by forward references. Does not recurse into nested blocks. /// </summary> /// <param name="block">The block whose declarations are to be processed</param> /// <param name="scope">Maps identifiers to Metadata nodes (e.g. Fields).</param> /// <param name="targetFor">Maps labels (Identifiers) to the corresponding labeled blocks (single statements are promoted to blocks for this purpose).</param> /// <param name="labelList">A list of all the labels encountered by Declarer.</param> public virtual void VisitBlock(Block block, Class scope, TrivialHashtable targetFor, IdentifierList labelList) { if (block == null) { return; } this.scope = scope; this.targetFor = targetFor; this.labelList = labelList; StatementList statements = block.Statements; if (statements == null) { return; } for (int i = 0, n = statements.Count; i < n; i++) { statements[i] = (Statement)this.Visit(statements[i]); } }
/// <summary> /// Gets the statement for the label, if it does not exist returns null. /// </summary> public StatementList ReadStatementsForLabel(string label) { var returnStatements = new StatementList { Statements = new List <TermStatement>() }; var terms = ReadInternalTermsForLabel(label); if (!terms.Any()) { return(null); } foreach (var internalTerm in terms) { returnStatements.Statements.Add(ReadRootTermStatement(internalTerm)); } return(returnStatements); }
public void SetVariableIdentityExpression(Type runnerType) { var stmtList = new StatementList(); stmtList.Insert(DB.Products, insert => insert.Value(p => p.Name, "test insert product")); var identity = stmtList.DeclareSqlVariable <int>("myident"); stmtList.SetSqlVariable(identity, (ctx) => Function.LastInsertIdentity <int>(ctx)); var select = stmtList.Select(ctx => new { Identity = identity.Value }); var runner = (IQueryRunner)Provider.GetRequiredService(runnerType); ResetDb(runner); var results = runner.ExecuteQuery(select).ToList(); Assert.AreEqual(1, results.Count, "Should be 1 result"); Assert.AreEqual(3, results[0].Identity, "New identity should be 3"); }
private static BlockStatement MakeMachineTransitionFunctionBody(Machine machine, string transitionName) { StatementList bodyStmtList = new StatementList(); SwitchStatement switchStmt = new SwitchStatement(); switchStmt.Expression = new IdentifierExpression( String.Format("{0}_state", machine.Name)); foreach (var state in machine.States) { if (state.HasTransitions) { foreach (var stateTransitionName in state.GetTransitionNames()) { if (stateTransitionName == transitionName) { StatementList caseStmtBodyStmtList = new StatementList(); caseStmtBodyStmtList.Add( new InvokeStatement( new InvokeExpression( new IdentifierExpression( String.Format("{0}_{1}_{2}", machine.Name, state.Name, transitionName))))); CaseStatement caseStmt = new CaseStatement( new LiteralExpression( String.Format("State_{0}", state.Name)), new BlockStatement(caseStmtBodyStmtList)); switchStmt.Cases.Add(caseStmt); } } } } switchStmt.DefaultCaseStmt = new BlockStatement(); bodyStmtList.Add(switchStmt); return(new BlockStatement(bodyStmtList)); }
public void FuncCallTest5() { var lambda = new LambdaExpression(MetaData.Empty, new StatementList(MetaData.Empty, new ReturnStatement(MetaData.Empty, new FunctionCallExpression(MetaData.Empty, new LambdaExpression(MetaData.Empty, new StatementList(MetaData.Empty, new ReturnStatement(MetaData.Empty, new FunctionCallExpression(MetaData.Empty, new VariableExpression(MetaData.Empty, "recur"), new List <Expression>(new[] { new VariableExpression(MetaData.Empty, "a") }))) ), returnType: new UnknownType(MetaData.Empty, "i8")), new List <Expression>()))), new List <VariableDeclaration>(new[] { new VariableDeclaration(MetaData.Empty, "a", type: new UnknownType(MetaData.Empty, "i8")) }), new UnknownType(MetaData.Empty, "i8")); var example = new StatementList(MetaData.Empty, new VariableDeclaration(MetaData.Empty, "recurFunc", lambda), new VariableDeclaration(MetaData.Empty, "gg", isMutable: true, type: new UnknownType(MetaData.Empty, "i8")), new AssignmentStatement(MetaData.Empty, new VariableExpression(MetaData.Empty, "gg"), new FunctionCallExpression(MetaData.Empty, new VariableExpression(MetaData.Empty, "recurFunc"), new List <Expression>(new[] { new IntLiteralExpression(MetaData.Empty, "233", true, 8) })))); example.SurroundWith(Environment.SolarSystem); example.PrintDumpInfo(); Assert.IsTrue(0 == Errors.ErrList.Count); }
public void visitStatementList(StatementList sl) { Scope parentScope = _currentScope; _currentScope = new Scope(parentScope); sl.scope = _currentScope; // if there are formal args in play, assume they should be added to this scope while (_formalArgs.Count > 0) { Variable v = _formalArgs[0]; _formalArgs.RemoveAt(0); visitVariable(v); } visitChildren(sl); // now that we've finished with the statement list return to the previous scope _currentScope = parentScope; }
public Node If() { var ifToken = Expect(TokenCategory.IF); var expr = Expression(); Expect(TokenCategory.THEN); var stmtList = new StatementList(); while (firstOfStatement.Contains(CurrentToken)) { stmtList.Add(Statement()); } Expect(TokenCategory.END); var result = new If() { expr, stmtList }; result.AnchorToken = ifToken; return(result); }
public void TestSelectStar() { StatementList statementList = new StatementList() { Statements = new List <Statement>() { new SelectStatement() { SelectElements = new List <Expressions.SelectExpression>() { new SelectStarExpression() } } } }; var expected = "SELECT *"; var actual = statementList.Print(); actual.Should().Be(expected); }
/// <summary> /// Crea la funcio 'getInstance' /// </summary> /// <param name="machine">La maquina.</param> /// <returns>La declaracio de la funcio.</returns> /// private FunctionDeclaration MakeGetStateInstanceFunction(Machine machine) { StatementList statements = new StatementList( new ReturnStatement( new SubscriptExpression( new IdentifierExpression("states"), new CastExpression( TypeIdentifier.FromName("int"), new IdentifierExpression("id") ) ) ) ); return(new FunctionDeclaration( "getStateInstance", AccessSpecifier.Public, TypeIdentifier.FromName("State*"), new ArgumentDeclarationList(new ArgumentDeclaration("id", TypeIdentifier.FromName("StateID"))), statements)); }
public void ParserTest() { string text = @" a = 40; b = a + 2; print(b);"; SyntaxNode root = ParserWrap.Parse(text); var statements = new StatementList(); statements.Add(new AssignmentStatement(new Identifier("a"), new Int32Const(40))); statements.Add(new AssignmentStatement( new Identifier("b"), new BinaryExpression( new Identifier("a"), Operation.Add, new Int32Const(2)))); statements.Add(new PrintStatement(new Identifier("b"), false)); Assert.AreEqual(root, new Program(statements)); }
/// <summary> /// Method returns a list of statements that checks task status. /// </summary> private static StatementList CreateIfTaskResultIsEqualsTo( Parameter taskParameterToCheck, TaskStatus expectedStatus, Block endBlock) { Contract.Ensures(Contract.Result <StatementList>() != null); var result = new StatementList(); // If-statement is slightly different in IL. // To get `if (condition) {statements}` // we need to generate: // if (!condition) goto endBLock; statements; endBlock: // This method emits a check that simplifies CheckMethod implementation. var statusProperty = GetTaskProperty(taskParameterToCheck, "get_Status"); Contract.Assert(statusProperty != null, "Can't find Task.Status property"); // Emitting: var tmpStatus = task.Status; var tmpStatus = new Local(statusProperty.ReturnType); result.Add( new AssignmentStatement(tmpStatus, new MethodCall(new MemberBinding(taskParameterToCheck, statusProperty), new ExpressionList()))); // if (tmpStatus != expectedStatus) // goto endOfMethod; // This is an inverted form of the check: if (tmpStatus == expectedStatus) {check} result.Add( new Branch( new BinaryExpression( tmpStatus, new Literal(expectedStatus), NodeType.Ne), endBlock)); return(result); }
private CaretCurrentStatement FindCurrentStatement(StatementList statementList, CaretPosition caret) { if (statementList == null) { return(null); } foreach (var statement in statementList.Statements) { var ft = statementList.ScriptTokenStream[statement.FirstTokenIndex]; var lt = statementList.ScriptTokenStream[statement.LastTokenIndex]; if (caret.Line >= ft.Line && caret.Line <= lt.Line) { var isBeforeFirstToken = caret.Line == ft.Line && caret.LineCharOffset < ft.Column; var isAfterLastToken = caret.Line == lt.Line && caret.LineCharOffset > lt.Column + lt.Text.Length; if (!(isBeforeFirstToken || isAfterLastToken)) { var currentStatement = new CaretCurrentStatement() { FirstToken = new CaretPosition { Line = ft.Line, LineCharOffset = ft.Column }, LastToken = new CaretPosition { Line = lt.Line, LineCharOffset = lt.Column + lt.Text.Length } }; return(currentStatement); } } } return(null); }
static void Main(string[] args) { TextReader rdr = new StreamReader(new MemoryStream( Encoding.UTF8.GetBytes( @"/* comment */ WITH CteUpdate AS ( SELECT * FROM Table1 WHERE Col1 = 1 ) UPDATE CteUpdate SET city = ""NY"" WHERE name = ""tom""") )); TSql110Parser parser = new TSql110Parser(true); IList <ParseError> errors; StatementList stmtList = parser.ParseStatementList(rdr, out errors); // Process errors foreach (TSqlStatement stmt in stmtList.Statements) { Console.WriteLine("Statement type {0}", stmt.GetType()); if (stmt is SelectStatement) { //Process SELECT statment } else if (stmt is UpdateStatement) { //Process UPDATE statment UpdateStatement stmtUpdate = (UpdateStatement)stmt; NamedTableReference tabRef = (NamedTableReference)stmtUpdate.UpdateSpecification.Target; Console.Write(" > UPDATE statement > target object {0}", tabRef.SchemaObject.BaseIdentifier.Value); } else //Process other statments { throw new NotImplementedException(); } } }
public override StatementList VisitStatementList(StatementList statements) { var oldSL = this.currentSL; var oldSLi = this.currentSLindex; this.currentSL = statements; try { if (statements == null) return null; for (int i = 0, n = statements.Count; i < n; i++) { this.currentSLindex = i; statements[i] = (Statement) this.Visit(statements[i]); } return statements; } finally { this.currentSLindex = oldSLi; this.currentSL = oldSL; } }
internal void Transfer(LocalsStack /*!*/ targetStack, StatementList /*!*/ statements) { Debug.Assert(targetStack != null); if (targetStack == this) { return; } int n = this.top; Debug.Assert(n == targetStack.top); for (int i = 0; i <= n; i++) { Local sloc = this.elements[i]; Local tloc = targetStack.elements[i]; if (sloc == tloc) { continue; } Debug.Assert(sloc != null && tloc != null); statements.Add(new AssignmentStatement(tloc, sloc)); } }
public StatementList GetStatementList(TSqlFragment fragment) { var fragmentTypeName = fragment.GetType().Name; var statementList = new StatementList(); switch (fragmentTypeName.ToLower()) { case "createprocedurestatement": return((fragment as CreateProcedureStatement)?.StatementList); case "createviewstatement": statementList.Statements.Add((fragment as CreateViewStatement)?.SelectStatement); return(statementList); case "createfunctionstatement": var func = (fragment as CreateFunctionStatement); if (func == null) { return(null); } var returnType = func.ReturnType as SelectFunctionReturnType; //this is an ITVF, and does not have a statement list, it has one statement in the return block... if (func.StatementList == null && returnType != null) { statementList.Statements.Add(returnType.SelectStatement); return(statementList); } return(func.StatementList); case "createtriggerstatement": return((fragment as CreateTriggerStatement)?.StatementList); default: //throw new ApplicationException("Unable to determine statement list for fragment type: " + fragmentTypeName); return(null); } }
public async Task <ActionResult> GetFile(long?fileId) { Entities.File file = statementBusinessLogic.File_Get(fileId.Value); try { var filePath = Path.Combine(ConfiguraionProvider.FileStorageFolder, file.FIleUrl); byte[] fileContents; using (var fs = System.IO.File.OpenRead(filePath)) { fileContents = new byte[fs.Length]; await fs.ReadAsync(fileContents, 0, fileContents.Length); } return(File(fileContents, System.Net.Mime.MediaTypeNames.Application.Octet, file.FileName)); } catch (Exception ex) { var exceptionDetails = new ExceptionDetails(ex, "Ошибка при получении файла."); var model = new StatementList(exceptionDetails); return(View("Statement", model)); } }
public Node Loop() { var result = new Loop() { AnchorToken = Expect(TokenCategory.LOOP) }; var statementList = new StatementList(); if (firstOfStatement.Contains(CurrentToken)) { while (firstOfStatement.Contains(CurrentToken)) { statementList.Add(Statement()); } } result.Add(statementList); Expect(TokenCategory.END); Expect(TokenCategory.SEMICOLON); return(result); }
private StatementList ParseChildren(Stream stream) { StatementList statement = new StatementList(_host); var open = stream.Next(); CloseBracesToken close = null; while (stream.Peek() != null) { var token = stream.Peek(); if (token == null) { break; } switch (token.Type) { case TokenType.Plus: //ignore these? break; case TokenType.CloseBrace: //consume closing brace stream.NextNoReturn(); goto doneWithChildren; default: var statements = ParseStatement(stream); int length = statements.Count; for (int i = 0; i < length; i++) { statement.Add(statements[i]); } break; } } doneWithChildren: return(statement); }
private StatementList Invoke(IMethodDefinition member, BoogieVariable receiver) { Expression receiverObject = receiver; if (receiver.Type.Equals(Helpers.BoogieType.Addr)) { AddressExpression addrExpr = new AddressExpression(member.ContainingType, receiver); receiverObject = BoogieGenerator.Instance().ReadAddr(addrExpr); } Expression subtype = Expression.Subtype(Expression.DynamicType(receiverObject), member.ContainingType); StatementList body = new StatementList(); List <Expression> argumentList = new List <Expression>(); argumentList.Add(receiverObject); body.Add(BoogieGenerator.Instance().ProcedureCall(BoogieMethod.From(member), argumentList)); body.Add(BoogieStatement.ReturnStatement); var ifExpr = BoogieStatement.If(subtype, body); return(ifExpr); }
//public override Block VisitBlock(Block block) { // if(block.Statements != null && block.Statements.Count == 1) { // Return r = block.Statements[0] as Return; // if(r != null) { // Statement s = this.VisitReturn(r); // Block retBlock = s as Block; // if(retBlock != null) { // block.Statements = retBlock.Statements; // return block; // } else { // return base.VisitBlock(block); // } // } else { // return base.VisitBlock(block); // } // } else { // return base.VisitBlock(block); // } //} public override Statement VisitReturn(Return Return) { if (Return == null) { return(null); } returnCount++; this.lastReturnSourceContext = Return.SourceContext; StatementList stmts = new StatementList(); Return.Expression = this.VisitExpression(Return.Expression); if (Return.Expression != null) { MethodCall mc = Return.Expression as MethodCall; if (mc != null && mc.IsTailCall) { mc.IsTailCall = false; } var assgnmt = new AssignmentStatement(result, Return.Expression); assgnmt.SourceContext = Return.SourceContext; stmts.Add(assgnmt); } // the branch is a "leave" out of the try block that the body will be // in. var branch = new Branch(null, newExit, false, false, this.leaveExceptionBody); branch.SourceContext = Return.SourceContext; stmts.Add(branch); return(new Block(stmts)); }
static void Main(string[] args) { #if debugenabled try { #endif string Code = File.ReadAllText("Tests\\Ackermann.cs"); CodeLexer lexer = new CodeLexer(Code); LexTokenList lexTokens = lexer.Analyze(); CPreprocessor preProcessor = new CPreprocessor(lexTokens); lexTokens = preProcessor.Process(); Console.WriteLine("LexTokens (post-processed):"); foreach (LexToken lexToken in lexTokens) { Console.WriteLine(lexToken.Kind.ToString() + " " + (lexToken.Value == null ? "" : lexToken.Value.ToString())); } Console.WriteLine("------\nGenerating AST.."); AstGenerator astGenerator = new AstGenerator(lexTokens); StatementList statements = astGenerator.Generate(); Console.WriteLine("Generated AST!"); Console.WriteLine(View.ASTView.GenerateStatements(statements)); #if debugenabled } catch (Exception ex) { Console.WriteLine(ex.Message + "\n" + ex.StackTrace); } #endif Console.ReadLine(); }
public void SetVariableTypes(Type runnerType) { var stmtList = new StatementList(); var intVar = stmtList.DeclareSqlVariable <int>("intVar"); stmtList.SetSqlVariable(intVar, ctx => 1); var decimalVar = stmtList.DeclareSqlVariable <decimal>("decimalVar"); stmtList.SetSqlVariable(decimalVar, ctx => 2.23M); var intNullableVar = stmtList.DeclareSqlVariable <int?>("intNullableVar"); stmtList.SetSqlVariable(intNullableVar, ctx => 42); var stringVar = stmtList.DeclareSqlVariable <string>("stringVar"); stmtList.SetSqlVariable(stringVar, ctx => "test"); var select = stmtList.Select(ctx => new { intVar = intVar.Value, decimalVar = decimalVar.Value, intNullableVar = intNullableVar.Value, stringVar = stringVar.Value }); var runner = (IQueryRunner)Provider.GetRequiredService(runnerType); ResetDb(runner); var results = runner.ExecuteQuery(select).ToList(); Assert.AreEqual(1, results.Count, "Should be 1 result"); Assert.AreEqual(1, results[0].intVar, "intVar should be 1"); Assert.AreEqual(42, results[0].intNullableVar, "intNullableVar should be 42"); Assert.AreEqual(2.23M, results[0].decimalVar, "decimalVar should be 2.23"); Assert.AreEqual("test", results[0].stringVar, "stringVar should be 'test'"); }
public int FindUsingInstruction2(StatementList stms, int i, Operator next) { for (++i; i < stms.Count; ++i) { if (!(stms[i].Instruction is Assignment ass)) { continue; } if (!(ass.Src is BinaryExpression bin)) { continue; } if (bin.Operator == next) { return(i); } if (IsCarryFlag(ass.Dst)) { return(-1); } } return(-1); }
//public override Block VisitBlock(Block block) { // if(block.Statements != null && block.Statements.Count == 1) { // Return r = block.Statements[0] as Return; // if(r != null) { // Statement s = this.VisitReturn(r); // Block retBlock = s as Block; // if(retBlock != null) { // block.Statements = retBlock.Statements; // return block; // } else { // return base.VisitBlock(block); // } // } else { // return base.VisitBlock(block); // } // } else { // return base.VisitBlock(block); // } //} public override Statement VisitReturn(Return Return) { if (Return == null) { return null; } returnCount++; this.lastReturnSourceContext = Return.SourceContext; StatementList stmts = new StatementList(); Return.Expression = this.VisitExpression(Return.Expression); if (Return.Expression != null) { MethodCall mc = Return.Expression as MethodCall; if (mc != null && mc.IsTailCall) { mc.IsTailCall = false; } var assgnmt = new AssignmentStatement(result, Return.Expression); assgnmt.SourceContext = Return.SourceContext; stmts.Add(assgnmt); } // the branch is a "leave" out of the try block that the body will be // in. var branch = new Branch(null, newExit, false, false, this.leaveExceptionBody); branch.SourceContext = Return.SourceContext; stmts.Add(branch); return new Block(stmts); }
protected void Visit(StatementList statementList) { for (int i = 0; i < statementList.Count; i++) { var statement = statementList[i]; var ifStatement = statement as IfStatement; if (ifStatement != null) { var result = evaluator.Evaluate(ifStatement.Condition); if (result.HasErrors) { continue; } statementList[i] = result.Value == 1.0 ? ifStatement.Then : ifStatement.Else; if (statementList[i] == null) { statementList.RemoveAt(i); } i--; } } Visit((Node)statementList); }
//================= reader methods ========================================== void AddReadAttributes(TypeNode type, StatementList statements, Identifier reader, Expression target, SchemaValidator validator) { if (validator.Attributes != null) { Block whileBody = new Block(new StatementList()); Literal trueLit = Literal.True; MethodCall movenext = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToNextAttribute")), new ExpressionList()); BinaryExpression condition = new BinaryExpression(movenext, trueLit, NodeType.Eq); While w = new While(condition, whileBody); statements.Add(w); Block lastElseBlock = null; Local nameLocal = new Local(SystemTypes.String); whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName")))); Local nsLocal = new Local(SystemTypes.String); whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI")))); foreach (SchemaAttDef ad in validator.Attributes) { // todo: any way to do tokenized compares? BinaryExpression nameEqual = new BinaryExpression(nameLocal, new Literal(ad.Name.Name, SystemTypes.String), NodeType.Eq); BinaryExpression nsEqual = new BinaryExpression(nsLocal, new Literal(ad.Name.Prefix != null ? ad.Name.Prefix.Name : "", SystemTypes.String), NodeType.Eq); Block elseBlock = new Block(new StatementList()); If ifExpr = new If(new BinaryExpression(nameEqual, nsEqual, NodeType.And), new Block(new StatementList()), elseBlock); if (lastElseBlock != null) { lastElseBlock.Statements.Add(ifExpr); } else { whileBody.Statements.Add(ifExpr); } lastElseBlock = elseBlock; // body of if test, parse the attribute value as the specified type. Debug.Assert(ad.Member is Field || ad.Member is Property); AddReadSimpleType(Checker.GetMemberType(ad.Member), ifExpr.TrueBlock.Statements, reader, GetMemberBinding(target, ad.Member), null, true); } //todo: report unknown attributes? } }
/// <summary> /// Initializes a new instance of the <see cref="MethodDefinition"/> class. /// </summary> public MethodDefinition() { Body = new StatementList(); declaration = this; }
public override StatementList VisitStatementList(StatementList statements) { if (statements == null) { WriteLine(";"); return null; } for (int i = 0, n = statements.Count; i < n; i++) this.Visit(statements[i]); return statements; }
public virtual StatementList VisitStatementList(StatementList statements, StatementList changes, StatementList deletions, StatementList insertions){ if (statements == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ } }else if (deletions != null) return null; return statements; }
void AddReadAllGroup(Class serializer, Block block, TypeNode type, StatementList statements, Identifier reader, Expression target, Expression required, Expression result, ArrayList members, Member mixedMember) { // todo: keep track of which members have been read and report error on duplicates MethodCall read = new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList()); Local sb = new Local(SystemTypes.StringBuilder); bool isMixed = mixedMember != null; if (isMixed) { statements.Add(new AssignmentStatement(sb, new Construct(new MemberBinding(null, SystemTypes.StringBuilder), new ExpressionList(), SystemTypes.StringBuilder))); } Block whileBody = new Block(new StatementList()); BinaryExpression notEndTag = new BinaryExpression( new QualifiedIdentifier(reader, Identifier.For("NodeType")) , new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("EndElement")), NodeType.Ne); BinaryExpression notEOF = new BinaryExpression( new QualifiedIdentifier(reader, Identifier.For("EOF")), Literal.True, NodeType.Ne); While w = new While(new BinaryExpression(notEndTag, notEOF, NodeType.And), whileBody); statements.Add(w); Local nameLocal = new Local(Identifier.For("name"),SystemTypes.String,block); Local nsLocal = new Local(Identifier.For("ns"),SystemTypes.String,block); Local nodeType = new Local(Identifier.For("nodeType"),Runtime.XmlNodeType,block); whileBody.Statements.Add(new AssignmentStatement(nameLocal, new QualifiedIdentifier(reader, Identifier.For("LocalName")))); whileBody.Statements.Add(new AssignmentStatement(nsLocal, new QualifiedIdentifier(reader, Identifier.For("NamespaceURI")))); whileBody.Statements.Add(new AssignmentStatement(nodeType, new QualifiedIdentifier(reader, Identifier.For("NodeType")))); Block childBlock = whileBody; if (isMixed) { // Append the text node to the current StringBuilder contents. childBlock = new Block(new StatementList()); If ifText = new If(IsTextNode(nodeType), new Block(new StatementList()), childBlock); whileBody.Statements.Add(ifText); ExpressionList args = new ExpressionList(); args.Add(new QualifiedIdentifier(reader, Identifier.For("Value"))); ifText.TrueBlock.Statements.Add(new ExpressionStatement(new MethodCall( new QualifiedIdentifier(sb, Identifier.For("Append")), args))); ifText.TrueBlock.Statements.Add(new ExpressionStatement(read)); // advance to next node } If ifElement = new If(new BinaryExpression(nodeType, new QualifiedIdentifier(Identifier.For("XmlNodeType"), Identifier.For("Element")), NodeType.Eq), new Block(new StatementList()), new Block(new StatementList())); childBlock.Statements.Add(ifElement); childBlock = ifElement.TrueBlock; //AddConsoleWrite(statements, new Literal("name=",SystemTypes.String)); //AddConsoleWriteLine(statements, nameLocal); //AddConsoleWrite(statements, new Literal("nodeType=",SystemTypes.String)); //AddConsoleWriteLine(statements, nodeType); foreach (NamedNode childNode in members) { if (!(childNode.Member is Field || childNode.Member is Property)) { AddError(statements, reader, RuntimeError.SerializationOfTypeNotSupported, new Literal(childNode.Member.GetType().FullName, SystemTypes.String)); } else { Expression mb = GetMemberBinding(target, childNode.Member); childBlock = AddReadChild(block, childBlock.Statements, childNode.Name, childNode.TypeNode, mb, reader, result, true, false).FalseBlock; // todo: throw error if child is required. (e.g. NonEmptyIEnumerable...) } } // if it isn't any of the expected elements then throw an error. AddError(childBlock.Statements, reader, RuntimeError.NoSuchMember, new Expression[2]{new Literal(tempChecker.GetTypeName(type),SystemTypes.String), nameLocal}); // If it's not an element then consume it anyway to keep the reader advancing. // Probably a comment or PI or something. ifElement.FalseBlock.Statements.Add(new ExpressionStatement(new MethodCall( new QualifiedIdentifier(reader, Identifier.For("Skip")), new ExpressionList()))); if (isMixed) { statements.Add(new AssignmentStatement(GetMemberBinding(target, mixedMember), new MethodCall(new QualifiedIdentifier(sb, Identifier.For("ToString")), new ExpressionList()))); } statements.Add(new AssignmentStatement(result, Literal.True)); }
If AddEmptyElementCheck(StatementList statements, Identifier reader) { // make sure the element is not empty. If isEmpty = new If(new BinaryExpression(new QualifiedIdentifier(reader, Identifier.For("IsEmptyElement")), Literal.True, NodeType.Eq), new Block(new StatementList()), new Block(new StatementList())); statements.Add(isEmpty); statements = isEmpty.TrueBlock.Statements; // consume empty start tag and just return. statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList()))); return isEmpty; }
void AddReadContentNode(ContentNode n, Block block, StatementList statements, Identifier reader, Expression target, Expression required, Expression result, SchemaValidator validator) { if (n.TypeNode == null) { Debug.Assert(n is SequenceNode); // In the class inheritance case we have two independent left and right children inside // a parent sequence that has no unified type or member. SequenceNode s = (SequenceNode)n; AddReadContentNode(s.LeftChild, block, statements, reader, target, required, result, validator); AddReadContentNode(s.RightChild, block, statements, reader, target, required, result, validator); return; } TypeNode ct = n.TypeNode; Debug.Assert(ct != null); if (n.Member != null && !(n.Member is Method)) { target = GetMemberBinding(target, n.Member); ct = target.Type; } // todo: might be content model AND mixed, in which case we have to pass the MixedMember // to AddReadTuple, AddReadChoice and AddReadStream. if (ct.Template == SystemTypes.GenericBoxed){ ct = Checker.GetCollectionElementType(ct); } if (ct is TupleType) { AddReadTuple(block, ct as TupleType, statements, reader, target, required, result); } else if (ct is TypeUnion) { AddReadChoice(block, ct as TypeUnion, statements, reader, target, required, result); } else if (IsStream(ct)) { AddReadStream(block, ct, statements, reader, target, result); } else if (ct is TypeAlias) { AddReadAlias(block, ct as TypeAlias, statements, reader, target, required, result); } else { Identifier name = Checker.GetDefaultElementName(ct); AddReadRequiredChild(block, statements, name, ct, target, reader, result, required, true, false); } }
void AddReadContent(Class serializer, Block block, TypeNode type, StatementList statements, Identifier reader, Expression target, Expression required, Expression result, SchemaValidator validator) { // position us in the content. statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList()))); Local elementName = new Local(Identifier.Empty,SystemTypes.String); statements.Add(new AssignmentStatement(elementName, new QualifiedIdentifier(reader, Identifier.For("LocalName")))); // make sure the element is not empty. If isEmpty = AddEmptyElementCheck(statements, reader); // Read the contents. statements = isEmpty.FalseBlock.Statements; statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("Read")), new ExpressionList()))); statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("MoveToContent")), new ExpressionList()))); ValidationState context = new ValidationState(); context.ErrorHandler = this.errorHandler; validator.validator.InitValidation(context); ArrayList members = null; if (validator.validator is AllElementsContentValidator) { members = validator.validator.ExpectedElements(context, false, false); AddReadAllGroup(serializer, block, type, statements, reader, target, required, result, members, validator.validator.MixedMember); } else { // There should be one root level anonymous Item0 member. SequenceNode seq = (SequenceNode)validator.RootNode; // this is a wrapper node. if (seq == null) { // perhaps it is ContentType.Empty or Mixed. if (validator.validator.ContentType == XmlSchemaContentType.Mixed || validator.validator.ContentType == XmlSchemaContentType.TextOnly){ Debug.Assert(validator.validator.MixedMember != null); statements.Add(new AssignmentStatement(GetMemberBinding(target, validator.validator.MixedMember), new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadStringElement")), new ExpressionList()))); } return; } else { ContentNode n = seq.LeftChild; AddReadContentNode(n, block, statements, reader, target, required, result, validator); } } // consume final end tag statements.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(reader, Identifier.For("ReadEndTag")), new ExpressionList(elementName)))); }
public override void VisitStatementList(StatementList statements) { if (statements == null) return; for (int i = 0; i < statements.Count; i++) { var st = statements[i]; if (st != null && st.SourceContext.IsValid) { lastSC = st.SourceContext; } this.Visit(st); } }
/// <summary> /// Visits the ForEachStatement Node and collects information from it. /// </summary> /// <param name="forEachStatement">The ForEachStatement</param> public override Node Visit(ForEachStatement forEachStatement) { if (expandForEachStatements) { // run analysis on collection VisitDynamic(forEachStatement.Collection); var inference = forEachStatement.Collection.TypeInference.Declaration as Variable; if (!(inference != null && inference.Type is ArrayType)) return forEachStatement; if ((inference.Type as ArrayType).Dimensions.Count > 1) { Error(XenkoMessageCode.ErrorMultiDimArray, forEachStatement.Span, inference, forEachStatement, analyzedModuleMixin.MixinName); return forEachStatement; } var dim = (int)((inference.Type as ArrayType).Dimensions.FirstOrDefault() as LiteralExpression).Value; var result = new StatementList(); for (int i = 0; i < dim; ++i) { var cloned = forEachStatement.DeepClone(); var replace = new XenkoReplaceExtern(cloned.Variable, new IndexerExpression(cloned.Collection, new LiteralExpression(i))); replace.Run(cloned.Body); result.Add(cloned.Body); } VisitDynamic(result); return result; } else { base.Visit(forEachStatement); parsingInfo.ForEachStatements.Add(new StatementNodeCouple(forEachStatement, ParentNode)); return forEachStatement; } }
void AddWriteStream(TypeNode type, StatementList statements, TypeNode referringType, Expression src, Identifier writer) { // Generate the following code: // XxxxSerializer s = new XxxxSerializer(); // foreach (Xxxx x in src) { // s.Serialize(x,writer); // } // Where Xxxx is the element type for the given stream type. if (type.Template == SystemTypes.GenericNonEmptyIEnumerable) { type = Checker.GetIEnumerableTypeFromNonEmptyIEnumerableStruct(this.module, type); } else { statements = AddCheckForNull(statements, Duplicate(src, referringType), type); } TypeNode ceType = Checker.GetCollectionElementType(type); //todo: should check that type has an IEnumerator. Identifier loopVariable = Identifier.For("e"); loopVariable.Type = ceType; Block body = new Block(); body.Statements = new StatementList(); Expression name, ns; GetNameAndNamespace(ceType, out name, out ns); // call the Serialize method on it, passing the member we're serializing. if (!AddWriteSimpleType(ceType, body.Statements, referringType, writer, loopVariable, name, ns)) { AddCallSerializer(ceType, body.Statements, loopVariable, writer, name, ns); } ForEach fe = new ForEach(ceType, loopVariable, src, body); statements.Add(fe); }