Algo de trabajo en el parser.

Subv · Subv · commit 457d328ba356 · 2015-04-25T00:05:29.000-05:00
TODO: Pruebas
diff --git a/src/correctorcodigodoc/Comparador.java b/src/correctorcodigodoc/Comparador.java
@@ -4,6 +4,7 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import javax.swing.JOptionPane;
+import parser.ParserStatement;
 
 /**
  * @author Sebastian
@@ -148,6 +149,17 @@ public Comparador(String patron, String texto) {
     public ArrayList<Error> CompararLexer() {
         ArrayList<Error> errores_detectados = new ArrayList<Error>();
         
+        Parser parser = new Parser(lexer_texto);
+        try {
+            ParserStatement st = parser.parseStatement();
+            while (st != null)
+                st = parser.parseStatement();
+        } catch (Parser.ParseException ex) {
+            JOptionPane.showMessageDialog(null, ex.message);
+        }
+        
+        return errores_detectados;
+        /*
         ArrayList<Token> tokens_patron = new ArrayList<Token>();
         ArrayList<Token> tokens_texto = new ArrayList<Token>();
         
@@ -180,7 +192,7 @@ public ArrayList<Error> CompararLexer() {
             }
         }
         
-        return errores_detectados;
+        return errores_detectados;*/
     }
     
     public ArrayList<Error> CompararCaracteres() {
diff --git a/src/correctorcodigodoc/Lexer.java b/src/correctorcodigodoc/Lexer.java
@@ -13,7 +13,6 @@ public class Lexer {
     private char ultimo_caracter;
     private Token ultimo_token;
     private int lex_index;
-    private int lex_linea;
     
     private final static HashMap<String, Token.Ids> TiposToken;
     private final static HashMap<Character, Token.Ids> TokensAtomicos;
@@ -72,7 +71,6 @@ public Lexer(String program) {
         this.ultimo_caracter = ' ';
         this.lex_index = 0;
         this.ultimo_token = null;
-        this.lex_linea = 0;
     }
     
     private Token nextTokenInternal() {
@@ -163,6 +161,25 @@ public Token nextToken() {
         return next_token;
     }
     
+    public Token peekToken() {
+        // Guarda el índice y el caracter actual
+        int lex_idx = lex_index;
+        char ultimo_caract = ultimo_caracter;
+        
+        // Lexea un token
+        Token token = nextTokenInternal();
+        
+        // Restaura el índice y el caracter
+        lex_index = lex_idx;
+        ultimo_caracter = ultimo_caract;
+        
+        return token;
+    }
+    
+    public Token prevToken() {
+        return ultimo_token;
+    }
+    
     private char getChar() {
         return codigo[lex_index++];
     }
diff --git a/src/correctorcodigodoc/Parser.java b/src/correctorcodigodoc/Parser.java
@@ -5,14 +5,128 @@
  */
 package correctorcodigodoc;
 
+import parser.ParserStatement;
+import parser.DeclarationStatement;
+import parser.NullStatement;
+import compiladorpseu.Tokens.Token;
+import java.util.ArrayList;
+import java.util.List;
+import parser.Expression;
+import parser.Identifier;
+
 /**
  *
  * @author Sebastian
  */
 public class Parser {
+    public static class ParseException extends Exception {
+        public String message;
+        
+        public ParseException(String what) {
+            this.message = what;
+        }
+    }
+    
     private Lexer lexer;
+    private Token current_token;
     
     public Parser(Lexer lexer) {
         this.lexer = lexer;
+        this.current_token = lexer.nextToken();
+    }
+    
+    public ParserStatement parseStatement() throws ParseException {
+        if (current_token == null)
+            return null;
+        
+        Token next_token = lexer.nextToken();
+        ParserStatement statement = null;
+        
+        switch (current_token.id) {
+            case INICIO: // Nada que hacer
+            case PROC: // Nada que hacer
+            case FIN: // Nada que hacer
+            case NUEVA_LINEA: // Nada que hacer
+            case DOS_PUNTOS:
+                statement = new NullStatement();
+                break;
+                
+            case TIPO_DATO:
+                // El siguiente token debe ser un identificador o una lista
+                List<Identifier> tokens = parseIdentifierList(next_token);
+                if (tokens.isEmpty()) {
+                    throw new ParseException("Error de sintaxis en la lista de identificadores");
+                }
+                statement = new DeclarationStatement(tokens);
+                
+                // Ya nos comimos el último token, por tanto tenemos que retroceder una posición
+                next_token = lexer.prevToken();
+                break;
+        }
+        
+        current_token = next_token;
+        return statement;
+    }
+    
+    /*
+     * Parsea una lista de identificadores de la forma I1,I2,I3,I4...In
+     * Tira una excepción si la lista está malformada
+     * @param token_inicial El token que inicia la lista
+     * @returns Lista de identificadores parseada
+     */
+    public List<Identifier> parseIdentifierList(Token token_inicial) throws ParseException {
+        List<Identifier> ret = new ArrayList<Identifier>();
+        
+        Token token = token_inicial;
+        
+        while (token.id == Token.Ids.IDENTIFIER) {
+            ret.add(parseIdentifier(token));
+            
+            token = lexer.nextToken();
+            
+            // La lista termina con una nueva linea
+            if (token.id == Token.Ids.NUEVA_LINEA)
+                break;
+            
+            // Si lo que sigue no es una coma, tenemos un error de sintaxis
+            if (token.id != Token.Ids.COMA) {
+                throw new ParseException("Error de sintaxis en la lista de identificadores");
+            }
+            
+            token = lexer.nextToken();
+        }
+        
+        return ret;
+    }
+    
+    /*
+     * Parsea un identifier a partir de un token
+     * el identifier puede ser un array o una variable normal
+     * @param token_inicial El token por el que comienza el identifier
+     * @returns Identifier parseado
+     */
+    public Identifier parseIdentifier(Token token_inicial) throws ParseException {
+        Token next_token = lexer.peekToken();
+        
+        if (next_token.id == Token.Ids.PARENTESIS_ABRE) {
+            // El identificador es un arreglo, parsea los parametros hasta el (
+            // Comete el (
+            lexer.nextToken();
+            List<Expression> parametros = parseExpressionList(lexer.nextToken(), Token.Ids.PARENTESIS_CIERRA);
+            if (parametros.isEmpty()) {
+                throw new ParseException("Error de sintaxis en la lista de identificadores");
+            }
+            return new Identifier(parametros);
+        }
+        
+        return new Identifier(null);
+    }
+    
+    public List<Expression> parseExpressionList(Token token_inicial, Token.Ids terminador) {
+        return null;
+    }
+    
+    public Expression parseExpression() {
+        return null;
     }
 }
diff --git a/src/parser/DeclarationStatement.java b/src/parser/DeclarationStatement.java
@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package parser;
+
+import java.util.List;
+
+/**
+ *
+ * @author Sebastian
+ */
+public class DeclarationStatement extends ParserStatement {
+    private List<Identifier> identifiers;
+    
+    public DeclarationStatement(List<Identifier> identifiers) {
+        this.identifiers = identifiers;
+    }
+}
diff --git a/src/parser/Expression.java b/src/parser/Expression.java
@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package parser;
+
+/**
+ *
+ * @author Sebastian
+ */
+public class Expression {
+    
+}
diff --git a/src/parser/Identifier.java b/src/parser/Identifier.java
@@ -0,0 +1,20 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package parser;
+
+import java.util.List;
+
+/**
+ *
+ * @author Sebastian
+ */
+public class Identifier {
+    private List<Expression> parameters;
+    
+    public Identifier(List<Expression> parameters) {
+        this.parameters = parameters;
+    }
+}
diff --git a/src/parser/NullStatement.java b/src/parser/NullStatement.java
@@ -0,0 +1,19 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package parser;
+
+import compiladorpseu.Tokens.Token;
+import java.util.List;
+
+/**
+ *
+ * @author Sebastian
+ */
+public class NullStatement extends ParserStatement {
+    public NullStatement() {
+
+    }
+}
diff --git a/src/parser/ParserStatement.java b/src/parser/ParserStatement.java
@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package parser;
+
+/**
+ *
+ * @author Sebastian
+ */
+public abstract class ParserStatement {
+    
+}
