Parser new

compiler/src/main/java/compiler/lexer/LexerException.java

@@ -15,4 +15,12 @@ public LexerException(String message, int line, int column, Throwable cause) {
         this.line = line;
         this.column = column;
     }
+
+    public int getLine() {
+        return line;
+    }
+
+    public int getColumn() {
+        return column;
+    }
 }

compiler/src/main/java/compiler/lexer/Token.java

@@ -25,6 +25,18 @@ public TokenType getType() {
         return type;
     }
 
+    public int getLine() {
+        return line;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public String getLexeme() {
+        return lexeme;
+    }
+
     public String toString() {
         return String.format("%s:%s@%d:%d", type, lexeme, line, column);
     }

compiler/src/main/java/compiler/parser/ArrayAccessNode.java

@@ -0,0 +1,27 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class ArrayAccessNode extends AstNode implements ExpressionNode {
+    private final ExpressionNode array;
+    private final ExpressionNode index;
+
+    public ArrayAccessNode(Token token, ExpressionNode array, ExpressionNode index) {
+        super(token);
+        this.array = array;
+        this.index = index;
+    }
+
+    public ExpressionNode getArray() {
+        return array;
+    }
+
+    public ExpressionNode getIndex() {
+        return index;
+    }
+
+    @Override
+    public String toString() {
+        return array + "[" + index + "]";
+    }
+}

compiler/src/main/java/compiler/parser/ArrayTypeNode.java

@@ -0,0 +1,28 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class ArrayTypeNode extends TypeNode {
+    private final ExpressionNode size; // can be null for []
+    private final TypeNode elementType;
+
+    public ArrayTypeNode(Token token, ExpressionNode size, TypeNode elementType) {
+        super(token);
+        this.size = size;
+        this.elementType = elementType;
+    }
+
+    public ExpressionNode getSize() {
+        return size;
+    }
+
+    public TypeNode getElementType() {
+        return elementType;
+    }
+
+    @Override
+    public String toString() {
+        String sizeStr = size != null ? "[" + size + "]" : "[]";
+        return "array" + sizeStr + " " + elementType;
+    }
+}

compiler/src/main/java/compiler/parser/AssignmentNode.java

@@ -0,0 +1,27 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class AssignmentNode extends AstNode implements StatementNode {
+    private final ExpressionNode target;
+    private final ExpressionNode value;
+
+    public AssignmentNode(Token token, ExpressionNode target, ExpressionNode value) {
+        super(token);
+        this.target = target;
+        this.value = value;
+    }
+
+    public ExpressionNode getTarget() {
+        return target;
+    }
+
+    public ExpressionNode getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return target + " := " + value;
+    }
+}

compiler/src/main/java/compiler/parser/AstNode.java

@@ -0,0 +1,25 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public abstract class AstNode {
+    private final Token token; // For position information
+
+    protected AstNode(Token token) {
+        this.token = token;
+    }
+
+    public Token getToken() {
+        return token;
+    }
+
+    public int getLine() {
+        return token.getLine();
+    }
+
+    public int getColumn() {
+        return token.getColumn();
+    }
+
+    public abstract String toString();
+}

compiler/src/main/java/compiler/parser/BinaryOpNode.java

@@ -0,0 +1,33 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class BinaryOpNode extends AstNode implements ExpressionNode {
+    private final Operator operator;
+    private final ExpressionNode left;
+    private final ExpressionNode right;
+
+    public BinaryOpNode(Token token, Operator operator, ExpressionNode left, ExpressionNode right) {
+        super(token);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+
+    public Operator getOperator() {
+        return operator;
+    }
+
+    public ExpressionNode getLeft() {
+        return left;
+    }
+
+    public ExpressionNode getRight() {
+        return right;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + left + " " + operator.name().toLowerCase() + " " + right + ")";
+    }
+}

compiler/src/main/java/compiler/parser/BooleanLiteralNode.java

@@ -0,0 +1,21 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class BooleanLiteralNode extends AstNode implements ExpressionNode {
+    private final boolean value;
+
+    public BooleanLiteralNode(Token token) {
+        super(token);
+        this.value = token.getType() == compiler.lexer.TokenType.TRUE;
+    }
+
+    public boolean getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+}

compiler/src/main/java/compiler/parser/ExpressionNode.java

@@ -0,0 +1,5 @@
+package compiler.parser;
+
+public interface ExpressionNode {
+    // Marker interface for expressions
+}

compiler/src/main/java/compiler/parser/FieldAccessNode.java

@@ -0,0 +1,27 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class FieldAccessNode extends AstNode implements ExpressionNode {
+    private final ExpressionNode record;
+    private final String fieldName;
+
+    public FieldAccessNode(Token token, ExpressionNode record, String fieldName) {
+        super(token);
+        this.record = record;
+        this.fieldName = fieldName;
+    }
+
+    public ExpressionNode getRecord() {
+        return record;
+    }
+
+    public String getFieldName() {
+        return fieldName;
+    }
+
+    @Override
+    public String toString() {
+        return record + "." + fieldName;
+    }
+}

compiler/src/main/java/compiler/parser/ForLoopNode.java

@@ -0,0 +1,61 @@
+package compiler.parser;
+
+import java.util.List;
+
+import compiler.lexer.Token;
+
+public class ForLoopNode extends AstNode implements StatementNode {
+    private final String variable;
+    private final ExpressionNode rangeStart;
+    private final ExpressionNode rangeEnd; // can be null
+    private final boolean reverse;
+    private final List<AstNode> body;
+
+    public ForLoopNode(Token token, String variable, ExpressionNode rangeStart, ExpressionNode rangeEnd,
+                       boolean reverse, List<AstNode> body) {
+        super(token);
+        this.variable = variable;
+        this.rangeStart = rangeStart;
+        this.rangeEnd = rangeEnd;
+        this.reverse = reverse;
+        this.body = body;
+    }
+
+    public String getVariable() {
+        return variable;
+    }
+
+    public ExpressionNode getRangeStart() {
+        return rangeStart;
+    }
+
+    public ExpressionNode getRangeEnd() {
+        return rangeEnd;
+    }
+
+    public boolean isReverse() {
+        return reverse;
+    }
+
+    public List<AstNode> getBody() {
+        return body;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("for ").append(variable).append(" in ");
+        sb.append(rangeStart);
+        if (rangeEnd != null) {
+            sb.append("..").append(rangeEnd);
+        }
+        if (reverse) {
+            sb.append(" reverse");
+        }
+        sb.append(" loop\n");
+        for (AstNode stmt : body) {
+            sb.append("  ").append(stmt).append("\n");
+        }
+        sb.append("end");
+        return sb.toString();
+    }
+}

compiler/src/main/java/compiler/parser/IfStatementNode.java

@@ -0,0 +1,46 @@
+package compiler.parser;
+
+import java.util.List;
+
+import compiler.lexer.Token;
+
+public class IfStatementNode extends AstNode implements StatementNode {
+    private final ExpressionNode condition;
+    private final List<AstNode> thenBody;
+    private final List<AstNode> elseBody; // can be null
+
+    public IfStatementNode(Token token, ExpressionNode condition, List<AstNode> thenBody, List<AstNode> elseBody) {
+        super(token);
+        this.condition = condition;
+        this.thenBody = thenBody;
+        this.elseBody = elseBody;
+    }
+
+    public ExpressionNode getCondition() {
+        return condition;
+    }
+
+    public List<AstNode> getThenBody() {
+        return thenBody;
+    }
+
+    public List<AstNode> getElseBody() {
+        return elseBody;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("if ").append(condition).append(" then\n");
+        for (AstNode stmt : thenBody) {
+            sb.append("  ").append(stmt).append("\n");
+        }
+        if (elseBody != null) {
+            sb.append("else\n");
+            for (AstNode stmt : elseBody) {
+                sb.append("  ").append(stmt).append("\n");
+            }
+        }
+        sb.append("end");
+        return sb.toString();
+    }
+}

compiler/src/main/java/compiler/parser/IntegerLiteralNode.java

@@ -0,0 +1,21 @@
+package compiler.parser;
+
+import compiler.lexer.Token;
+
+public class IntegerLiteralNode extends AstNode implements ExpressionNode {
+    private final int value;
+
+    public IntegerLiteralNode(Token token) {
+        super(token);
+        this.value = Integer.parseInt(token.getLexeme());
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(value);
+    }
+}

compiler/src/main/java/compiler/parser/Operator.java

@@ -0,0 +1,10 @@
+package compiler.parser;
+
+public enum Operator {
+    // Binary operators
+    PLUS, MINUS, MULTIPLY, DIVIDE, MODULO,
+    LESS, LESS_EQUAL, GREATER, GREATER_EQUAL, EQUAL, NOT_EQUAL,
+    AND, OR, XOR,
+    // Unary operators
+    NOT, UNARY_PLUS, UNARY_MINUS
+}