bobbylucero/Bob
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: bobbylucero:linux-cross-platform-fix
Branches Tags
bobbylucero:master
bobbylucero:development
bobbylucero:linux-cross-platform-fix
..
compare: bobbylucero:master
Branches Tags
bobbylucero:development
bobbylucero:linux-cross-platform-fix
bobbylucero:master

No commits in common. "linux-cross-platform-fix" and "master" have entirely different histories.
linux-cros ... master

7 changed files with 25 additions and 153 deletions
Show Stats Expand all files Collapse all files

47
headers/Interpreter.h
View File

@ -12,46 +12,6 @@
#include <memory>
#include <unordered_map>
#include <stack>
#include <optional>
#include <functional>
// Forward declaration
class Interpreter;
// RAII helper for thunk execution flag
struct ScopedThunkFlag {
bool& flag;
bool prev;
ScopedThunkFlag(bool& f) : flag(f), prev(f) { flag = true; }
~ScopedThunkFlag() { flag = prev; }
};
// RAII helper for environment management
struct ScopedEnv {
std::shared_ptr<Environment>& target;
std::shared_ptr<Environment> prev;
ScopedEnv(std::shared_ptr<Environment>& e) : target(e), prev(e) {}
~ScopedEnv() { target = prev; }
};
// Thunk class for trampoline-based tail call optimization
class Thunk {
public:
using ThunkFunction = std::function<Value()>;
explicit Thunk(ThunkFunction func) : func(std::move(func)) {}
Value execute() const {
return func();
}
bool isThunk() const { return true; }
private:
ThunkFunction func;
};
class Interpreter : public ExprVisitor, public StmtVisitor {
@ -86,21 +46,14 @@ private:
std::vector<std::shared_ptr<BuiltinFunction> > builtinFunctions;
std::vector<std::shared_ptr<Function> > functions;
ErrorReporter* errorReporter;
bool inThunkExecution = false;
Value evaluate(const std::shared_ptr<Expr>& expr);
Value evaluateWithoutTrampoline(const std::shared_ptr<Expr>& expr);
bool isEqual(Value a, Value b);
bool isWholeNumer(double num);
void execute(const std::shared_ptr<Stmt>& statement, ExecutionContext* context = nullptr);
void executeBlock(std::vector<std::shared_ptr<Stmt> > statements, std::shared_ptr<Environment> env, ExecutionContext* context = nullptr);
void addStdLibFunctions();
// Trampoline execution
Value runTrampoline(Value initialResult);
public:
bool isTruthy(Value object);
std::string stringify(Value object);

13
headers/Value.h
View File

@ -11,17 +11,15 @@
class Environment;
class Function;
class BuiltinFunction;
class Thunk;
// Type tags for the Value union
enum ValueType {
enum ValueType : uint8_t {
VAL_NONE,
VAL_NUMBER,
VAL_BOOLEAN,
VAL_STRING,
VAL_FUNCTION,
VAL_BUILTIN_FUNCTION,
VAL_THUNK
VAL_BUILTIN_FUNCTION
};
// Tagged value system (like Lua) - no heap allocation for simple values
@ -31,7 +29,6 @@ struct Value {
bool boolean;
Function* function;
BuiltinFunction* builtin_function;
Thunk* thunk;
};
ValueType type;
std::string string_value; // Store strings outside the union for safety
@ -45,7 +42,6 @@ struct Value {
Value(std::string&& s) : type(ValueType::VAL_STRING), string_value(std::move(s)) {}
Value(Function* f) : function(f), type(ValueType::VAL_FUNCTION) {}
Value(BuiltinFunction* bf) : builtin_function(bf), type(ValueType::VAL_BUILTIN_FUNCTION) {}
Value(Thunk* t) : thunk(t), type(ValueType::VAL_THUNK) {}
// Move constructor
Value(Value&& other) noexcept
@ -98,7 +94,6 @@ struct Value {
inline bool isString() const { return type == ValueType::VAL_STRING; }
inline bool isFunction() const { return type == ValueType::VAL_FUNCTION; }
inline bool isBuiltinFunction() const { return type == ValueType::VAL_BUILTIN_FUNCTION; }
inline bool isThunk() const { return type == ValueType::VAL_THUNK; }
inline bool isNone() const { return type == ValueType::VAL_NONE; }
// Value extraction (safe, with type checking) - inline for performance
@ -107,7 +102,6 @@ struct Value {
inline const std::string& asString() const { return string_value; }
inline Function* asFunction() const { return isFunction() ? function : nullptr; }
inline BuiltinFunction* asBuiltinFunction() const { return isBuiltinFunction() ? builtin_function : nullptr; }
inline Thunk* asThunk() const { return isThunk() ? thunk : nullptr; }
// Truthiness check - inline for performance
inline bool isTruthy() const {
@ -118,7 +112,6 @@ struct Value {
case ValueType::VAL_STRING: return !string_value.empty();
case ValueType::VAL_FUNCTION: return function != nullptr;
case ValueType::VAL_BUILTIN_FUNCTION: return builtin_function != nullptr;
case ValueType::VAL_THUNK: return thunk != nullptr;
default: return false;
}
}
@ -134,7 +127,6 @@ struct Value {
case ValueType::VAL_STRING: return string_value == other.string_value;
case ValueType::VAL_FUNCTION: return function == other.function;
case ValueType::VAL_BUILTIN_FUNCTION: return builtin_function == other.builtin_function;
case ValueType::VAL_THUNK: return thunk == other.thunk;
default: return false;
}
}
@ -159,7 +151,6 @@ struct Value {
case ValueType::VAL_STRING: return string_value;
case ValueType::VAL_FUNCTION: return "<function>";
case ValueType::VAL_BUILTIN_FUNCTION: return "<builtin_function>";
case ValueType::VAL_THUNK: return "<thunk>";
default: return "unknown";
}
}

2
headers/bob.h
View File

@ -8,7 +8,7 @@
#include "../headers/helperFunctions/ShortHands.h"
#include "../headers/ErrorReporter.h"
#define VERSION "0.0.2"
#define VERSION "0.0.1"
class Bob
{

65
source/Interpreter.cpp
View File

@ -24,10 +24,6 @@ struct ReturnContext {
ReturnContext() : returnValue(NONE_VALUE), hasReturn(false) {}
};
// Trampoline-based tail call optimization - no exceptions needed
Value Interpreter::visitLiteralExpr(const std::shared_ptr<LiteralExpr>& expr) {
if(expr->isNull) return NONE_VALUE;
@ -600,12 +596,7 @@ Value Interpreter::visitCallExpr(const std::shared_ptr<CallExpr>& expression) {
" arguments but got " + std::to_string(arguments.size()) + ".");
}
// Check if this is a tail call
if (expression->isTailCall) {
// Create a thunk for tail call optimization
auto thunk = new Thunk([this, function, arguments]() -> Value {
// Use RAII to manage environment
ScopedEnv _env(environment);
auto previousEnv = environment;
environment = std::make_shared<Environment>(function->closure);
environment->setErrorReporter(errorReporter);
@ -616,45 +607,16 @@ Value Interpreter::visitCallExpr(const std::shared_ptr<CallExpr>& expression) {
ExecutionContext context;
context.isFunctionBody = true;
// Use RAII to manage thunk execution flag
ScopedThunkFlag _inThunk(inThunkExecution);
// Execute function body
for (const auto& stmt : function->body) {
execute(stmt, &context);
if (context.hasReturn) {
environment = previousEnv;
return context.returnValue;
}
}
environment = previousEnv;
return context.returnValue;
});
// Return the thunk as a Value
return Value(thunk);
} else {
// Normal function call - create new environment
ScopedEnv _env(environment);
environment = std::make_shared<Environment>(function->closure);
environment->setErrorReporter(errorReporter);
for (size_t i = 0; i < function->params.size(); i++) {
environment->define(function->params[i], arguments[i]);
}
ExecutionContext context;
context.isFunctionBody = true;
// Execute function body
for (const auto& stmt : function->body) {
execute(stmt, &context);
if (context.hasReturn) {
return context.returnValue;
}
}
return context.returnValue;
}
}
throw std::runtime_error("Can only call functions and classes.");
@ -720,8 +682,6 @@ void Interpreter::visitReturnStmt(const std::shared_ptr<ReturnStmt>& statement,
{
Value value = NONE_VALUE;
if (statement->value != nullptr) {
// For tail calls, the trampoline handling is done in visitCallExpr
// We just need to evaluate normally
value = evaluate(statement->value);
}
@ -771,28 +731,9 @@ void Interpreter::executeBlock(std::vector<std::shared_ptr<Stmt> > statements, s
}
Value Interpreter::evaluate(const std::shared_ptr<Expr>& expr) {
Value result = expr->accept(this);
if (inThunkExecution) {
return result; // Don't use trampoline when inside a thunk
}
return runTrampoline(result);
}
Value Interpreter::evaluateWithoutTrampoline(const std::shared_ptr<Expr>& expr) {
return expr->accept(this);
}
Value Interpreter::runTrampoline(Value initialResult) {
Value current = initialResult;
while (current.isThunk()) {
// Execute the thunk to get the next result
current = current.asThunk()->execute();
}
return current;
}
bool Interpreter::isTruthy(Value object) {
if(object.isBoolean())

2
source/Lexer.cpp
View File

@ -421,7 +421,7 @@ std::vector<Token> Lexer::Tokenize(std::string source){
}
}
tokens.push_back({END_OF_FILE, "eof", line, column});
tokens.push_back({END_OF_FILE, "eof", line});
return tokens;
}

2
source/bob.cpp
View File

@ -33,7 +33,7 @@ void Bob::runPrompt()
{
this->interpreter = msptr(Interpreter)(true);
cout << "Bob v" << VERSION << ", 2025" << endl;
cout << "Bob v" << VERSION << ", 2023" << endl;
for(;;)
{
string line;

13
tco.bob
View File

@ -1,13 +0,0 @@
func countdown(n)
{
if(n == 0)
return 0;
print(n);
return countdown(n - 1);
}
countdown(1000000);