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