From 07079366b804cbe6b95c15d4af14c06a727471fd Mon Sep 17 00:00:00 2001 From: Clemens-Dautermann Date: Thu, 20 Aug 2020 22:37:30 +0200 Subject: [PATCH] corrected implementation of unary operators --- .../.idea/.idea.Compiler/.idea/workspace.xml | 154 ++++++++++-------- Compiler/Compiler.cs | 22 +-- Compiler/Parser/Nodes/ConstantNode.cs | 2 +- Compiler/Parser/Nodes/NodeType.cs | 2 + Compiler/Parser/Nodes/UnaryOperatorNode.cs | 2 +- Compiler/Parser/Parser.cs | 91 +++++++---- 6 files changed, 156 insertions(+), 117 deletions(-) diff --git a/Compiler/.idea/.idea.Compiler/.idea/workspace.xml b/Compiler/.idea/.idea.Compiler/.idea/workspace.xml index 8cb404b..578830b 100644 --- a/Compiler/.idea/.idea.Compiler/.idea/workspace.xml +++ b/Compiler/.idea/.idea.Compiler/.idea/workspace.xml @@ -20,27 +20,12 @@ - - - - - - - - - - - - - - - - + + - @@ -224,86 +211,102 @@ - + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - - + + - + + + + + + + + + + + + + + + + + @@ -328,10 +331,10 @@ - - + + - + @@ -345,4 +348,23 @@ + + + + + file://$PROJECT_DIR$/Compiler.cs + 138 + + + + + + + + + + \ No newline at end of file diff --git a/Compiler/Compiler.cs b/Compiler/Compiler.cs index c715648..1d66f96 100644 --- a/Compiler/Compiler.cs +++ b/Compiler/Compiler.cs @@ -139,22 +139,18 @@ namespace Compiler { switch (root.NodeType) { - case NodeType.ExpressionNode: - if (root is UnaryOperatorNode) - { - Console.WriteLine(indent + root.NodeType + ":" + ((UnaryOperatorNode) root).OperatorType); - } - - if (root is ConstantNode) - { - Console.WriteLine(indent + root.NodeType + ":" + ((ConstantNode) root).value); - } - break; case NodeType.FunctionNode: Console.WriteLine(indent + root.NodeType + ":" + ((FunctionNode) root).Name); break; - case NodeType.ProgramNode: - case NodeType.ReturnStatementNode: + case NodeType.ConstantNode: + Console.WriteLine(indent + root.NodeType + ":" + ((ConstantNode) root).value); + break; + case NodeType.UnaryOperatorNode: + Console.WriteLine(indent + root.NodeType + ":" + ((UnaryOperatorNode) root).OperatorType); + break; + + default: + Console.WriteLine(indent + root.NodeType); break; } diff --git a/Compiler/Parser/Nodes/ConstantNode.cs b/Compiler/Parser/Nodes/ConstantNode.cs index 2e7b315..1a1c7cb 100644 --- a/Compiler/Parser/Nodes/ConstantNode.cs +++ b/Compiler/Parser/Nodes/ConstantNode.cs @@ -7,7 +7,7 @@ namespace Compiler.Parser.Nodes public ConstantNode(int value) { - this.NodeType = NodeType.ExpressionNode; + this.NodeType = NodeType.ConstantNode; this.value = value; } } diff --git a/Compiler/Parser/Nodes/NodeType.cs b/Compiler/Parser/Nodes/NodeType.cs index d760db2..919242a 100644 --- a/Compiler/Parser/Nodes/NodeType.cs +++ b/Compiler/Parser/Nodes/NodeType.cs @@ -6,6 +6,8 @@ namespace Compiler.Parser.Nodes FunctionNode, ReturnStatementNode, ExpressionNode, + ConstantNode, + UnaryOperatorNode } } \ No newline at end of file diff --git a/Compiler/Parser/Nodes/UnaryOperatorNode.cs b/Compiler/Parser/Nodes/UnaryOperatorNode.cs index bdb6266..5769587 100644 --- a/Compiler/Parser/Nodes/UnaryOperatorNode.cs +++ b/Compiler/Parser/Nodes/UnaryOperatorNode.cs @@ -8,7 +8,7 @@ namespace Compiler.Parser.Nodes public UnaryOperatorNode(OperatorType operatorType) { OperatorType = operatorType; - NodeType = NodeType.ExpressionNode; + NodeType = NodeType.UnaryOperatorNode; } } } \ No newline at end of file diff --git a/Compiler/Parser/Parser.cs b/Compiler/Parser/Parser.cs index ebb58ed..0b3e82c 100644 --- a/Compiler/Parser/Parser.cs +++ b/Compiler/Parser/Parser.cs @@ -102,7 +102,6 @@ namespace Compiler.Parser //remove trailing ; CheckFirstTokenAndRemove(TokenType.SemicolonToken); - break; case NodeType.ExpressionNode: @@ -114,53 +113,73 @@ namespace Compiler.Parser Token expressionToken = _tokenList[0]; - //the next token might be a constant or any operator switch (expressionToken.TokenType) { case TokenType.IntegerLiteralToken: - //remove int literal token - _tokenList.RemoveAt(0); - - //check if value Type is right - if (expressionToken.Value.GetType() != typeof(int)) - { - throw new WrongTypeException(typeof(int), expressionToken.Value.GetType()); - } - - //return final constant node to end recursion - n = new ConstantNode((int) expressionToken.Value); - break; - case TokenType.NegationToken: - _tokenList.RemoveAt(0); - n = new UnaryOperatorNode(OperatorType.Negation); - n.Children.Add(Parse(NodeType.ExpressionNode)); + n = Parse(NodeType.ConstantNode); break; case TokenType.BitwiseComplementToken: - _tokenList.RemoveAt(0); - n = new UnaryOperatorNode(OperatorType.BitwiseComplement); - n.Children.Add(Parse(NodeType.ExpressionNode)); - break; + case TokenType.NegationToken: case TokenType.LogicalNegationToken: - _tokenList.RemoveAt(0); - n = new UnaryOperatorNode(OperatorType.LogicalNegation); - n.Children.Add(Parse(NodeType.ExpressionNode)); + n = Parse(NodeType.UnaryOperatorNode); break; - case TokenType.IntToken: - case TokenType.OpenParenthesisToken: - case TokenType.CloseParenthesisToken: - case TokenType.OpenBraceToken: - case TokenType.CloseBraceToken: - case TokenType.ReturnToken: - case TokenType.SemicolonToken: - case TokenType.IdentifierToken: - case TokenType.InvalidToken: - throw new UnexpectedTokenException(TokenType.IntToken, expressionToken.TokenType); default: - throw new UnexpectedTokenException(TokenType.IntToken, expressionToken.TokenType); + throw new UnexpectedTokenException(TokenType.IntegerLiteralToken, + expressionToken.TokenType); + } + break; + + case NodeType.UnaryOperatorNode: + if (_tokenList.Count == 0) + { + throw new MissingTokenException(TokenType.IntegerLiteralToken); + } + else + { + Token unaryOperator = _tokenList[0]; + _tokenList.RemoveAt(0); + + switch (unaryOperator.TokenType) + { + case TokenType.BitwiseComplementToken: + n = new UnaryOperatorNode(OperatorType.BitwiseComplement); + n.Children.Add(Parse(NodeType.ExpressionNode)); + break; + case TokenType.NegationToken: + n = new UnaryOperatorNode(OperatorType.Negation); + n.Children.Add(Parse(NodeType.ExpressionNode)); + break; + case TokenType.LogicalNegationToken: + n = new UnaryOperatorNode(OperatorType.LogicalNegation); + n.Children.Add(Parse(NodeType.ExpressionNode)); + break; + default: + throw new UnexpectedTokenException(TokenType.IntegerLiteralToken, + unaryOperator.TokenType); + } } break; + case NodeType.ConstantNode: + + if (_tokenList.Count == 0) + { + throw new MissingTokenException(TokenType.IntegerLiteralToken); + } + + //double check, for safety. Pbly unnecesarry + if (_tokenList[0].TokenType != TokenType.IntegerLiteralToken) + { + throw new UnexpectedTokenException(TokenType.IntegerLiteralToken, _tokenList[0].TokenType); + } + else + { + //return final constant node to end recursion + n = new ConstantNode((int) _tokenList[0].Value); + _tokenList.RemoveAt(0); + break; + } default: throw new Exception("Unknown Node Type " + nodeType); }