private bool ParseFunctionCall(Lexer lexer, Attributes attributes, string identifierName, out Expression tree)
        {
            var successfullyParsed = true;
            var functionCall       = new FunctionCallExpression();
            var environments       = attributes["ENVS"] as Environments;
            var functionCallToken  = lexer.GetCurrentToken();

            // SEM: Verifico que exista una funcion con el identificador indicado.
            if (!environments.ExistsFunction(identifierName))
            {
                LogFunctionNotFound(lexer.GetCurrentToken(), identifierName);
                successfullyParsed = false;
            }

            functionCall.Identifier = identifierName;
            functionCall.Reference  = environments.FindFunction(identifierName);

            attributes.AddAttribute(functionCall.ActualParameters, "PARMS");

            successfullyParsed &= ParserFactory.GetActualParametersParser().Parse(lexer, lexer.GetNextToken(), attributes);

            var function = environments.GetSubroutine(functionCall.Reference) as Function;

            if (function != null)
            {
                // SEM: Verifico que la cantidad y el tipo de los parametros usados en la llamada coincidan con los de la
                // definición de la funcion.
                if (!FormalParametersParser.ValidateFormalParametersVsActualParameters(
                        function.Environment.FormalParameters.ToList(), functionCall.ActualParameters.Parameters))
                {
                    LogInvalidParametersCountOrType(identifierName, functionCallToken);
                    successfullyParsed = false;
                }

                // SEM: Verifico que no se pasen arrays completos como parametro de una funcion.
                if (ActualParametersParser.VerifyIfArraysArePassedAsParameters(environments,
                                                                               functionCall.ActualParameters.Parameters))
                {
                    LogArrayCantBeSubroutineParameter(functionCallToken, functionCall.Identifier);
                    successfullyParsed = false;
                }

                functionCall.Type = function.ReturnType;
            }

            attributes.RemoveAttribute("PARMS");

            ValidateToken(lexer.GetCurrentToken(), TokenType.RightParenthesis);

            tree = functionCall;

            return(successfullyParsed);
        }
Beispiel #2
0
        private bool ParseProcedureCall(string identifier, Lexer lexer, Attributes attributes)
        {
            var successfullyParsed = true;
            var procedureCallToken = lexer.GetCurrentToken();
            var environments       = attributes["ENVS"] as Environments;

            //SEM: Validar que la subrutina exista en el scope y sea un procedimiento
            if (!environments.ExistsProcedure(identifier))
            {
                LogProcedureNotFound(lexer.GetCurrentToken(), identifier);
                successfullyParsed = false;
            }

            var procedureCallTree = new ProcedureCall();

            procedureCallTree.Identifier = identifier;
            procedureCallTree.Reference  = environments.FindProcedure(identifier);

            attributes.AddAttribute(procedureCallTree.ActualParameters, "PARMS");

            successfullyParsed &= ParserFactory.GetActualParametersParser().Parse(lexer, lexer.GetNextToken(), attributes);

            var procedure = environments.GetSubroutine(procedureCallTree.Reference);

            if (procedure != null)
            {
                // SEM: Verifico que la cantidad y el tipo de los parametros usados en la llamada coincidan con los de la
                // definición de la funcion.
                if (!FormalParametersParser.ValidateFormalParametersVsActualParameters(
                        procedure.Environment.FormalParameters.ToList(), procedureCallTree.ActualParameters.Parameters))
                {
                    LogInvalidParametersCountOrType(identifier, procedureCallToken);
                    successfullyParsed = false;
                }

                // SEM: Verifico que no se pasen arrys completos como parametro de un procedimiento.
                if (ActualParametersParser.VerifyIfArraysArePassedAsParameters(environments,
                                                                               procedureCallTree.ActualParameters.Parameters))
                {
                    LogArrayCantBeSubroutineParameter(procedureCallToken, procedure.Identifier);
                    successfullyParsed = false;
                }
            }

            attributes.RemoveAttribute("PARMS");

            ValidateToken(lexer.GetCurrentToken(), TokenType.RightParenthesis);
            ValidateToken(lexer.GetNextToken(), TokenType.EndOfInstruction);

            attributes.AddAttribute(procedureCallTree, "AOC");

            return(successfullyParsed);
        }