Development

.gitignore

@@ -88,3 +88,4 @@ fabric.properties
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+/.metadata/

.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+
+
+        {
+            "type": "java",
+            "name": "Debug (Launch) - Current File",
+            "request": "launch",
+            "mainClass": "${file}"
+        },
+        {
+            "type": "java",
+            "name": "Debug (Launch)-Main<java>",
+            "request": "launch",
+            "mainClass": "Main",
+            "projectName": "java"
+        }
+    ]
+}

bin/test

@@ -0,0 +1,10 @@
+//this is a simple comment to test 
+
+x = /*fucking comment */ 10;
+int x = 10; //será que ignora?
+int y = 10;
+batata = 20;
+triangulo = 70;
+tri%%@ 43566¨
+
+=== 1/**/2

bin/test_preprocessed.txt

@@ -0,0 +1,11 @@
+
+
+x =  10;
+int x = 10; 
+int y = 10;
+batata = 20;
+triangulo = 70;
+tri%%@ 43566¨
+
+=== 12
+$

src/java/core/CompilerMain.java

@@ -0,0 +1,76 @@
+package core;
+
+import utils.LexicalError;
+import utils.Preprocessor;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * core.CompilerMain class.
+ *
+ * @author Leonardo-Rocha, Gabriel Chiquetto.
+ */
+public class CompilerMain {
+
+    public static void main(String[] args) throws IOException {
+
+        if (args.length > 0) {
+            File filePath = openFile(args[0]);
+
+            filePath = openFile(preprocessFile(filePath));
+
+            runTest(filePath);
+
+            LexicalError.computeErrorLog();
+
+            System.out.println("Process terminated.");
+        } else {
+            System.out.println("Please, insert a valid file path.");
+        }
+    }
+
+    /**
+     * @param path path of the file to be open.
+     * @return open file reference.
+     */
+    private static File openFile(String path) {
+        return new File(path);
+    }
+
+    /**
+     * Runs a test with the TokenGenerator to visually check if it's working.
+     *
+     * @param source file to run the token generator.
+     * @throws IOException if an error occurs during getNextToken().
+     */
+    private static void runTest(File source) throws IOException {
+        TokenGenerator tokenizer = new TokenGenerator(source);
+        Token currentToken = tokenizer.getNextToken();
+        while (!currentToken.equalsTokenType(TokenType.EOF)) {
+            currentToken.showCase();
+            currentToken = tokenizer.getNextToken();
+        }
+
+    }
+
+    /**
+     * @param rawSource source to preprocess.
+     * @return preprocessed file path.
+     */
+    private static String preprocessFile(File rawSource) {
+        System.out.println("Test file: " + rawSource.getAbsolutePath());
+        System.out.println("Pre-processing test file...");
+        try {
+            Preprocessor preprocessor = new Preprocessor();
+            preprocessor.preProcess(rawSource);
+            System.out.println("Preprocess successful.");
+        } catch (FileNotFoundException ex) {
+            System.out.println("Unable to open file '" + rawSource + "'");
+        } catch (IOException ex) {
+            System.out.println("Error reading file '" + rawSource + "'");
+        }
+        return rawSource + "_preprocessed.txt";
+    }
+}

src/java/core/Parser.java

@@ -0,0 +1,47 @@
+package core;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Parser {
+
+    private TokenGenerator tokenGenerator;
+
+    private Token currentToken;
+
+    private void advanceToken() throws IOException{
+        currentToken = this.tokenGenerator.getNextToken();
+    }
+
+    public Parser(File sourceCode) throws IOException {
+        tokenGenerator = new TokenGenerator(sourceCode);
+        advanceToken();
+    }
+
+    public void match(TokenType type){
+        //if(type != currentToken.getAttribute())
+    }
+
+    public void program(){
+        if(currentToken.equalsTokenType(TokenType.CLASS)){
+            classList();
+        }
+    }
+
+    private void classList(){
+        classDecl();
+        classListLinha();
+    }
+
+    private void classListLinha(){
+        if(currentToken.equalsTokenType(TokenType.CLASS)){
+            classList();
+        }
+    }
+
+    private void classDecl(){
+        //match(CLASS);
+        //match(IDENTIFIER);
+        //classDeclLinha();
+    }
+}

src/java/core/Token.java

@@ -0,0 +1,111 @@
+package core;
+
+/**
+ * This class represents every recognized single unit(token) of the source code.
+ * A token is a Pair <type, attribute> and the attribute is optional.
+ *
+ * @author Gabriel Chiquetto, Leonardo-Rocha
+ */
+class Token {
+    /**
+     * Abstract symbol that represents a type of lexical unit.
+     */
+    private final TokenType tokenType;
+    /**
+     * Optional value of a token.
+     */
+    private TokenType attribute;
+    /**
+     * Sequence of characters that represents the token in the source code.
+     */
+    private String lexeme;
+
+    /**
+     * Initializes a token with the main fields.
+     *
+     * @param tokenType type of the generated token.
+     * @param attribute value of the token.
+     */
+    public Token(TokenType tokenType, TokenType attribute) {
+        this.tokenType = tokenType;
+        this.attribute = attribute;
+    }
+
+    /**
+     * Initializes a token without an attribute.
+     *
+     * @param tokenType type of the generated token.
+     */
+    public Token(TokenType tokenType) {
+        this(tokenType, TokenType.UNDEF);
+    }
+
+    /**
+     * Override of equals method.
+     * @param obj Object to evaluate.
+     * @return true if they're equal.
+     */
+    @Override
+    public boolean equals(Object obj) {
+        Token token = (Token) obj;
+        return this.getTokenType() == token.getTokenType();
+    }
+
+    /**
+     * Compare token types.
+     * @param tokentype
+     * @return true if the type of this token equals the given token type.
+     */
+    public boolean equalsTokenType(TokenType tokentype){
+        return this.getTokenType() == tokentype;
+    }
+
+    /**
+     * Print token informations for debuggin purposes.
+     */
+    public void showCase() {
+        System.out.print("lexeme:" + this.getLexeme());
+        System.out.print(", core.TokenType: " + getTokenType());
+        System.out.println(", Attribute: " + getAttribute() + '.');
+    }
+
+    /**
+     * 
+     * @return type of the token.
+     */
+	public TokenType getTokenType() {
+		return tokenType;
+	}
+
+	/**
+	 * 
+	 * @return attribute of the token.
+	 */
+	public TokenType getAttribute() {
+		return attribute;
+	}
+
+    /**
+     * Set the value of the field attribute.
+     * @param attribute value to set.
+     */
+    public void setAttribute(TokenType attribute){
+        this.attribute = attribute;
+    }
+
+	/**
+	 * 
+	 * @return lexeme of the token.
+	 */
+	public String getLexeme() {
+		return lexeme;
+	}
+
+	/**
+	 * Should only be used once.
+	 * @param lexeme string to set.
+	 */
+	void setLexeme(String lexeme) {
+		this.lexeme = lexeme;
+	}
+}