// Appends NFunDef to nFunDefList
public void FunDef(NFunDefList nFunDefList)
{
NFunDef nFunDef = new NFunDef()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
};
NParameterList nParameterList = new NParameterList();
Expect(TokenCategory.PARENTHESIS_LEFT);
if (CurrentToken == TokenCategory.IDENTIFIER)
{
nParameterList.Add(new NParameter()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
while (CurrentToken == TokenCategory.COMMA)
{
Expect(TokenCategory.COMMA);
nParameterList.Add(new NParameter()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
});
}
}
Expect(TokenCategory.PARENTHESIS_RIGHT);
Expect(TokenCategory.CURLY_BRACE_LEFT);
NVarDefList nVarDefList = (NVarDefList)VarDefList();
NStmtList nStmtList = (NStmtList)StmtList();
Expect(TokenCategory.CURLY_BRACE_RIGHT);
nFunDef.Add(nParameterList);
nFunDef.Add(nVarDefList);
nFunDef.Add(nStmtList);
nFunDefList.Add(nFunDef);
}
public void Visit(NStmtList nStmtList)
{
foreach (Node stmt in nStmtList)
{
Visit((dynamic)stmt);
}
}
public void Visit(NFunDef nFunDef)
{
currentFunction = semanticAnalyzer.GetFunctionSymbolByLexeme(nFunDef.AnchorToken.Lexeme);
// No need to visit neither parameter list nor variable definition list
NStmtList stmtList = (NStmtList)nFunDef[2];
Visit(stmtList);
currentFunction = null;
}
// Returns NStmtList
public Node StmtList()
{
NStmtList nStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
return(nStmtList);
}
// Returns NStmtList
public Node Default()
{
NStmtList nStmtList = new NStmtList();
Expect(TokenCategory.DEFAULT);
Expect(TokenCategory.COLON);
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
return(nStmtList);
}
public string Visit(NStmtList nStmtList)
{
string retVal = "";
foreach (Node stmt in nStmtList)
{
retVal += Visit((dynamic)stmt);
if (stmt.GetType() == typeof(NFunCall))
{
retVal += "\t\tpop\n";
}
}
return(retVal);
}
// Returns NIfStmt
public Node IfStmt()
{
NIfStmt nIfStmt = new NIfStmt();
Expect(TokenCategory.PARENTHESIS_LEFT);
nIfStmt.Add(Expr());
Expect(TokenCategory.PARENTHESIS_RIGHT);
Expect(TokenCategory.CURLY_BRACE_LEFT);
NStmtList nStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
nIfStmt.Add(nStmtList);
Expect(TokenCategory.CURLY_BRACE_RIGHT);
while (CurrentToken == TokenCategory.ELSE)
{
Expect(TokenCategory.ELSE);
if (CurrentToken == TokenCategory.IF)
{
Expect(TokenCategory.IF);
Expect(TokenCategory.PARENTHESIS_LEFT);
nIfStmt.Add(Expr());
Expect(TokenCategory.PARENTHESIS_RIGHT);
Expect(TokenCategory.CURLY_BRACE_LEFT);
NStmtList otherNStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(otherNStmtList);
}
nIfStmt.Add(otherNStmtList);
Expect(TokenCategory.CURLY_BRACE_RIGHT);
}
else if (CurrentToken == TokenCategory.CURLY_BRACE_LEFT)
{
Expect(TokenCategory.CURLY_BRACE_LEFT);
NStmtList otherNStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(otherNStmtList);
}
nIfStmt.Add(otherNStmtList);
Expect(TokenCategory.CURLY_BRACE_RIGHT);
break;
}
}
return(nIfStmt);
}
public string Visit(NSwitchStmt nSwitchStmt)
{
string retVal = "";
string exitAll = GenerateLabel();
Node testVar = nSwitchStmt[0];
retVal += Visit((dynamic)testVar);
NCaseList nCaseList = (NCaseList)nSwitchStmt[1];
retVal += Visit((dynamic)nCaseList, exitAll);
NStmtList nStmtList = (NStmtList)nSwitchStmt[2];
retVal += Visit((dynamic)nStmtList);
retVal += exitAll + ":\n";
retVal += "\t\tpop\n";
return(retVal);
}
// Returns NWhileStmt
public Node WhileStmt()
{
NWhileStmt nWhileStmt = new NWhileStmt();
Expect(TokenCategory.WHILE);
Expect(TokenCategory.PARENTHESIS_LEFT);
nWhileStmt.Add(Expr());
Expect(TokenCategory.PARENTHESIS_RIGHT);
Expect(TokenCategory.CURLY_BRACE_LEFT);
NStmtList nStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
nWhileStmt.Add(nStmtList);
Expect(TokenCategory.CURLY_BRACE_RIGHT);
return(nWhileStmt);
}
//Returns NCase
public Node Case()
{
NCase nCase = new NCase();
Expect(TokenCategory.CASE);
nCase.Add(Lit());
while (CurrentToken == TokenCategory.COMMA)
{
Expect(TokenCategory.COMMA);
nCase.Add(Lit());
}
Expect(TokenCategory.COLON);
NStmtList nStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
nCase.Add(nStmtList);
return(nCase);
}
// Returns NForStmt
public Node ForStmt()
{
Expect(TokenCategory.FOR);
Expect(TokenCategory.PARENTHESIS_LEFT);
NForStmt nForStmt = new NForStmt()
{
AnchorToken = Expect(TokenCategory.IDENTIFIER)
};
Expect(TokenCategory.IN);
nForStmt.Add(Expr());
Expect(TokenCategory.PARENTHESIS_RIGHT);
Expect(TokenCategory.CURLY_BRACE_LEFT);
NStmtList nStmtList = new NStmtList();
while (firstOfStatement.Contains(CurrentToken))
{
Stmt(nStmtList);
}
nForStmt.Add(nStmtList);
Expect(TokenCategory.CURLY_BRACE_RIGHT);
return(nForStmt);
}
// Appends NStmt to nStmtList
public void Stmt(NStmtList nStmtList)
{
switch (CurrentToken)
{
case TokenCategory.IDENTIFIER: {
Token tokenForAnchor = Expect(TokenCategory.IDENTIFIER);
if (CurrentToken == TokenCategory.ASSIGN)
{
NAssign nAssign = new NAssign()
{
AnchorToken = tokenForAnchor
};
nAssign.Add(Assign());
nStmtList.Add(nAssign);
}
else if (CurrentToken == TokenCategory.PARENTHESIS_LEFT)
{
NFunCall nFunCall = new NFunCall()
{
AnchorToken = tokenForAnchor
};
nFunCall.Add(FunCall());
nStmtList.Add(nFunCall);
}
else
{
throw new SyntaxError(new HashSet <TokenCategory>()
{
TokenCategory.ASSIGN,
TokenCategory.PARENTHESIS_LEFT
}
, tokenStream.Current);
}
break;
}
case TokenCategory.IF: {
Expect(TokenCategory.IF);
nStmtList.Add(IfStmt());
break;
}
case TokenCategory.SWITCH: {
nStmtList.Add(SwitchStmt());
break;
}
case TokenCategory.WHILE: {
nStmtList.Add(WhileStmt());
break;
}
case TokenCategory.DO: {
nStmtList.Add(DoWhileStmt());
break;
}
case TokenCategory.FOR: {
nStmtList.Add(ForStmt());
break;
}
case TokenCategory.BREAK: {
nStmtList.Add(new NBreak()
{
AnchorToken = Expect(TokenCategory.BREAK)
});
Expect(TokenCategory.SEMICOLON);
break;
}
case TokenCategory.CONTINUE: {
nStmtList.Add(new NContinue()
{
AnchorToken = Expect(TokenCategory.CONTINUE)
});
Expect(TokenCategory.SEMICOLON);
break;
}
case TokenCategory.RETURN: {
Expect(TokenCategory.RETURN);
NReturn nReturn = new NReturn();
Node returnExpression = Expr();
if (returnExpression != null)
{
nReturn.Add(returnExpression);
}
nStmtList.Add(nReturn);
Expect(TokenCategory.SEMICOLON);
break;
}
case TokenCategory.SEMICOLON: {
Expect(TokenCategory.SEMICOLON);
break;
}
default: {
throw new SyntaxError(firstOfStatement, tokenStream.Current);
}
}
}
//-----------------------------------------------------------
public void Visit(NStmtList node)
{
Console.WriteLine($"+++++++++++++++ NStmtList ++++++++++++++++");
VisitChildren(node);
}
