public void GenerateCode(DoWhileNode node, ICIL_CodeGenerator codeGenerator)
{
//Loop:
// GenCode <Body>
// GenCode <ExprCond>
// if ExprCond = true Goto Loop
// holder = -1
var loop = codeGenerator.DefineLabel();
codeGenerator.AddInstruction(new Label(loop));
GenerateCode(node.Body, codeGenerator);
GenerateCode(node.Condition, codeGenerator);
codeGenerator.AddInstruction(
new ConditionalJump((Variable)node.Body.Holder, true, loop));
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
codeGenerator.AddInstruction(
new Assign((Variable)node.Holder, -1));
}
private TypeDescriptor Visit(DoWhileNode node, Context context)
{
Visit(node.Condition, context);
Visit(node.Command, context);
return(null);
}
public DoWhileBuilder(DoWhileNode dowhilenode)
{
node = dowhilenode;
DotDefinition = new List <IDotElement>();
CreateNode();
CreateEdgeToFirstChildren();
CreateEndNode();
CreateLoopEdge();
CreateEdgeToNextSibling();
}
private void Visit(DoWhileNode node, MethodBuilder builder, CodegenContext context)
{
int nop = builder.Nop();
Visit(node.Command, builder, context);
Visit(node.Condition, builder, context);
int jmp = builder.PrepareJump(true);
builder.MakeJump(jmp, nop, Jump.IfFalse);
}
public Word Visit(DoWhileNode doWhileNode)
{
ControlStack.Push(ControlType.Loop);
Word result;
PyObj pyObj;
MyBoolean myBool;
while (true)
{
result = doWhileNode.Block.Accept(this);
if (IsJumper(result))
{
var jumper = (Jumper)result;
if (jumper.GetJumperType() == JumperType.Breaker)
{
return(null);
}
else if (jumper.GetJumperType() != JumperType.Continue)
{
return(jumper);
}
//Si es continue no tiene que hacer nada porque el block ya interumpio la ejecucion 1 vez
}
result = doWhileNode.Condition.Accept(this);
if (IsError(result))
{
ControlStack.Pop();
return(result);
}
if (IsMemoryBlock(result))//comentar ese if else si se hace la desereferencia en atomic expr.
{
pyObj = ((MemoryBlock)result).Value;
}
else
{
pyObj = (PyObj)result;
}
//pyObj = (PyObj)result;//Descomentar esta linea si se hace la desereferencia en atomic expr.
if (pyObj.GetMyType() != TypeConstants.BOOLEAN)
{
ControlStack.Pop();
return(ErrorFactory.WhileError(doWhileNode, pyObj));
}
myBool = (MyBoolean)pyObj;
if (!myBool.Bool)
{
break;
}
}
ControlStack.Pop();
return(null);
}
private Statement ProcessDoWhileStatement(DoWhileNode node)
{
Expression condition = _expressionBuilder.BuildExpression(node.Condition);
if (condition is MemberExpression)
{
condition = _expressionBuilder.TransformMemberExpression((MemberExpression)condition);
}
Statement body = BuildStatement((StatementNode)node.Body);
return(new WhileStatement(condition, body, /* preCondition */ false));
}
public void CheckSemantic(DoWhileNode node, IScope scope = null)
{
CheckSemantic(node.Body, scope);
CheckSemantic(node.Condition, scope);
if (node.Condition.ComputedType.Name != "Bool")
{
Logger.LogError(node.Condition.Line, node.Condition.CharPositionInLine,
$"Cannot implicity convert type '{node.Condition.ComputedType}'to 'Bool'");
return;
}
TypeTable.IsDefinedType("Object", out var objType);
node.ComputedType = objType;
}
public bool VisitDoWhileNode(DoWhileNode node, CompilationState state)
{
state.Write("repeat");
state.NewLine();
state.Ident();
node.Body.AcceptVisitor(this, state);
state.NewLine();
state.FinishIdent();
state.Write("until (");
state.Write("not ");
EncapsulateOrNot(state, node.Condition);
state.Write(")");
return(true);
}
public void Accept(DoWhileNode node)
{
var bodyLabel = nextLabel();
var endLabel = nextLabel();
int breakLabelCount = methodStack.Peek().BreakLabels.Count;
int continueLabelCount = methodStack.Peek().ContinueLabels.Count;
methodStack.Peek().BreakLabels.Push(endLabel);
methodStack.Peek().ContinueLabels.Push(bodyLabel);
emitLabel(node.Body.SourceLocation, bodyLabel);
node.Body.Visit(this);
node.Condition.Visit(this);
emit(node.Body.SourceLocation, InstructionType.JumpIfTrue, bodyLabel);
emitLabel(node.Condition.SourceLocation, endLabel);
restoreLabels(breakLabelCount, continueLabelCount);
}
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);
}
}
}
public object Process(Parser parser, SortedDictionary <string, object> parameters)
{
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(null);
}
else if (parser.CurrenToken.Type == TokenType.KwIf)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _ifCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
var _ifNotCode = (ElseNode) new IfNot().Process(parser, parameters);
var _if = new IfNode {
EvaluationNode = _evaluation, IfCode = _ifCode, IfNotCode = _ifNotCode
};
return(_if);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwWhile)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _whileCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
var _while = new WhileNode {
EvaluationNode = _evaluation, CodeNode = _whileCode
};
return(_while);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwFor)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _for = (ForNode) new ForConditions().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _forCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
_for.CodeNode = _forCode;
return(_for);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwBreak)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(new BreakNode());
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwContinue)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(new ContinueNode());
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwThrow)
{
var _throw = new ThrowStatement().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(_throw);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwSwitch)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftCurlyBracket)
{
parser.NextToken();
var _caseBlock = (BaseCaseNode) new CaseBlock().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightCurlyBracket)
{
parser.NextToken();
var _switch = new SwitchNode {
EvaluationNode = _evaluation, CaseBlockNode = _caseBlock
};
return(_switch);
}
else
{
throw new ParserException("This was expected } Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected { Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwDo)
{
parser.NextToken();
var _doWhileCode = (List <StatementNode>) new Statementp().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.KwWhile)
{
parser.NextToken();
if (parser.CurrenToken.Type == TokenType.PmLeftParent)
{
parser.NextToken();
var _evaluation = (ExpressionNode) new AssignmentExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmRightParent)
{
parser.NextToken();
var _doWhile = new DoWhileNode {
EvaluationNode = _evaluation, CodeNode = _doWhileCode
};
return(_doWhile);
}
else
{
throw new ParserException("This was expected ) Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected ( Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else
{
throw new ParserException("This was expected the token: while, Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwReturn)
{
parser.NextToken();
var _returnEp = (List <ExpressionNode>) new ExpressionOpt().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
var _return = new ReturnNode {
ReturnExpressionNode = _returnEp
};
return(_return);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
else if (parser.CurrenToken.Type == TokenType.KwTry)
{
parser.NextToken();
var _tryCode = (List <StatementNode>) new CompoundStatement().Process(parser, parameters);
var _try = (TryNode) new CatchBlock().Process(parser, parameters);
var _finally = (FinallyNode) new FinallyBlock().Process(parser, parameters);
_try.FinallyCode = _finally;
_try.TryCode = _tryCode;
return(_try);
}
else
{
var _varEp = new VariablesOrExpression().Process(parser, parameters);
if (parser.CurrenToken.Type == TokenType.PmSemicolon)
{
parser.NextToken();
return(_varEp);
}
else
{
throw new ParserException("This was expected ; Received: [" +
parser.CurrenToken.LexemeVal + "], Row: " + parser.CurrenToken.Row
+ ", Column: " + parser.CurrenToken.Column);
}
}
}
