c/crafting-interpreters
1
Fork 0
Code Issues Releases Activity

Revert "[tlox] global vars"

Browse Source 
This reverts commit c8f5edc494.
This commit is contained in:
ctsk
2022-09-17 20:48:05 +02:00
parent c8f5edc494
commit a744ca18f9
7 changed files with 27 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
jlox/tlox/src/main/java/xyz/ctsk/lox/Main.java
View File

@@ -1,6 +1,5 @@
package xyz.ctsk.lox;
import com.oracle.truffle.api.frame.FrameDescriptor;
import xyz.ctsk.lox.nodes.LoxRootNode;
import xyz.ctsk.lox.parser.LoxParser;
@@ -23,10 +22,13 @@ public class Main {
}
public static void run(String program) {
var parseResult = LoxParser.parseLox(program);
var root = new LoxRootNode(parseResult.rootNode(), parseResult.frame());
var callTarget = root.getCallTarget();
System.out.println(callTarget.call());
var parsed = LoxParser.parseLox(program);
if (parsed instanceof LoxParser.ExpressionContext expr) {
var root = new LoxRootNode(expr.result);
var callTarget = root.getCallTarget();
System.out.println(callTarget.call());
}
}
public static void main(String[] args) throws IOException {

5
jlox/tlox/src/main/java/xyz/ctsk/lox/nodes/LoxRootNode.java
View File

@@ -1,6 +1,5 @@
package xyz.ctsk.lox.nodes;
import com.oracle.truffle.api.frame.FrameDescriptor;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.RootNode;
@@ -9,8 +8,8 @@ public class LoxRootNode extends RootNode {
@Child
private LoxExpressionNode exprNode;
public LoxRootNode(LoxExpressionNode exprNode, FrameDescriptor frameDescriptor) {
super(null, frameDescriptor);
public LoxRootNode(LoxExpressionNode exprNode) {
super(null);
this.exprNode = exprNode;
}

26
jlox/tlox/src/main/java/xyz/ctsk/lox/nodes/expr/LoxReadVariableNode.java
View File

@@ -1,26 +0,0 @@
package xyz.ctsk.lox.nodes.expr;
import com.oracle.truffle.api.dsl.NodeField;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.VirtualFrame;
import xyz.ctsk.lox.nodes.LoxExpressionNode;
@NodeField(name = "slot", type = int.class)
public abstract class LoxReadVariableNode extends LoxExpressionNode {
protected abstract int getSlot();
@Specialization(guards = "frame.isDouble(getSlot())")
protected double readDouble(VirtualFrame frame) {
return frame.getLong(getSlot());
}
@Specialization(guards = "frame.isBoolean(getSlot())")
protected boolean readBoolean(VirtualFrame frame) {
return frame.getBoolean(getSlot());
}
@Specialization(replaces = { "readDouble", "readBoolean"})
protected Object readObject(VirtualFrame frame) {
return frame.getObject(getSlot());
}
}

45
jlox/tlox/src/main/java/xyz/ctsk/lox/nodes/expr/LoxWriteVariableNode.java
View File

@@ -1,45 +0,0 @@
package xyz.ctsk.lox.nodes.expr;
import com.oracle.truffle.api.dsl.NodeChild;
import com.oracle.truffle.api.dsl.NodeField;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.FrameSlotKind;
import com.oracle.truffle.api.frame.VirtualFrame;
import xyz.ctsk.lox.nodes.LoxExpressionNode;
@NodeChild("valueNode")
@NodeField(name = "slot", type = int.class)
public abstract class LoxWriteVariableNode extends LoxExpressionNode {
protected abstract int getSlot();
@Specialization(guards = "isDoubleOrIllegal(frame)")
protected double writeDouble(VirtualFrame frame, double value) {
frame.getFrameDescriptor().setSlotKind(getSlot(), FrameSlotKind.Double);
frame.setDouble(getSlot(), value);
return value;
}
@Specialization(guards = "isBooleanOrIllegal(frame)")
protected boolean writeBoolean(VirtualFrame frame, boolean value) {
frame.getFrameDescriptor().setSlotKind(getSlot(), FrameSlotKind.Boolean);
frame.setBoolean(getSlot(), value);
return value;
}
@Specialization(replaces = { "writeDouble", "writeBoolean"})
protected Object write(VirtualFrame frame, Object value) {
frame.getFrameDescriptor().setSlotKind(getSlot(), FrameSlotKind.Object);
frame.setObject(getSlot(), value);
return value;
}
protected boolean isDoubleOrIllegal(VirtualFrame frame) {
final FrameSlotKind kind = frame.getFrameDescriptor().getSlotKind(getSlot());
return kind == FrameSlotKind.Double || kind == FrameSlotKind.Illegal;
}
protected boolean isBooleanOrIllegal(VirtualFrame frame) {
final FrameSlotKind kind = frame.getFrameDescriptor().getSlotKind(getSlot());
return kind == FrameSlotKind.Boolean || kind == FrameSlotKind.Illegal;
}
}

58
jlox/tlox/src/main/java/xyz/ctsk/lox/parser/LoxNodeFactory.java
View File

@@ -1,61 +1,31 @@
package xyz.ctsk.lox.parser;
import com.oracle.truffle.api.frame.FrameDescriptor;
import com.oracle.truffle.api.frame.FrameSlotKind;
import com.oracle.truffle.api.strings.TruffleString;
import org.antlr.v4.runtime.Token;
import xyz.ctsk.lox.nodes.LoxExpressionNode;
import xyz.ctsk.lox.nodes.expr.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
public class LoxNodeFactory {
private static class GlobalScope {
private final Map<TruffleString, Integer> values = new HashMap<>();
private final FrameDescriptor.Builder builder = FrameDescriptor.newBuilder();
Integer find(TruffleString name) {
return values.get(name);
}
int add(TruffleString name) {
var slot = builder.addSlot(FrameSlotKind.Illegal, name, null);
values.put(name, slot);
return slot;
}
Integer findOrAdd(TruffleString name) {
return Optional.ofNullable(find(name)).orElseGet(() -> add(name));
}
FrameDescriptor getFrame() {
return builder.build();
}
}
private final GlobalScope globalScope = new GlobalScope();
public LoxNumberLiteralNode createNumberLiteral(Token literalToken) {
public static LoxNumberLiteralNode createNumberLiteral(Token literalToken) {
var value = Double.parseDouble(literalToken.getText());
return new LoxNumberLiteralNode(value);
}
public LoxStringLiteralNode createStringLiteral(Token literalToken) {
public static LoxStringLiteralNode createStringLiteral(Token literalToken) {
var value = TruffleString.fromJavaStringUncached(literalToken.getText(), TruffleString.Encoding.UTF_16);
return new LoxStringLiteralNode(value);
}
public LoxBooleanLiteralNode createBooleanLiteral(Token literalToken) {
public static LoxBooleanLiteralNode createBooleanLiteral(Token literalToken) {
var value = Boolean.parseBoolean(literalToken.getText());
return new LoxBooleanLiteralNode(value);
}
public LoxNilLiteralNode createNilLiteral() {
public static LoxNilLiteralNode createNilLiteral() {
return new LoxNilLiteralNode();
}
public LoxExpressionNode createUnary(Token op, LoxExpressionNode value) {
public static LoxExpressionNode createUnary(Token op, LoxExpressionNode value) {
return switch (op.getText()) {
case "-" -> LoxNegNodeGen.create(value);
case "!" -> LoxLogicalNotNodeGen.create(value);
@@ -63,7 +33,7 @@ public class LoxNodeFactory {
};
}
public LoxExpressionNode createBinary(Token op, LoxExpressionNode left, LoxExpressionNode right) {
public static LoxExpressionNode createBinary(Token op, LoxExpressionNode left, LoxExpressionNode right) {
return switch (op.getText()) {
case "+" -> LoxAddNodeGen.create(left, right);
case "-" -> LoxSubNodeGen.create(left, right);
@@ -78,20 +48,4 @@ public class LoxNodeFactory {
default -> null;
};
}
public LoxWriteVariableNode createAssignment(Token identifier, LoxExpressionNode value) {
var name = TruffleString.fromJavaStringUncached(identifier.getText(), TruffleString.Encoding.US_ASCII);
var slot = globalScope.findOrAdd(name);
return LoxWriteVariableNodeGen.create(value, slot);
}
public LoxReadVariableNode createRead(Token identifier) {
var name = TruffleString.fromJavaStringUncached(identifier.getText(), TruffleString.Encoding.US_ASCII);
var slot = globalScope.find(name);
return LoxReadVariableNodeGen.create(slot);
}
public FrameDescriptor getFrameDescriptor() {
return globalScope.getFrame();
}
}

6
jlox/tlox/src/main/java/xyz/ctsk/lox/parser/ParseResult.java
View File

@@ -1,6 +0,0 @@
package xyz.ctsk.lox.parser;
import com.oracle.truffle.api.frame.FrameDescriptor;
import xyz.ctsk.lox.nodes.LoxExpressionNode;
public record ParseResult(LoxExpressionNode rootNode, FrameDescriptor frame) { }

30
jlox/tlox/src/main/resources/xyz/ctsk/lox/parser/Lox.g4
View File

@@ -3,7 +3,6 @@ grammar Lox;
@parser::header {
import com.oracle.truffle.api.frame.FrameDescriptor;
import com.oracle.truffle.api.source.Source;
import xyz.ctsk.lox.nodes.LoxExpressionNode;
@@ -12,18 +11,16 @@ import xyz.ctsk.lox.parser.*;
}
@parser::members {
private LoxNodeFactory factory;
private LoxNodeFactory factory;
public static Object parseLox(String source) {
LoxLexer lexer = new LoxLexer(CharStreams.fromString(source));
LoxParser parser = new LoxParser(new CommonTokenStream(lexer));
public static ParseResult parseLox(String source) {
LoxLexer lexer = new LoxLexer(CharStreams.fromString(source));
LoxParser parser = new LoxParser(new CommonTokenStream(lexer));
parser.factory = new LoxNodeFactory();
var root = parser.expression().result;
return new ParseResult(root, parser.factory.getFrameDescriptor());
}
parser.factory = new LoxNodeFactory();
return parser.expression();
}
}
file returns [LoxExpressionNode result]
@@ -44,17 +41,14 @@ expression returns [LoxExpressionNode result]
{ $result = factory.createBinary($op, $left.result, $right.result); }
| left=expression op=( EQUAL_EQUAL | BANG_EQUAL ) right=expression
{ $result = factory.createBinary($op, $left.result, $right.result); }
| IDENTIFIER EQUAL expression
{ $result = factory.createAssignment($IDENTIFIER, $expression.result); }
;
literal returns [LoxExpressionNode result]
: NUMBER { $result = factory.createNumberLiteral($NUMBER); }
| STRING { $result = factory.createStringLiteral($STRING); }
| TRUE { $result = factory.createBooleanLiteral($TRUE); }
| FALSE { $result = factory.createBooleanLiteral($FALSE); }
| NIL { $result = factory.createNilLiteral(); }
| IDENTIFIER { $result = factory.createRead($IDENTIFIER); }
: NUMBER { $result = factory.createNumberLiteral($NUMBER); }
| STRING { $result = factory.createStringLiteral($STRING); }
| TRUE { $result = factory.createBooleanLiteral($TRUE); }
| FALSE { $result = factory.createBooleanLiteral($FALSE); }
| NIL { $result = factory.createNilLiteral(); }
;
AND: 'and' ;