public override void Visit(ElifNode node)
{
CSharpString.Append("else if (");
node.ControlExpr.Accept(this);
CSharpString.Append(")");
node.ElifBody.Accept(this);
}
public override void Visit(ElifNode node)
{
Console.Write("elif (");
node.ControlExpr.Accept(this);
Console.Write(")");
node.ElifBody.Accept(this);
}
public override void Visit(ElifNode node)
{
symbolTable.OpenScope();
node.ControlExpr.Accept(this);
if (node.ControlExpr.Type != "bool")
{
throw new SemanticException($"Error on line {node.line}: Elif control expression expected type bool, was {node.ControlExpr.Type}.");
}
node.ElifBody.Accept(this);
symbolTable.CloseScope();
}
private SyntaxNode Node(SyntaxType parent, int start, int end, List <Token> tokens, List <Error> compileErrors)
{
switch (parent)
{
case SyntaxType.Program:
{
SyntaxNode node = new ProgramNode();
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of class declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Class, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.InterfaceDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of interface declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.ClassDeclaration:
case TokenType.InterfaceDeclaration:
left++;
break;
case TokenType.ClassEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.Interface, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in program body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Class:
{
SyntaxNode node = new ClassNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
case TokenType.MainMethodDeclaration:
{
var newStart = i + 1;
var left = 1;
var right = 0;
while (left != right)
{
i++;
if (i >= end)
{
compileErrors.Add(new Error("Missing end of main method declaration"));
return(null);
}
switch (tokens[i].Type)
{
case TokenType.MethodDeclaration:
case TokenType.MainMethodDeclaration:
left++;
break;
case TokenType.MethodEndDeclaration:
right++;
break;
}
}
var childNode = Node(SyntaxType.MainMethodDeclaring, newStart, i, tokens, compileErrors);
if (childNode == null)
{
return(null);
}
node.Nodes.Add(childNode);
break;
}
default:
{
if (IsTokenWhiteSpace(tokens[i]))
{
continue;
}
compileErrors.Add(new Error("Unexpected expression in class body"));
return(null);
}
}
}
return(node);
}
case SyntaxType.Interface:
{
SyntaxNode node = new InterfaceNode(tokens[start - 1], tokens[end]);
for (var i = start; i < end; i++)
{
if (tokens[i].Type == TokenType.MethodDeclaration)
{
node.Nodes.Add(new InterfaceMethodNode(tokens[i]));
}
else if (IsTokenWhiteSpace(tokens[i]))
{
}
else
{
compileErrors.Add(new Error("Unexpected expression in interface body"));
return(null);
}
}
return(node);
}
case SyntaxType.MethodDeclaring:
case SyntaxType.MainMethodDeclaring:
{
SyntaxNode node = new MethodNode(tokens[start - 1], tokens[end], parent == SyntaxType.MainMethodDeclaring);
Node(parent, start, end, tokens, compileErrors, node, "method");
return(node);
}
case SyntaxType.Switch:
{
SyntaxNode node = new SwitchNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "switch");
return(node);
}
case SyntaxType.SwitchCase:
{
SyntaxNode node = new SwitchCase(tokens[start - 1], tokens[start - 1].Type == TokenType.SwitchDefaultCase);
Node(parent, start, end, tokens, compileErrors, node, "switch case");
return(node);
}
case SyntaxType.IfTruePart:
{
SyntaxNode node = new IfTrueNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "if");
return(node);
}
case SyntaxType.IfFalsePart:
{
SyntaxNode node = new IfElseNode();
Node(parent, start, end, tokens, compileErrors, node, "else");
return(node);
}
case SyntaxType.ElifPart:
{
SyntaxNode node = new ElifNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "else-if");
return(node);
}
case SyntaxType.For:
{
SyntaxNode node = new ForNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "for");
return(node);
}
case SyntaxType.Foreach:
{
SyntaxNode node = new ForeachNode(tokens[start - 1], tokens[end]);
Node(parent, start, end, tokens, compileErrors, node, "foreach");
return(node);
}
case SyntaxType.While:
{
SyntaxNode node = new WhileNode(tokens[start - 1].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "while");
return(node);
}
case SyntaxType.DoWhile:
{
SyntaxNode node = new DoWhileNode(tokens[end].Childs[0]);
Node(parent, start, end, tokens, compileErrors, node, "do-while");
return(node);
}
default:
{
compileErrors.Add(new Error("Not implemented parser behaviour"));
return(null);
}
}
}
internal abstract void Visit(ElifNode node);
public abstract void Visit(ElifNode node);
