/// <summary> /// run step 123. /// </summary> /// <returns></returns> public override Expr Parse() { // Move past "mod" _tokenIt.Advance(); // Get the name of the module "e.g." "math" var name = _tokenIt.ExpectId(); // 1. Create the symbol to represent module var symbol = new SymbolModule(); symbol.Name = name; symbol.Category = SymbolCategory.Module; symbol.DataType = new LModuleType(); symbol.DataType.Name = name; symbol.DataType.FullName = name; symbol.Scope = new SymbolsNested(name); symbol.ParentScope = this.Ctx.Symbols.Current; // 2. Add the module symbol to the current scope this.Ctx.Symbols.Define(symbol); // 3. Now push the scope on top of the current scope. ( since modules can be nested ) this.Ctx.Symbols.Push(symbol.Scope, true); var block = new BlockExpr(); _parser.ParseBlock(block); this.Ctx.Symbols.Pop(); return(block); }
/// <summary> /// Parses a block by first pushing symbol scope and then popping after completion. /// </summary> public virtual void ParseBlock(BlockExpr stmt) { this.Ctx.Symbols.Push(new SymbolsNested(string.Empty), true); stmt.SymScope = this.Ctx.Symbols.Current; _parser.ParseBlock(stmt); this.Ctx.Symbols.Pop(); }
public BlockExprFrame( EvalVisitor evaluator, BlockExpr e ) : base(evaluator, e) { foreach( var local in ((BlockExpr)Expr).Locals ) { _visitor.ScopeManager.Register( local ); } }
public object VisitBlock(BlockExpr expr) { foreach (var stmt in expr.Statements) { stmt.Visit(this); } return(null); }
public virtual bool VisitBlockExpr(BlockExpr stmt) { if (!VisitExpr(stmt)) { return(false); } return(true); }
/// <summary> /// Executes the block with callback/template methods. /// </summary> public object VisitBlock(BlockExpr expr) { object result = LObjects.Null; try { //expr.OnBlockEnter(); expr.Ctx.Memory.Push(); LangHelper.Evaluate(expr.Statements, expr.Parent, this); } finally { //expr.OnBlockExit(); expr.Ctx.Memory.Pop(); } return(result); }
private object Evaluate(Expr expression) { return(expression switch { BinaryExpr binaryExpr => Evaluate(binaryExpr), BlockExpr blockExpr => Evaluate(blockExpr), BreakExpr breakExpr => Evaluate(breakExpr), CallExpr callExpr => Evaluate(callExpr), ContinueExpr continueExpr => Evaluate(continueExpr), Identifier identifier => Evaluate(identifier), IfExpr ifExpr => Evaluate(ifExpr), LambdaExpr lambdaExpr => Evaluate(lambdaExpr), Literal literal => Evaluate(literal), ReturnExpr returnExpr => Evaluate(returnExpr), UnaryExpr unaryExpr => Evaluate(unaryExpr), _ => throw new ArgumentOutOfRangeException(nameof(expression)) });
/// <summary> /// Parses a block by first pushing symbol scope and then popping after completion. /// </summary> public override void ParseBlock(BlockExpr stmt) { var fs = stmt as FunctionExpr; // 1. Define the function in global symbol scope var funcSymbol = new SymbolFunction(fs.Meta); funcSymbol.FuncExpr = stmt; // 2. Push the current scope. stmt.SymScope = this.Ctx.Symbols.Current; this.Ctx.Symbols.Push(new SymbolsFunction(string.Empty), true); // 3. Parse the function block _parser.ParseBlock(stmt); // 4. Pop the symbols scope. this.Ctx.Symbols.Pop(); }
public Expr OnParseIf() { var tokenIt = this._parser.TokenIt; var initiatorToken = tokenIt.NextToken; var expr = new IfExpr(); // <codeIf> tokenIt.Expect(Tokens.If); // Parse the if this.ParseConditionalBlock(expr); tokenIt.AdvancePastNewLines(); // Handle "else if" and/or else if (tokenIt.NextToken.Token == Tokens.Else) { // tokenIt.NextToken = "else" tokenIt.Advance(); tokenIt.AdvancePastNewLines(); // What's after else? // 1. "if" = else if statement // 2. "{" = multi line else // 3. "nothing" = single line else // Peek 2nd token for else if. var token = tokenIt.NextToken; if (tokenIt.NextToken.Token == Tokens.If) { expr.Else = OnParseIf() as BlockExpr; } else // Multi-line or single line else { var elseStmt = new BlockExpr(); this._parser.ParseBlock(elseStmt); this._parser.SetupContext(elseStmt, token); expr.Else = elseStmt; } } // </codeIf> this._parser.SetupContext(expr, initiatorToken); return(expr); }
/// <summary> /// return value; /// </summary> /// <returns></returns> public override Expr Parse() { var stmt = new IfExpr(); var statements = new List <Expr>(); // While ( condition expression ) _tokenIt.Expect(Tokens.If); // Parse the if ParseConditionalBlock(stmt); _tokenIt.AdvancePastNewLines(); // Handle "else if" and/or else if (_tokenIt.NextToken.Token == Tokens.Else) { // _tokenIt.NextToken = "else" _tokenIt.Advance(); _tokenIt.AdvancePastNewLines(); // What's after else? // 1. "if" = else if statement // 2. "{" = multi line else // 3. "nothing" = single line else // Peek 2nd token for else if. var token = _tokenIt.NextToken; if (_tokenIt.NextToken.Token == Tokens.If) { stmt.Else = Parse() as BlockExpr; } else // Multi-line or single line else { var elseStmt = new BlockExpr(); ParseBlock(elseStmt); _parser.SetupContext(elseStmt, token); stmt.Else = elseStmt; } } return(stmt); }
/// <summary> /// Parses a block by first pushing symbol scope and then popping after completion. /// </summary> public override void ParseBlock(BlockExpr stmt) { var fs = stmt as FunctionExpr; var funcName = fs.Name; // 1. Define the function in global symbol scope var funcSymbol = new SymbolFunction(fs.Meta); funcSymbol.FuncExpr = stmt; this.Ctx.Symbols.Define(funcSymbol); // 2. Define the aliases. if (!fs.Meta.Aliases.IsNullOrEmpty()) { foreach (var alias in fs.Meta.Aliases) { this.Ctx.Symbols.DefineAlias(alias, fs.Meta.Name); } } // 3. Push the current scope. this.Ctx.Symbols.Push(new SymbolsFunction(fs.Name), true); // 4. Register the parameter names in the symbol scope. if (!fs.Meta.Arguments.IsNullOrEmpty()) { foreach (var arg in fs.Meta.Arguments) { this.Ctx.Symbols.DefineVariable(arg.Name, LTypes.Object); } } stmt.SymScope = this.Ctx.Symbols.Current; _parser.ParseBlock(stmt); this.Ctx.Symbols.Pop(); }
/// <summary> /// Parses a block by first pushing symbol scope and then popping after completion. /// </summary> public void OnParseFunctionDeclareBlock(BlockExpr expr) { var fs = expr as FunctionExpr; var funcName = fs.Meta.Name; // 1. Define the function in global symbol scope var funcSymbol = new SymbolFunction(fs.Meta); funcSymbol.FuncExpr = expr; this._parser.Context.Symbols.Define(funcSymbol); // 2. Define the aliases. if (fs.Meta.Aliases != null && fs.Meta.Aliases.Count > 0) { foreach (var alias in fs.Meta.Aliases) { this._parser.Context.Symbols.DefineAlias(alias, fs.Meta.Name); } } // 3. Push the current scope. expr.SymScope = this._parser.Context.Symbols.Current; this._parser.Context.Symbols.Push(new SymbolsFunction(fs.Meta.Name), true); // 4. Register the parameter names in the symbol scope. if (fs.Meta.Arguments != null && fs.Meta.Arguments.Count > 0) { foreach (var arg in fs.Meta.Arguments) { this._parser.Context.Symbols.DefineVariable(arg.Name, LTypes.Object); } } this._parser.ParseBlock(expr); this._parser.Context.Symbols.Pop(); }
public bool VisitBlockExpr(BlockExpr stmt) { throw new NotImplementedException(); }
/* public KonohaExpr ParseExpr(String str) { if (str == null) { throw new ArgumentException("str must not be null."); } return null; //return ParseExprAux(new Tokenizer(str)); } private KonohaExpr ParseExprAux(Tokenizer lexer) { return null; //throw new NotImplementedException(); } */ /// <summary> /// トークン列をパースしてブロックを得る /// </summary> /// <param name="parent">親のステートメント</param> /// <param name="token">トークン列</param> /// <param name="start">開始トークン位置</param> /// <param name="end">終了トークンの次の位置</param> /// <param name="delim">デリミタ</param> /// <returns></returns> // static kBlock *new_Block(CTX, kKonohaSpace *ks, kStmt *parent, kArray *tls, int s, int e, int delim) public BlockExpr CreateBlock(ExprOrStmt parent, IList<Token> token, int start, int end, char delim) { BlockExpr block = new BlockExpr(); block.parent = parent; int indent = 0; int atop = token.Count; for (int i = start; i < end; ) { Token error; Debug.Assert(atop == token.Count); i = SelectStatementLine(ref indent, token, i, end, delim, token, out error); int asize = token.Count; if (asize > atop) { block.AddStatementLine(ctx, ks, token, atop, asize, out error); } } return block; }
public PExpr Visit( BlockExpr e ) { return Run( new BlockExprFrame( this, e ) ); }
private string ExprToString(BlockExpr expr) { StringBuilder stringBuilder = new StringBuilder(); ExprToString(expr, stringBuilder); return stringBuilder.ToString(); }
private void Resolve(BlockExpr block) { Resolve(block.Stmts); Resolve(block.Value); }
/// <summary> /// Create new instance /// </summary> public TryCatchExpr() { this.Nodetype = NodeTypes.SysTryCatch; InitBoundary(true, "}"); Catch = new BlockExpr(); }
private IUnboundExpr SyntaxExpr() { Position position; if (ConsumeIf(TokenType.LeftCurly, out position)) { // ignore a leading line ConsumeIf(TokenType.Line); var expressions = new List<IUnboundExpr>(); while (true) { expressions.Add(Expression()); if (ConsumeIf(TokenType.RightCurly)) break; Consume(TokenType.Line); if (ConsumeIf(TokenType.RightCurly)) break; } IUnboundExpr expr; if (expressions.Count > 1) { expr = new BlockExpr(expressions); } else { expr = expressions[0]; } return new SyntaxExpr(position, expr); } else return DefineExpr(); }
/// <summary> /// Create new instance /// </summary> public TryCatchExpr() { InitBoundary(true, "}"); Catch = new BlockExpr(); }
public IfExpr(Expr condition, BlockExpr consequent, Expr alternative) { Condition = condition; Consequent = consequent; Alternative = alternative; }
private void ExprToString(BlockExpr block, int indent, ref string actual) { foreach (var expr in block.Exprs) { TextExpr textExpr = expr as TextExpr; ConditionalExpr conditionalExpr = expr as ConditionalExpr; AttrExpr attrExpr = expr as AttrExpr; BlockExpr blockExpr = expr as BlockExpr; if (textExpr != null) { actual += Environment.NewLine + new string('\t', indent) + "Text-" + textExpr.Text; } else if (conditionalExpr != null) { actual += Environment.NewLine + new string('\t', indent) + "Conditional-" + conditionalExpr.Attr + conditionalExpr.Operator + String.Join("|", conditionalExpr.Values.Select(x => x ?? "null")) + "?"; ExprToString(conditionalExpr.TrueExpr, indent + 1, ref actual); if (conditionalExpr.FalseExpr != null) { actual += ":"; ExprToString(conditionalExpr.FalseExpr, indent + 1, ref actual); } } else if (attrExpr != null) { actual += Environment.NewLine + new string('\t', indent) + "Attr-" + attrExpr.Name + (String.IsNullOrWhiteSpace(attrExpr.Regex) ? "" : "(" + attrExpr.Regex + ")"); } else if (blockExpr != null) { ExprToString(blockExpr, indent + 1, ref actual); } } }
private string ExprToString(BlockExpr block) { string actual = ""; ExprToString(block, 0, ref actual); return actual; }