Beispiel #1
0
        /**
         * Verifica se é uma identacao, caso for tambem verifica se é valida
         */
        private int VerifyIdentation(string readLine)
        {
            /* Verifica identação com espaços */
            int spaces = 0;

            while (readLine[spaces].Equals(' '))
            {
                spaces++;
                if (spaces >= readLine.Length)
                {
                    break;
                }
            }

            /* Verifica identação com tabulação */
            int tabulacao = 0;

            while (readLine[tabulacao].Equals('\t'))
            {
                tabulacao++;
                if (tabulacao >= readLine.Length)
                {
                    break;
                }
            }

            if (spaces.Equals(0))
            {
                spaces = tabulacao * 4;
            }

            if (spaces < readLine.Length)
            {
                if (readLine[spaces].Equals('#'))
                {
                    return(1);
                }
            }

            /* Verifica se identou */
            if (spaces > IdentationLevel.Peek())
            {
                var newToken = new TokensFound("TOKEN.INDENT", "Indentenção", 0, Line);
                TokensFound.Add(newToken);
                IdentationLevel.Push(spaces);
            }
            /* Verifica se desidentou */
            else if (spaces < IdentationLevel.Peek())
            {
                while (spaces != IdentationLevel.Peek())
                {
                    IdentationLevel.Pop();
                    var newToken = new TokensFound("TOKEN.DEDENT", "Desindentenção", 0, Line);
                    TokensFound.Add(newToken);
                }
            }

            return(2);
        }
Beispiel #2
0
        /**
         * Realiza análise léxica do arquivo
         */
        public bool LexicalAnalysis(string filePath)
        {
            Tokens = new Tokens();

            try
            {
                StreamReader streamReader = new StreamReader(filePath);
                {
                    string      readLine;
                    TokensFound newToken    = null;
                    bool        isOnComment = false;

                    while ((readLine = streamReader.ReadLine()) != null)
                    {
                        Position = 0;

                        /* Linha de espaçamento */
                        readLine = readLine.TrimEnd();

                        if (readLine.Length.Equals(0))
                        {
                            continue;
                        }

                        /* Verifica se começa com um comentário múltiplo */
                        var lineAux = Line;
                        isOnComment = VerifyMultipleComment(readLine, isOnComment);

                        /* Se esta num comentario, entao ignora o que tem dentro */
                        if (!isOnComment)
                        {
                            if (!lineAux.Equals(Line))
                            {
                                continue;
                            }

                            /* Verifica se começa com um comentario de uma linha */
                            if (readLine[0].Equals('#'))
                            {
                                newToken = new TokensFound("TOKEN.COMENTARIO", "Comentário", 0, Line);
                                TokensFound.Add(newToken);
                                Line++;
                                continue;
                            }

                            var returnIdentation = VerifyIdentation(readLine);

                            if (returnIdentation.Equals(0))
                            {
                                return(false);
                            }
                            else if (returnIdentation.Equals(1))
                            {
                                continue;
                            }

                            for (Position = IdentationLevel.Peek(); Position < readLine.Length; Position++)
                            {
                                isOnComment = VerifyMultipleComment(readLine, isOnComment);

                                /* Se esta num comentario, entao ignora o que tem dentro */
                                if (!isOnComment)
                                {
                                    var returnOpeDelim = VerifyOperatorsAndDelimeters(readLine);
                                    if (returnOpeDelim.Equals(1))
                                    {
                                        continue;
                                    }
                                    else if (returnOpeDelim.Equals(2))
                                    {
                                        break;
                                    }


                                    switch (VerifyTypes(readLine))
                                    {
                                    case 0: return(false);

                                    case 1: continue;
                                    }

                                    if (VerifyKeywordsAndIds(readLine))
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    break;
                                }
                            }
                        }

                        Line++;
                    }

                    while (IdentationLevel.Count > 1)
                    {
                        newToken = new TokensFound("TOKEN.DEDENT", "Desindentenção", 0, Line);
                        TokensFound.Add(newToken);
                        IdentationLevel.Pop();
                    }

                    /* Adiciona token de final do arquivo quando termina de encontrar outros tokens */
                    newToken = new TokensFound("TOKEN.EOF", "EOF", TokensFound[TokensFound.Count - 1].Column + 1, TokensFound[TokensFound.Count - 1].Line);
                    TokensFound.Add(newToken);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return(true);
        }