Esempio n. 1
0
        public Type Visit(Int_Literal node)
        {
            var tempInt = node.AnchorToken.Lexeme;

            try
            {
                Convert.ToInt32(tempInt);
            }
            catch (OverflowException)
            {
                throw new SemanticError("Integer literal: " + tempInt + " too large ", node.AnchorToken);
            }
            return(Type.INT);
        }
Esempio n. 2
0
        public Node SimpleExpression()
        {
            switch (CurrentToken)
            {
            case TokenCategory.PARENTHESIS_OPEN:
                Expect(TokenCategory.PARENTHESIS_OPEN);
                var expr = Expression();
                Expect(TokenCategory.PARENTHESIS_CLOSE);
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var result = new ListItem();
                    result.Add(expr);
                    auxiliarMethod(result);
                    return(result);
                }
                else
                {
                    return(expr);
                }

            case TokenCategory.IDENTIFIER:
                var identifier = Expect(TokenCategory.IDENTIFIER);
                if (CurrentToken == TokenCategory.PARENTHESIS_OPEN)
                {
                    var result = Call();
                    result.AnchorToken = identifier;
                    if (CurrentToken == TokenCategory.BRACKET_OPEN)
                    {
                        var call = new ListItem();
                        call.Add(result);
                        auxiliarMethod(call);
                        return(call);
                    }
                    else
                    {
                        return(result);
                    }
                }
                else
                {
                    if (CurrentToken == TokenCategory.BRACKET_OPEN)
                    {
                        var listI = new ListItem();
                        listI.Add(new Identifier()
                        {
                            AnchorToken = identifier
                        });
                        auxiliarMethod(listI);
                        return(listI);
                    }
                    else
                    {
                        var id = new Identifier()
                        {
                            AnchorToken = identifier
                        };
                        return(id);
                    }
                }

            case TokenCategory.INT_LITERAL:
                var iLiteral = new Int_Literal()
                {
                    AnchorToken = Expect(TokenCategory.INT_LITERAL)
                };
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var listI = new ListItem();
                    listI.Add(iLiteral);
                    auxiliarMethod(listI);
                    return(listI);
                }
                else
                {
                    return(iLiteral);
                }

            case TokenCategory.STR_LITERAL:
                var sLiteral = new Str_Literal()
                {
                    AnchorToken = Expect(TokenCategory.STR_LITERAL)
                };
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var listI = new ListItem();
                    listI.Add(sLiteral);
                    auxiliarMethod(listI);
                    return(listI);
                }
                else
                {
                    return(sLiteral);
                }

            case TokenCategory.TRUE:
                var tLiteral = new True()
                {
                    AnchorToken = Expect(TokenCategory.TRUE)
                };
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var listI = new ListItem();
                    listI.Add(tLiteral);
                    auxiliarMethod(listI);
                    return(listI);
                }
                else
                {
                    return(tLiteral);
                }

            case TokenCategory.FALSE:
                var fLiteral = new False()
                {
                    AnchorToken = Expect(TokenCategory.FALSE)
                };
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var listI = new ListItem();
                    listI.Add(fLiteral);
                    auxiliarMethod(listI);
                    return(listI);
                }
                else
                {
                    return(fLiteral);
                }

            case TokenCategory.BRACE_OPEN:
                var list = List();
                if (CurrentToken == TokenCategory.BRACKET_OPEN)
                {
                    var listI = new ListItem();
                    listI.Add(list);
                    auxiliarMethod(listI);
                    return(listI);
                }
                else
                {
                    return(list);
                }

            default:
                throw new SyntaxError(firstOfSimpleExpression,
                                      tokenStream.Current);
            }
        }